@keep-network/tbtc-v2 1.6.0-dev.0 → 1.6.0-dev.1

package/export/artifacts/contracts/test/WormholeBridgeStub.sol/WormholeBridgeStub.json

@@ -364,8 +364,8 @@
       "type": "function"
     }
   ],
-  "bytecode": "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",
-  "deployedBytecode": "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",
+  "bytecode": "0x608060405234801561001057600080fd5b50604051610b08380380610b0883398101604081905261002f91610054565b600080546001600160a01b0319166001600160a01b0392909216919091179055610084565b60006020828403121561006657600080fd5b81516001600160a01b038116811461007d57600080fd5b9392505050565b610a75806100936000396000f3fe6080604052600436106100b15760003560e01c8063c3f511c111610069578063e566df311161004e578063e566df31146101bb578063ea63738d146101db578063efcb70c01461020857600080fd5b8063c3f511c11461017b578063c5a5ebda146101a857600080fd5b8063504d27fd1161009a578063504d27fd1461010b57806381c82233146101215780639542c9f11461014357600080fd5b80630f5287b0146100b657806316fed3e2146100e7575b600080fd5b6100c96100c4366004610577565b610228565b60405167ffffffffffffffff90911681526020015b60405180910390f35b3480156100f357600080fd5b506100fd60025481565b6040519081526020016100de565b34801561011757600080fd5b506100fd60015481565b34801561012d57600080fd5b5061014161013c3660046105d8565b600155565b005b34801561014f57600080fd5b50600054610163906001600160a01b031681565b6040516001600160a01b0390911681526020016100de565b34801561018757600080fd5b5061019b6101963660046106f9565b6102a0565b6040516100de9190610786565b6100c96101b63660046107a0565b61041e565b3480156101c757600080fd5b506101416101d63660046105d8565b600255565b3480156101e757600080fd5b506101fb6101f63660046106f9565b61046f565b6040516100de9190610823565b34801561021457600080fd5b5061014161022336600461089b565b6104ca565b604080516001600160a01b03881681526020810187905261ffff861681830152606081018590526080810184905263ffffffff831660a082015290516000917f4d24ef3f381c3d7e8696045268f69c41ec3dee2c5bd1aaa48daf8ec2ec7fe436919081900360c00190a1506103099695505050505050565b60607f6efaccd86b6ce8325db6ad038d68e09f9b1af9a0fc1ed121ebe9d870aafc2086826040516102d19190610786565b60405180910390a16000546001546040516340c10f1960e01b815233600482015260248101919091526001600160a01b03909116906340c10f1990604401600060405180830381600087803b15801561032957600080fd5b505af115801561033d573d6000803e3d6000fd5b5050604080516101008101825260018152600260208083018290527f300000000000000000000000000000000000000000000000000000000000000083850152600460608401527f50000000000000000000000000000000000000000000000000000000000000006080840152600660a08401527f700000000000000000000000000000000000000000000000000000000000000060c08401529054835180830191909152835180820383018152908401845260e083015291519093506104079250839101610823565b604051602081830303815290604052915050919050565b60007f8f36aa28e4f86a5b6d397422d004b60e74eda866a331d074749b789d70ca3144878787878787604051610459969594939291906108c5565b60405180910390a1506103789695505050505050565b60408051610100810182526000808252602080830182905292820181905260608083018290526080830182905260a0830182905260c083019190915260e0820152825190916104c49184018101908401610976565b92915050565b6000546040516340c10f1960e01b81526001600160a01b03848116600483015260248201849052909116906340c10f1990604401600060405180830381600087803b15801561051857600080fd5b505af115801561052c573d6000803e3d6000fd5b505050505050565b80356001600160a01b038116811461054b57600080fd5b919050565b61ffff8116811461056057600080fd5b50565b803563ffffffff8116811461054b57600080fd5b60008060008060008060c0878903121561059057600080fd5b61059987610534565b95506020870135945060408701356105b081610550565b935060608701359250608087013591506105cc60a08801610563565b90509295509295509295565b6000602082840312156105ea57600080fd5b5035919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b604051610100810167ffffffffffffffff81118282101715610644576106446105f1565b60405290565b604051601f8201601f1916810167ffffffffffffffff81118282101715610673576106736105f1565b604052919050565b600067ffffffffffffffff821115610695576106956105f1565b50601f01601f191660200190565b600082601f8301126106b457600080fd5b81356106c76106c28261067b565b61064a565b8181528460208386010111156106dc57600080fd5b816020850160208301376000918101602001919091529392505050565b60006020828403121561070b57600080fd5b813567ffffffffffffffff81111561072257600080fd5b61072e848285016106a3565b949350505050565b60005b83811015610751578181015183820152602001610739565b50506000910152565b60008151808452610772816020860160208601610736565b601f01601f19169290920160200192915050565b602081526000610799602083018461075a565b9392505050565b60008060008060008060c087890312156107b957600080fd5b6107c287610534565b95506020870135945060408701356107d981610550565b9350606087013592506107ee60808801610563565b915060a087013567ffffffffffffffff81111561080a57600080fd5b61081689828a016106a3565b9150509295509295509295565b6020815260ff8251166020820152602082015160408201526040820151606082015261ffff6060830151166080820152608082015160a0820152600060a083015161087460c084018261ffff169052565b5060c083015160e083015260e083015161010080818501525061072e61012084018261075a565b600080604083850312156108ae57600080fd5b6108b783610534565b946020939093013593505050565b6001600160a01b038716815285602082015261ffff8516604082015283606082015263ffffffff8316608082015260c060a0820152600061090960c083018461075a565b98975050505050505050565b805160ff8116811461054b57600080fd5b805161054b81610550565b600082601f83011261094257600080fd5b81516109506106c28261067b565b81815284602083860101111561096557600080fd5b61072e826020830160208701610736565b60006020828403121561098857600080fd5b815167ffffffffffffffff808211156109a057600080fd5b9083019061010082860312156109b557600080fd5b6109bd610620565b6109c683610915565b815260208301516020820152604083015160408201526109e860608401610926565b606082015260808301516080820152610a0360a08401610926565b60a082015260c083015160c082015260e083015182811115610a2457600080fd5b610a3087828601610931565b60e0830152509594505050505056fea2646970667358221220913de8d1db6fa583b976d45f865e25f5fd92a6626c1bddca76ad1d23088eee1764736f6c63430008110033",
+  "deployedBytecode": "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",
   "linkReferences": {},
   "deployedLinkReferences": {},
   "devdoc": {
@@ -377,13 +377,13 @@
   "evm": {
     "bytecode": {
       "functionDebugData": {
-        "@_41169": {
+        "@_41125": {
           "entryPoint": null,
-          "id": 41169,
+          "id": 41125,
           "parameterSlots": 1,
           "returnSlots": 0
         },
-        "abi_decode_tuple_t_contract$_TestERC20_$41058_fromMemory": {
+        "abi_decode_tuple_t_contract$_TestERC20_$41014_fromMemory": {
           "entryPoint": 84,
           "id": null,
           "parameterSlots": 2,
@@ -655,7 +655,7 @@
                     }
                   ]
                 },
-                "name": "abi_decode_tuple_t_contract$_TestERC20_$41058_fromMemory",
+                "name": "abi_decode_tuple_t_contract$_TestERC20_$41014_fromMemory",
                 "nodeType": "YulFunctionDefinition",
                 "parameters": [
                   {
@@ -683,75 +683,75 @@
               }
             ]
           },
-          "contents": "{\n    { }\n    function abi_decode_tuple_t_contract$_TestERC20_$41058_fromMemory(headStart, dataEnd) -> value0\n    {\n        if slt(sub(dataEnd, headStart), 32) { revert(0, 0) }\n        let value := mload(headStart)\n        if iszero(eq(value, and(value, sub(shl(160, 1), 1)))) { revert(0, 0) }\n        value0 := value\n    }\n}",
+          "contents": "{\n    { }\n    function abi_decode_tuple_t_contract$_TestERC20_$41014_fromMemory(headStart, dataEnd) -> value0\n    {\n        if slt(sub(dataEnd, headStart), 32) { revert(0, 0) }\n        let value := mload(headStart)\n        if iszero(eq(value, and(value, sub(shl(160, 1), 1)))) { revert(0, 0) }\n        value0 := value\n    }\n}",
           "id": 125,
           "language": "Yul",
           "name": "#utility.yul"
         }
       ],
       "linkReferences": {},
-      "opcodes": "PUSH1 0x80 PUSH1 0x40 MSTORE CALLVALUE DUP1 ISZERO PUSH2 0x10 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH1 0x40 MLOAD PUSH2 0xB08 CODESIZE SUB DUP1 PUSH2 0xB08 DUP4 CODECOPY DUP2 ADD PUSH1 0x40 DUP2 SWAP1 MSTORE PUSH2 0x2F SWAP2 PUSH2 0x54 JUMP JUMPDEST PUSH1 0x0 DUP1 SLOAD PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB NOT AND PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB SWAP3 SWAP1 SWAP3 AND SWAP2 SWAP1 SWAP2 OR SWAP1 SSTORE PUSH2 0x84 JUMP JUMPDEST PUSH1 0x0 PUSH1 0x20 DUP3 DUP5 SUB SLT ISZERO PUSH2 0x66 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP2 MLOAD PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB DUP2 AND DUP2 EQ PUSH2 0x7D JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST SWAP4 SWAP3 POP POP POP JUMP JUMPDEST PUSH2 0xA75 DUP1 PUSH2 0x93 PUSH1 0x0 CODECOPY PUSH1 0x0 RETURN INVALID PUSH1 0x80 PUSH1 0x40 MSTORE PUSH1 0x4 CALLDATASIZE LT PUSH2 0xB1 JUMPI PUSH1 0x0 CALLDATALOAD PUSH1 0xE0 SHR DUP1 PUSH4 0xC3F511C1 GT PUSH2 0x69 JUMPI DUP1 PUSH4 0xE566DF31 GT PUSH2 0x4E JUMPI DUP1 PUSH4 0xE566DF31 EQ PUSH2 0x1BB JUMPI DUP1 PUSH4 0xEA63738D EQ PUSH2 0x1DB JUMPI DUP1 PUSH4 0xEFCB70C0 EQ PUSH2 0x208 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP1 PUSH4 0xC3F511C1 EQ PUSH2 0x17B JUMPI DUP1 PUSH4 0xC5A5EBDA EQ PUSH2 0x1A8 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP1 PUSH4 0x504D27FD GT PUSH2 0x9A JUMPI DUP1 PUSH4 0x504D27FD EQ PUSH2 0x10B JUMPI DUP1 PUSH4 0x81C82233 EQ PUSH2 0x121 JUMPI DUP1 PUSH4 0x9542C9F1 EQ PUSH2 0x143 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP1 PUSH4 0xF5287B0 EQ PUSH2 0xB6 JUMPI DUP1 PUSH4 0x16FED3E2 EQ PUSH2 0xE7 JUMPI JUMPDEST PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0xC9 PUSH2 0xC4 CALLDATASIZE PUSH1 0x4 PUSH2 0x577 JUMP JUMPDEST PUSH2 0x228 JUMP JUMPDEST PUSH1 0x40 MLOAD PUSH8 0xFFFFFFFFFFFFFFFF SWAP1 SWAP2 AND DUP2 MSTORE PUSH1 0x20 ADD JUMPDEST PUSH1 0x40 MLOAD DUP1 SWAP2 SUB SWAP1 RETURN JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0xF3 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0xFD PUSH1 0x2 SLOAD DUP2 JUMP JUMPDEST PUSH1 0x40 MLOAD SWAP1 DUP2 MSTORE PUSH1 0x20 ADD PUSH2 0xDE JUMP JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x117 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0xFD PUSH1 0x1 SLOAD DUP2 JUMP JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x12D JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0x141 PUSH2 0x13C CALLDATASIZE PUSH1 0x4 PUSH2 0x5D8 JUMP JUMPDEST PUSH1 0x1 SSTORE JUMP JUMPDEST STOP JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x14F JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH1 0x0 SLOAD PUSH2 0x163 SWAP1 PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB AND DUP2 JUMP JUMPDEST PUSH1 0x40 MLOAD PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB SWAP1 SWAP2 AND DUP2 MSTORE PUSH1 0x20 ADD PUSH2 0xDE JUMP JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x187 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0x19B PUSH2 0x196 CALLDATASIZE PUSH1 0x4 PUSH2 0x6F9 JUMP JUMPDEST PUSH2 0x2A0 JUMP JUMPDEST PUSH1 0x40 MLOAD PUSH2 0xDE SWAP2 SWAP1 PUSH2 0x786 JUMP JUMPDEST PUSH2 0xC9 PUSH2 0x1B6 CALLDATASIZE PUSH1 0x4 PUSH2 0x7A0 JUMP JUMPDEST PUSH2 0x41E JUMP JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x1C7 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0x141 PUSH2 0x1D6 CALLDATASIZE PUSH1 0x4 PUSH2 0x5D8 JUMP JUMPDEST PUSH1 0x2 SSTORE JUMP JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x1E7 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0x1FB PUSH2 0x1F6 CALLDATASIZE PUSH1 0x4 PUSH2 0x6F9 JUMP JUMPDEST PUSH2 0x46F JUMP JUMPDEST PUSH1 0x40 MLOAD PUSH2 0xDE SWAP2 SWAP1 PUSH2 0x823 JUMP JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x214 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0x141 PUSH2 0x223 CALLDATASIZE PUSH1 0x4 PUSH2 0x89B JUMP JUMPDEST PUSH2 0x4CA JUMP JUMPDEST PUSH1 0x40 DUP1 MLOAD PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB DUP9 AND DUP2 MSTORE PUSH1 0x20 DUP2 ADD DUP8 SWAP1 MSTORE PUSH2 0xFFFF DUP7 AND DUP2 DUP4 ADD MSTORE PUSH1 0x60 DUP2 ADD DUP6 SWAP1 MSTORE PUSH1 0x80 DUP2 ADD DUP5 SWAP1 MSTORE PUSH4 0xFFFFFFFF DUP4 AND PUSH1 0xA0 DUP3 ADD MSTORE SWAP1 MLOAD PUSH1 0x0 SWAP2 PUSH32 0x4D24EF3F381C3D7E8696045268F69C41EC3DEE2C5BD1AAA48DAF8EC2EC7FE436 SWAP2 SWAP1 DUP2 SWAP1 SUB PUSH1 0xC0 ADD SWAP1 LOG1 POP PUSH2 0x309 SWAP7 SWAP6 POP POP POP POP POP POP JUMP JUMPDEST PUSH1 0x60 PUSH32 0x6EFACCD86B6CE8325DB6AD038D68E09F9B1AF9A0FC1ED121EBE9D870AAFC2086 DUP3 PUSH1 0x40 MLOAD PUSH2 0x2D1 SWAP2 SWAP1 PUSH2 0x786 JUMP JUMPDEST PUSH1 0x40 MLOAD DUP1 SWAP2 SUB SWAP1 LOG1 PUSH1 0x0 SLOAD PUSH1 0x1 SLOAD PUSH1 0x40 MLOAD PUSH4 0x40C10F19 PUSH1 0xE0 SHL DUP2 MSTORE CALLER PUSH1 0x4 DUP3 ADD MSTORE PUSH1 0x24 DUP2 ADD SWAP2 SWAP1 SWAP2 MSTORE PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB SWAP1 SWAP2 AND SWAP1 PUSH4 0x40C10F19 SWAP1 PUSH1 0x44 ADD PUSH1 0x0 PUSH1 0x40 MLOAD DUP1 DUP4 SUB DUP2 PUSH1 0x0 DUP8 DUP1 EXTCODESIZE ISZERO DUP1 ISZERO PUSH2 0x329 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP GAS CALL ISZERO DUP1 ISZERO PUSH2 0x33D JUMPI RETURNDATASIZE PUSH1 0x0 DUP1 RETURNDATACOPY RETURNDATASIZE PUSH1 0x0 REVERT JUMPDEST POP POP PUSH1 0x40 DUP1 MLOAD PUSH2 0x100 DUP2 ADD DUP3 MSTORE PUSH1 0x1 DUP2 MSTORE PUSH1 0x2 PUSH1 0x20 DUP1 DUP4 ADD DUP3 SWAP1 MSTORE PUSH32 0x3000000000000000000000000000000000000000000000000000000000000000 DUP4 DUP6 ADD MSTORE PUSH1 0x4 PUSH1 0x60 DUP5 ADD MSTORE PUSH32 0x5000000000000000000000000000000000000000000000000000000000000000 PUSH1 0x80 DUP5 ADD MSTORE PUSH1 0x6 PUSH1 0xA0 DUP5 ADD MSTORE PUSH32 0x7000000000000000000000000000000000000000000000000000000000000000 PUSH1 0xC0 DUP5 ADD MSTORE SWAP1 SLOAD DUP4 MLOAD DUP1 DUP4 ADD SWAP2 SWAP1 SWAP2 MSTORE DUP4 MLOAD DUP1 DUP3 SUB DUP4 ADD DUP2 MSTORE SWAP1 DUP5 ADD DUP5 MSTORE PUSH1 0xE0 DUP4 ADD MSTORE SWAP2 MLOAD SWAP1 SWAP4 POP PUSH2 0x407 SWAP3 POP DUP4 SWAP2 ADD PUSH2 0x823 JUMP JUMPDEST PUSH1 0x40 MLOAD PUSH1 0x20 DUP2 DUP4 SUB SUB DUP2 MSTORE SWAP1 PUSH1 0x40 MSTORE SWAP2 POP POP SWAP2 SWAP1 POP JUMP JUMPDEST PUSH1 0x0 PUSH32 0x8F36AA28E4F86A5B6D397422D004B60E74EDA866A331D074749B789D70CA3144 DUP8 DUP8 DUP8 DUP8 DUP8 DUP8 PUSH1 0x40 MLOAD PUSH2 0x459 SWAP7 SWAP6 SWAP5 SWAP4 SWAP3 SWAP2 SWAP1 PUSH2 0x8C5 JUMP JUMPDEST PUSH1 0x40 MLOAD DUP1 SWAP2 SUB SWAP1 LOG1 POP PUSH2 0x378 SWAP7 SWAP6 POP POP POP POP POP POP JUMP JUMPDEST PUSH1 0x40 DUP1 MLOAD PUSH2 0x100 DUP2 ADD DUP3 MSTORE PUSH1 0x0 DUP1 DUP3 MSTORE PUSH1 0x20 DUP1 DUP4 ADD DUP3 SWAP1 MSTORE SWAP3 DUP3 ADD DUP2 SWAP1 MSTORE PUSH1 0x60 DUP1 DUP4 ADD DUP3 SWAP1 MSTORE PUSH1 0x80 DUP4 ADD DUP3 SWAP1 MSTORE PUSH1 0xA0 DUP4 ADD DUP3 SWAP1 MSTORE PUSH1 0xC0 DUP4 ADD SWAP2 SWAP1 SWAP2 MSTORE PUSH1 0xE0 DUP3 ADD MSTORE DUP3 MLOAD SWAP1 SWAP2 PUSH2 0x4C4 SWAP2 DUP5 ADD DUP2 ADD SWAP1 DUP5 ADD PUSH2 0x976 JUMP JUMPDEST SWAP3 SWAP2 POP POP JUMP JUMPDEST PUSH1 0x0 SLOAD PUSH1 0x40 MLOAD PUSH4 0x40C10F19 PUSH1 0xE0 SHL DUP2 MSTORE PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB DUP5 DUP2 AND PUSH1 0x4 DUP4 ADD MSTORE PUSH1 0x24 DUP3 ADD DUP5 SWAP1 MSTORE SWAP1 SWAP2 AND SWAP1 PUSH4 0x40C10F19 SWAP1 PUSH1 0x44 ADD PUSH1 0x0 PUSH1 0x40 MLOAD DUP1 DUP4 SUB DUP2 PUSH1 0x0 DUP8 DUP1 EXTCODESIZE ISZERO DUP1 ISZERO PUSH2 0x518 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP GAS CALL ISZERO DUP1 ISZERO PUSH2 0x52C JUMPI RETURNDATASIZE PUSH1 0x0 DUP1 RETURNDATACOPY RETURNDATASIZE PUSH1 0x0 REVERT JUMPDEST POP POP POP POP POP POP JUMP JUMPDEST DUP1 CALLDATALOAD PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB DUP2 AND DUP2 EQ PUSH2 0x54B JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST SWAP2 SWAP1 POP JUMP JUMPDEST PUSH2 0xFFFF DUP2 AND DUP2 EQ PUSH2 0x560 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP JUMP JUMPDEST DUP1 CALLDATALOAD PUSH4 0xFFFFFFFF DUP2 AND DUP2 EQ PUSH2 0x54B JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH1 0x0 DUP1 PUSH1 0x0 DUP1 PUSH1 0x0 DUP1 PUSH1 0xC0 DUP8 DUP10 SUB SLT ISZERO PUSH2 0x590 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0x599 DUP8 PUSH2 0x534 JUMP JUMPDEST SWAP6 POP PUSH1 0x20 DUP8 ADD CALLDATALOAD SWAP5 POP PUSH1 0x40 DUP8 ADD CALLDATALOAD PUSH2 0x5B0 DUP2 PUSH2 0x550 JUMP JUMPDEST SWAP4 POP PUSH1 0x60 DUP8 ADD CALLDATALOAD SWAP3 POP PUSH1 0x80 DUP8 ADD CALLDATALOAD SWAP2 POP PUSH2 0x5CC PUSH1 0xA0 DUP9 ADD PUSH2 0x563 JUMP JUMPDEST SWAP1 POP SWAP3 SWAP6 POP SWAP3 SWAP6 POP SWAP3 SWAP6 JUMP JUMPDEST PUSH1 0x0 PUSH1 0x20 DUP3 DUP5 SUB SLT ISZERO PUSH2 0x5EA JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP CALLDATALOAD SWAP2 SWAP1 POP JUMP JUMPDEST PUSH32 0x4E487B7100000000000000000000000000000000000000000000000000000000 PUSH1 0x0 MSTORE PUSH1 0x41 PUSH1 0x4 MSTORE PUSH1 0x24 PUSH1 0x0 REVERT JUMPDEST PUSH1 0x40 MLOAD PUSH2 0x100 DUP2 ADD PUSH8 0xFFFFFFFFFFFFFFFF DUP2 GT DUP3 DUP3 LT OR ISZERO PUSH2 0x644 JUMPI PUSH2 0x644 PUSH2 0x5F1 JUMP JUMPDEST PUSH1 0x40 MSTORE SWAP1 JUMP JUMPDEST PUSH1 0x40 MLOAD PUSH1 0x1F DUP3 ADD PUSH1 0x1F NOT AND DUP2 ADD PUSH8 0xFFFFFFFFFFFFFFFF DUP2 GT DUP3 DUP3 LT OR ISZERO PUSH2 0x673 JUMPI PUSH2 0x673 PUSH2 0x5F1 JUMP JUMPDEST PUSH1 0x40 MSTORE SWAP2 SWAP1 POP JUMP JUMPDEST PUSH1 0x0 PUSH8 0xFFFFFFFFFFFFFFFF DUP3 GT ISZERO PUSH2 0x695 JUMPI PUSH2 0x695 PUSH2 0x5F1 JUMP JUMPDEST POP PUSH1 0x1F ADD PUSH1 0x1F NOT AND PUSH1 0x20 ADD SWAP1 JUMP JUMPDEST PUSH1 0x0 DUP3 PUSH1 0x1F DUP4 ADD SLT PUSH2 0x6B4 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP2 CALLDATALOAD PUSH2 0x6C7 PUSH2 0x6C2 DUP3 PUSH2 0x67B JUMP JUMPDEST PUSH2 0x64A JUMP JUMPDEST DUP2 DUP2 MSTORE DUP5 PUSH1 0x20 DUP4 DUP7 ADD ADD GT ISZERO PUSH2 0x6DC JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP2 PUSH1 0x20 DUP6 ADD PUSH1 0x20 DUP4 ADD CALLDATACOPY PUSH1 0x0 SWAP2 DUP2 ADD PUSH1 0x20 ADD SWAP2 SWAP1 SWAP2 MSTORE SWAP4 SWAP3 POP POP POP JUMP JUMPDEST PUSH1 0x0 PUSH1 0x20 DUP3 DUP5 SUB SLT ISZERO PUSH2 0x70B JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP2 CALLDATALOAD PUSH8 0xFFFFFFFFFFFFFFFF DUP2 GT ISZERO PUSH2 0x722 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0x72E DUP5 DUP3 DUP6 ADD PUSH2 0x6A3 JUMP JUMPDEST SWAP5 SWAP4 POP POP POP POP JUMP JUMPDEST PUSH1 0x0 JUMPDEST DUP4 DUP2 LT ISZERO PUSH2 0x751 JUMPI DUP2 DUP2 ADD MLOAD DUP4 DUP3 ADD MSTORE PUSH1 0x20 ADD PUSH2 0x739 JUMP JUMPDEST POP POP PUSH1 0x0 SWAP2 ADD MSTORE JUMP JUMPDEST PUSH1 0x0 DUP2 MLOAD DUP1 DUP5 MSTORE PUSH2 0x772 DUP2 PUSH1 0x20 DUP7 ADD PUSH1 0x20 DUP7 ADD PUSH2 0x736 JUMP JUMPDEST PUSH1 0x1F ADD PUSH1 0x1F NOT AND SWAP3 SWAP1 SWAP3 ADD PUSH1 0x20 ADD SWAP3 SWAP2 POP POP JUMP JUMPDEST PUSH1 0x20 DUP2 MSTORE PUSH1 0x0 PUSH2 0x799 PUSH1 0x20 DUP4 ADD DUP5 PUSH2 0x75A JUMP JUMPDEST SWAP4 SWAP3 POP POP POP JUMP JUMPDEST PUSH1 0x0 DUP1 PUSH1 0x0 DUP1 PUSH1 0x0 DUP1 PUSH1 0xC0 DUP8 DUP10 SUB SLT ISZERO PUSH2 0x7B9 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0x7C2 DUP8 PUSH2 0x534 JUMP JUMPDEST SWAP6 POP PUSH1 0x20 DUP8 ADD CALLDATALOAD SWAP5 POP PUSH1 0x40 DUP8 ADD CALLDATALOAD PUSH2 0x7D9 DUP2 PUSH2 0x550 JUMP JUMPDEST SWAP4 POP PUSH1 0x60 DUP8 ADD CALLDATALOAD SWAP3 POP PUSH2 0x7EE PUSH1 0x80 DUP9 ADD PUSH2 0x563 JUMP JUMPDEST SWAP2 POP PUSH1 0xA0 DUP8 ADD CALLDATALOAD PUSH8 0xFFFFFFFFFFFFFFFF DUP2 GT ISZERO PUSH2 0x80A JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0x816 DUP10 DUP3 DUP11 ADD PUSH2 0x6A3 JUMP JUMPDEST SWAP2 POP POP SWAP3 SWAP6 POP SWAP3 SWAP6 POP SWAP3 SWAP6 JUMP JUMPDEST PUSH1 0x20 DUP2 MSTORE PUSH1 0xFF DUP3 MLOAD AND PUSH1 0x20 DUP3 ADD MSTORE PUSH1 0x20 DUP3 ADD MLOAD PUSH1 0x40 DUP3 ADD MSTORE PUSH1 0x40 DUP3 ADD MLOAD PUSH1 0x60 DUP3 ADD MSTORE PUSH2 0xFFFF PUSH1 0x60 DUP4 ADD MLOAD AND PUSH1 0x80 DUP3 ADD MSTORE PUSH1 0x80 DUP3 ADD MLOAD PUSH1 0xA0 DUP3 ADD MSTORE PUSH1 0x0 PUSH1 0xA0 DUP4 ADD MLOAD PUSH2 0x874 PUSH1 0xC0 DUP5 ADD DUP3 PUSH2 0xFFFF AND SWAP1 MSTORE JUMP JUMPDEST POP PUSH1 0xC0 DUP4 ADD MLOAD PUSH1 0xE0 DUP4 ADD MSTORE PUSH1 0xE0 DUP4 ADD MLOAD PUSH2 0x100 DUP1 DUP2 DUP6 ADD MSTORE POP PUSH2 0x72E PUSH2 0x120 DUP5 ADD DUP3 PUSH2 0x75A JUMP JUMPDEST PUSH1 0x0 DUP1 PUSH1 0x40 DUP4 DUP6 SUB SLT ISZERO PUSH2 0x8AE JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0x8B7 DUP4 PUSH2 0x534 JUMP JUMPDEST SWAP5 PUSH1 0x20 SWAP4 SWAP1 SWAP4 ADD CALLDATALOAD SWAP4 POP POP POP JUMP JUMPDEST PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB DUP8 AND DUP2 MSTORE DUP6 PUSH1 0x20 DUP3 ADD MSTORE PUSH2 0xFFFF DUP6 AND PUSH1 0x40 DUP3 ADD MSTORE DUP4 PUSH1 0x60 DUP3 ADD MSTORE PUSH4 0xFFFFFFFF DUP4 AND PUSH1 0x80 DUP3 ADD MSTORE PUSH1 0xC0 PUSH1 0xA0 DUP3 ADD MSTORE PUSH1 0x0 PUSH2 0x909 PUSH1 0xC0 DUP4 ADD DUP5 PUSH2 0x75A JUMP JUMPDEST SWAP9 SWAP8 POP POP POP POP POP POP POP POP JUMP JUMPDEST DUP1 MLOAD PUSH1 0xFF DUP2 AND DUP2 EQ PUSH2 0x54B JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP1 MLOAD PUSH2 0x54B DUP2 PUSH2 0x550 JUMP JUMPDEST PUSH1 0x0 DUP3 PUSH1 0x1F DUP4 ADD SLT PUSH2 0x942 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP2 MLOAD PUSH2 0x950 PUSH2 0x6C2 DUP3 PUSH2 0x67B JUMP JUMPDEST DUP2 DUP2 MSTORE DUP5 PUSH1 0x20 DUP4 DUP7 ADD ADD GT ISZERO PUSH2 0x965 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0x72E DUP3 PUSH1 0x20 DUP4 ADD PUSH1 0x20 DUP8 ADD PUSH2 0x736 JUMP JUMPDEST PUSH1 0x0 PUSH1 0x20 DUP3 DUP5 SUB SLT ISZERO PUSH2 0x988 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP2 MLOAD PUSH8 0xFFFFFFFFFFFFFFFF DUP1 DUP3 GT ISZERO PUSH2 0x9A0 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST SWAP1 DUP4 ADD SWAP1 PUSH2 0x100 DUP3 DUP7 SUB SLT ISZERO PUSH2 0x9B5 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0x9BD PUSH2 0x620 JUMP JUMPDEST PUSH2 0x9C6 DUP4 PUSH2 0x915 JUMP JUMPDEST DUP2 MSTORE PUSH1 0x20 DUP4 ADD MLOAD PUSH1 0x20 DUP3 ADD MSTORE PUSH1 0x40 DUP4 ADD MLOAD PUSH1 0x40 DUP3 ADD MSTORE PUSH2 0x9E8 PUSH1 0x60 DUP5 ADD PUSH2 0x926 JUMP JUMPDEST PUSH1 0x60 DUP3 ADD MSTORE PUSH1 0x80 DUP4 ADD MLOAD PUSH1 0x80 DUP3 ADD MSTORE PUSH2 0xA03 PUSH1 0xA0 DUP5 ADD PUSH2 0x926 JUMP JUMPDEST PUSH1 0xA0 DUP3 ADD MSTORE PUSH1 0xC0 DUP4 ADD MLOAD PUSH1 0xC0 DUP3 ADD MSTORE PUSH1 0xE0 DUP4 ADD MLOAD DUP3 DUP2 GT ISZERO PUSH2 0xA24 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0xA30 DUP8 DUP3 DUP7 ADD PUSH2 0x931 JUMP JUMPDEST PUSH1 0xE0 DUP4 ADD MSTORE POP SWAP6 SWAP5 POP POP POP POP POP JUMP INVALID LOG2 PUSH5 0x6970667358 0x22 SLT KECCAK256 0xD6 PUSH7 0xF4ABAA644E652F PUSH11 0xF266DCFACD11E95277B42F BALANCE DUP1 0xB2 0xFB 0xD1 BALANCE 0xDC 0x28 NOT 0x4E 0xF8 PUSH5 0x736F6C6343 STOP ADDMOD GT STOP CALLER ",
+      "opcodes": "PUSH1 0x80 PUSH1 0x40 MSTORE CALLVALUE DUP1 ISZERO PUSH2 0x10 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH1 0x40 MLOAD PUSH2 0xB08 CODESIZE SUB DUP1 PUSH2 0xB08 DUP4 CODECOPY DUP2 ADD PUSH1 0x40 DUP2 SWAP1 MSTORE PUSH2 0x2F SWAP2 PUSH2 0x54 JUMP JUMPDEST PUSH1 0x0 DUP1 SLOAD PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB NOT AND PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB SWAP3 SWAP1 SWAP3 AND SWAP2 SWAP1 SWAP2 OR SWAP1 SSTORE PUSH2 0x84 JUMP JUMPDEST PUSH1 0x0 PUSH1 0x20 DUP3 DUP5 SUB SLT ISZERO PUSH2 0x66 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP2 MLOAD PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB DUP2 AND DUP2 EQ PUSH2 0x7D JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST SWAP4 SWAP3 POP POP POP JUMP JUMPDEST PUSH2 0xA75 DUP1 PUSH2 0x93 PUSH1 0x0 CODECOPY PUSH1 0x0 RETURN INVALID PUSH1 0x80 PUSH1 0x40 MSTORE PUSH1 0x4 CALLDATASIZE LT PUSH2 0xB1 JUMPI PUSH1 0x0 CALLDATALOAD PUSH1 0xE0 SHR DUP1 PUSH4 0xC3F511C1 GT PUSH2 0x69 JUMPI DUP1 PUSH4 0xE566DF31 GT PUSH2 0x4E JUMPI DUP1 PUSH4 0xE566DF31 EQ PUSH2 0x1BB JUMPI DUP1 PUSH4 0xEA63738D EQ PUSH2 0x1DB JUMPI DUP1 PUSH4 0xEFCB70C0 EQ PUSH2 0x208 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP1 PUSH4 0xC3F511C1 EQ PUSH2 0x17B JUMPI DUP1 PUSH4 0xC5A5EBDA EQ PUSH2 0x1A8 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP1 PUSH4 0x504D27FD GT PUSH2 0x9A JUMPI DUP1 PUSH4 0x504D27FD EQ PUSH2 0x10B JUMPI DUP1 PUSH4 0x81C82233 EQ PUSH2 0x121 JUMPI DUP1 PUSH4 0x9542C9F1 EQ PUSH2 0x143 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP1 PUSH4 0xF5287B0 EQ PUSH2 0xB6 JUMPI DUP1 PUSH4 0x16FED3E2 EQ PUSH2 0xE7 JUMPI JUMPDEST PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0xC9 PUSH2 0xC4 CALLDATASIZE PUSH1 0x4 PUSH2 0x577 JUMP JUMPDEST PUSH2 0x228 JUMP JUMPDEST PUSH1 0x40 MLOAD PUSH8 0xFFFFFFFFFFFFFFFF SWAP1 SWAP2 AND DUP2 MSTORE PUSH1 0x20 ADD JUMPDEST PUSH1 0x40 MLOAD DUP1 SWAP2 SUB SWAP1 RETURN JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0xF3 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0xFD PUSH1 0x2 SLOAD DUP2 JUMP JUMPDEST PUSH1 0x40 MLOAD SWAP1 DUP2 MSTORE PUSH1 0x20 ADD PUSH2 0xDE JUMP JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x117 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0xFD PUSH1 0x1 SLOAD DUP2 JUMP JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x12D JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0x141 PUSH2 0x13C CALLDATASIZE PUSH1 0x4 PUSH2 0x5D8 JUMP JUMPDEST PUSH1 0x1 SSTORE JUMP JUMPDEST STOP JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x14F JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH1 0x0 SLOAD PUSH2 0x163 SWAP1 PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB AND DUP2 JUMP JUMPDEST PUSH1 0x40 MLOAD PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB SWAP1 SWAP2 AND DUP2 MSTORE PUSH1 0x20 ADD PUSH2 0xDE JUMP JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x187 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0x19B PUSH2 0x196 CALLDATASIZE PUSH1 0x4 PUSH2 0x6F9 JUMP JUMPDEST PUSH2 0x2A0 JUMP JUMPDEST PUSH1 0x40 MLOAD PUSH2 0xDE SWAP2 SWAP1 PUSH2 0x786 JUMP JUMPDEST PUSH2 0xC9 PUSH2 0x1B6 CALLDATASIZE PUSH1 0x4 PUSH2 0x7A0 JUMP JUMPDEST PUSH2 0x41E JUMP JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x1C7 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0x141 PUSH2 0x1D6 CALLDATASIZE PUSH1 0x4 PUSH2 0x5D8 JUMP JUMPDEST PUSH1 0x2 SSTORE JUMP JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x1E7 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0x1FB PUSH2 0x1F6 CALLDATASIZE PUSH1 0x4 PUSH2 0x6F9 JUMP JUMPDEST PUSH2 0x46F JUMP JUMPDEST PUSH1 0x40 MLOAD PUSH2 0xDE SWAP2 SWAP1 PUSH2 0x823 JUMP JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x214 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0x141 PUSH2 0x223 CALLDATASIZE PUSH1 0x4 PUSH2 0x89B JUMP JUMPDEST PUSH2 0x4CA JUMP JUMPDEST PUSH1 0x40 DUP1 MLOAD PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB DUP9 AND DUP2 MSTORE PUSH1 0x20 DUP2 ADD DUP8 SWAP1 MSTORE PUSH2 0xFFFF DUP7 AND DUP2 DUP4 ADD MSTORE PUSH1 0x60 DUP2 ADD DUP6 SWAP1 MSTORE PUSH1 0x80 DUP2 ADD DUP5 SWAP1 MSTORE PUSH4 0xFFFFFFFF DUP4 AND PUSH1 0xA0 DUP3 ADD MSTORE SWAP1 MLOAD PUSH1 0x0 SWAP2 PUSH32 0x4D24EF3F381C3D7E8696045268F69C41EC3DEE2C5BD1AAA48DAF8EC2EC7FE436 SWAP2 SWAP1 DUP2 SWAP1 SUB PUSH1 0xC0 ADD SWAP1 LOG1 POP PUSH2 0x309 SWAP7 SWAP6 POP POP POP POP POP POP JUMP JUMPDEST PUSH1 0x60 PUSH32 0x6EFACCD86B6CE8325DB6AD038D68E09F9B1AF9A0FC1ED121EBE9D870AAFC2086 DUP3 PUSH1 0x40 MLOAD PUSH2 0x2D1 SWAP2 SWAP1 PUSH2 0x786 JUMP JUMPDEST PUSH1 0x40 MLOAD DUP1 SWAP2 SUB SWAP1 LOG1 PUSH1 0x0 SLOAD PUSH1 0x1 SLOAD PUSH1 0x40 MLOAD PUSH4 0x40C10F19 PUSH1 0xE0 SHL DUP2 MSTORE CALLER PUSH1 0x4 DUP3 ADD MSTORE PUSH1 0x24 DUP2 ADD SWAP2 SWAP1 SWAP2 MSTORE PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB SWAP1 SWAP2 AND SWAP1 PUSH4 0x40C10F19 SWAP1 PUSH1 0x44 ADD PUSH1 0x0 PUSH1 0x40 MLOAD DUP1 DUP4 SUB DUP2 PUSH1 0x0 DUP8 DUP1 EXTCODESIZE ISZERO DUP1 ISZERO PUSH2 0x329 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP GAS CALL ISZERO DUP1 ISZERO PUSH2 0x33D JUMPI RETURNDATASIZE PUSH1 0x0 DUP1 RETURNDATACOPY RETURNDATASIZE PUSH1 0x0 REVERT JUMPDEST POP POP PUSH1 0x40 DUP1 MLOAD PUSH2 0x100 DUP2 ADD DUP3 MSTORE PUSH1 0x1 DUP2 MSTORE PUSH1 0x2 PUSH1 0x20 DUP1 DUP4 ADD DUP3 SWAP1 MSTORE PUSH32 0x3000000000000000000000000000000000000000000000000000000000000000 DUP4 DUP6 ADD MSTORE PUSH1 0x4 PUSH1 0x60 DUP5 ADD MSTORE PUSH32 0x5000000000000000000000000000000000000000000000000000000000000000 PUSH1 0x80 DUP5 ADD MSTORE PUSH1 0x6 PUSH1 0xA0 DUP5 ADD MSTORE PUSH32 0x7000000000000000000000000000000000000000000000000000000000000000 PUSH1 0xC0 DUP5 ADD MSTORE SWAP1 SLOAD DUP4 MLOAD DUP1 DUP4 ADD SWAP2 SWAP1 SWAP2 MSTORE DUP4 MLOAD DUP1 DUP3 SUB DUP4 ADD DUP2 MSTORE SWAP1 DUP5 ADD DUP5 MSTORE PUSH1 0xE0 DUP4 ADD MSTORE SWAP2 MLOAD SWAP1 SWAP4 POP PUSH2 0x407 SWAP3 POP DUP4 SWAP2 ADD PUSH2 0x823 JUMP JUMPDEST PUSH1 0x40 MLOAD PUSH1 0x20 DUP2 DUP4 SUB SUB DUP2 MSTORE SWAP1 PUSH1 0x40 MSTORE SWAP2 POP POP SWAP2 SWAP1 POP JUMP JUMPDEST PUSH1 0x0 PUSH32 0x8F36AA28E4F86A5B6D397422D004B60E74EDA866A331D074749B789D70CA3144 DUP8 DUP8 DUP8 DUP8 DUP8 DUP8 PUSH1 0x40 MLOAD PUSH2 0x459 SWAP7 SWAP6 SWAP5 SWAP4 SWAP3 SWAP2 SWAP1 PUSH2 0x8C5 JUMP JUMPDEST PUSH1 0x40 MLOAD DUP1 SWAP2 SUB SWAP1 LOG1 POP PUSH2 0x378 SWAP7 SWAP6 POP POP POP POP POP POP JUMP JUMPDEST PUSH1 0x40 DUP1 MLOAD PUSH2 0x100 DUP2 ADD DUP3 MSTORE PUSH1 0x0 DUP1 DUP3 MSTORE PUSH1 0x20 DUP1 DUP4 ADD DUP3 SWAP1 MSTORE SWAP3 DUP3 ADD DUP2 SWAP1 MSTORE PUSH1 0x60 DUP1 DUP4 ADD DUP3 SWAP1 MSTORE PUSH1 0x80 DUP4 ADD DUP3 SWAP1 MSTORE PUSH1 0xA0 DUP4 ADD DUP3 SWAP1 MSTORE PUSH1 0xC0 DUP4 ADD SWAP2 SWAP1 SWAP2 MSTORE PUSH1 0xE0 DUP3 ADD MSTORE DUP3 MLOAD SWAP1 SWAP2 PUSH2 0x4C4 SWAP2 DUP5 ADD DUP2 ADD SWAP1 DUP5 ADD PUSH2 0x976 JUMP JUMPDEST SWAP3 SWAP2 POP POP JUMP JUMPDEST PUSH1 0x0 SLOAD PUSH1 0x40 MLOAD PUSH4 0x40C10F19 PUSH1 0xE0 SHL DUP2 MSTORE PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB DUP5 DUP2 AND PUSH1 0x4 DUP4 ADD MSTORE PUSH1 0x24 DUP3 ADD DUP5 SWAP1 MSTORE SWAP1 SWAP2 AND SWAP1 PUSH4 0x40C10F19 SWAP1 PUSH1 0x44 ADD PUSH1 0x0 PUSH1 0x40 MLOAD DUP1 DUP4 SUB DUP2 PUSH1 0x0 DUP8 DUP1 EXTCODESIZE ISZERO DUP1 ISZERO PUSH2 0x518 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP GAS CALL ISZERO DUP1 ISZERO PUSH2 0x52C JUMPI RETURNDATASIZE PUSH1 0x0 DUP1 RETURNDATACOPY RETURNDATASIZE PUSH1 0x0 REVERT JUMPDEST POP POP POP POP POP POP JUMP JUMPDEST DUP1 CALLDATALOAD PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB DUP2 AND DUP2 EQ PUSH2 0x54B JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST SWAP2 SWAP1 POP JUMP JUMPDEST PUSH2 0xFFFF DUP2 AND DUP2 EQ PUSH2 0x560 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP JUMP JUMPDEST DUP1 CALLDATALOAD PUSH4 0xFFFFFFFF DUP2 AND DUP2 EQ PUSH2 0x54B JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH1 0x0 DUP1 PUSH1 0x0 DUP1 PUSH1 0x0 DUP1 PUSH1 0xC0 DUP8 DUP10 SUB SLT ISZERO PUSH2 0x590 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0x599 DUP8 PUSH2 0x534 JUMP JUMPDEST SWAP6 POP PUSH1 0x20 DUP8 ADD CALLDATALOAD SWAP5 POP PUSH1 0x40 DUP8 ADD CALLDATALOAD PUSH2 0x5B0 DUP2 PUSH2 0x550 JUMP JUMPDEST SWAP4 POP PUSH1 0x60 DUP8 ADD CALLDATALOAD SWAP3 POP PUSH1 0x80 DUP8 ADD CALLDATALOAD SWAP2 POP PUSH2 0x5CC PUSH1 0xA0 DUP9 ADD PUSH2 0x563 JUMP JUMPDEST SWAP1 POP SWAP3 SWAP6 POP SWAP3 SWAP6 POP SWAP3 SWAP6 JUMP JUMPDEST PUSH1 0x0 PUSH1 0x20 DUP3 DUP5 SUB SLT ISZERO PUSH2 0x5EA JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP CALLDATALOAD SWAP2 SWAP1 POP JUMP JUMPDEST PUSH32 0x4E487B7100000000000000000000000000000000000000000000000000000000 PUSH1 0x0 MSTORE PUSH1 0x41 PUSH1 0x4 MSTORE PUSH1 0x24 PUSH1 0x0 REVERT JUMPDEST PUSH1 0x40 MLOAD PUSH2 0x100 DUP2 ADD PUSH8 0xFFFFFFFFFFFFFFFF DUP2 GT DUP3 DUP3 LT OR ISZERO PUSH2 0x644 JUMPI PUSH2 0x644 PUSH2 0x5F1 JUMP JUMPDEST PUSH1 0x40 MSTORE SWAP1 JUMP JUMPDEST PUSH1 0x40 MLOAD PUSH1 0x1F DUP3 ADD PUSH1 0x1F NOT AND DUP2 ADD PUSH8 0xFFFFFFFFFFFFFFFF DUP2 GT DUP3 DUP3 LT OR ISZERO PUSH2 0x673 JUMPI PUSH2 0x673 PUSH2 0x5F1 JUMP JUMPDEST PUSH1 0x40 MSTORE SWAP2 SWAP1 POP JUMP JUMPDEST PUSH1 0x0 PUSH8 0xFFFFFFFFFFFFFFFF DUP3 GT ISZERO PUSH2 0x695 JUMPI PUSH2 0x695 PUSH2 0x5F1 JUMP JUMPDEST POP PUSH1 0x1F ADD PUSH1 0x1F NOT AND PUSH1 0x20 ADD SWAP1 JUMP JUMPDEST PUSH1 0x0 DUP3 PUSH1 0x1F DUP4 ADD SLT PUSH2 0x6B4 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP2 CALLDATALOAD PUSH2 0x6C7 PUSH2 0x6C2 DUP3 PUSH2 0x67B JUMP JUMPDEST PUSH2 0x64A JUMP JUMPDEST DUP2 DUP2 MSTORE DUP5 PUSH1 0x20 DUP4 DUP7 ADD ADD GT ISZERO PUSH2 0x6DC JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP2 PUSH1 0x20 DUP6 ADD PUSH1 0x20 DUP4 ADD CALLDATACOPY PUSH1 0x0 SWAP2 DUP2 ADD PUSH1 0x20 ADD SWAP2 SWAP1 SWAP2 MSTORE SWAP4 SWAP3 POP POP POP JUMP JUMPDEST PUSH1 0x0 PUSH1 0x20 DUP3 DUP5 SUB SLT ISZERO PUSH2 0x70B JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP2 CALLDATALOAD PUSH8 0xFFFFFFFFFFFFFFFF DUP2 GT ISZERO PUSH2 0x722 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0x72E DUP5 DUP3 DUP6 ADD PUSH2 0x6A3 JUMP JUMPDEST SWAP5 SWAP4 POP POP POP POP JUMP JUMPDEST PUSH1 0x0 JUMPDEST DUP4 DUP2 LT ISZERO PUSH2 0x751 JUMPI DUP2 DUP2 ADD MLOAD DUP4 DUP3 ADD MSTORE PUSH1 0x20 ADD PUSH2 0x739 JUMP JUMPDEST POP POP PUSH1 0x0 SWAP2 ADD MSTORE JUMP JUMPDEST PUSH1 0x0 DUP2 MLOAD DUP1 DUP5 MSTORE PUSH2 0x772 DUP2 PUSH1 0x20 DUP7 ADD PUSH1 0x20 DUP7 ADD PUSH2 0x736 JUMP JUMPDEST PUSH1 0x1F ADD PUSH1 0x1F NOT AND SWAP3 SWAP1 SWAP3 ADD PUSH1 0x20 ADD SWAP3 SWAP2 POP POP JUMP JUMPDEST PUSH1 0x20 DUP2 MSTORE PUSH1 0x0 PUSH2 0x799 PUSH1 0x20 DUP4 ADD DUP5 PUSH2 0x75A JUMP JUMPDEST SWAP4 SWAP3 POP POP POP JUMP JUMPDEST PUSH1 0x0 DUP1 PUSH1 0x0 DUP1 PUSH1 0x0 DUP1 PUSH1 0xC0 DUP8 DUP10 SUB SLT ISZERO PUSH2 0x7B9 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0x7C2 DUP8 PUSH2 0x534 JUMP JUMPDEST SWAP6 POP PUSH1 0x20 DUP8 ADD CALLDATALOAD SWAP5 POP PUSH1 0x40 DUP8 ADD CALLDATALOAD PUSH2 0x7D9 DUP2 PUSH2 0x550 JUMP JUMPDEST SWAP4 POP PUSH1 0x60 DUP8 ADD CALLDATALOAD SWAP3 POP PUSH2 0x7EE PUSH1 0x80 DUP9 ADD PUSH2 0x563 JUMP JUMPDEST SWAP2 POP PUSH1 0xA0 DUP8 ADD CALLDATALOAD PUSH8 0xFFFFFFFFFFFFFFFF DUP2 GT ISZERO PUSH2 0x80A JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0x816 DUP10 DUP3 DUP11 ADD PUSH2 0x6A3 JUMP JUMPDEST SWAP2 POP POP SWAP3 SWAP6 POP SWAP3 SWAP6 POP SWAP3 SWAP6 JUMP JUMPDEST PUSH1 0x20 DUP2 MSTORE PUSH1 0xFF DUP3 MLOAD AND PUSH1 0x20 DUP3 ADD MSTORE PUSH1 0x20 DUP3 ADD MLOAD PUSH1 0x40 DUP3 ADD MSTORE PUSH1 0x40 DUP3 ADD MLOAD PUSH1 0x60 DUP3 ADD MSTORE PUSH2 0xFFFF PUSH1 0x60 DUP4 ADD MLOAD AND PUSH1 0x80 DUP3 ADD MSTORE PUSH1 0x80 DUP3 ADD MLOAD PUSH1 0xA0 DUP3 ADD MSTORE PUSH1 0x0 PUSH1 0xA0 DUP4 ADD MLOAD PUSH2 0x874 PUSH1 0xC0 DUP5 ADD DUP3 PUSH2 0xFFFF AND SWAP1 MSTORE JUMP JUMPDEST POP PUSH1 0xC0 DUP4 ADD MLOAD PUSH1 0xE0 DUP4 ADD MSTORE PUSH1 0xE0 DUP4 ADD MLOAD PUSH2 0x100 DUP1 DUP2 DUP6 ADD MSTORE POP PUSH2 0x72E PUSH2 0x120 DUP5 ADD DUP3 PUSH2 0x75A JUMP JUMPDEST PUSH1 0x0 DUP1 PUSH1 0x40 DUP4 DUP6 SUB SLT ISZERO PUSH2 0x8AE JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0x8B7 DUP4 PUSH2 0x534 JUMP JUMPDEST SWAP5 PUSH1 0x20 SWAP4 SWAP1 SWAP4 ADD CALLDATALOAD SWAP4 POP POP POP JUMP JUMPDEST PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB DUP8 AND DUP2 MSTORE DUP6 PUSH1 0x20 DUP3 ADD MSTORE PUSH2 0xFFFF DUP6 AND PUSH1 0x40 DUP3 ADD MSTORE DUP4 PUSH1 0x60 DUP3 ADD MSTORE PUSH4 0xFFFFFFFF DUP4 AND PUSH1 0x80 DUP3 ADD MSTORE PUSH1 0xC0 PUSH1 0xA0 DUP3 ADD MSTORE PUSH1 0x0 PUSH2 0x909 PUSH1 0xC0 DUP4 ADD DUP5 PUSH2 0x75A JUMP JUMPDEST SWAP9 SWAP8 POP POP POP POP POP POP POP POP JUMP JUMPDEST DUP1 MLOAD PUSH1 0xFF DUP2 AND DUP2 EQ PUSH2 0x54B JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP1 MLOAD PUSH2 0x54B DUP2 PUSH2 0x550 JUMP JUMPDEST PUSH1 0x0 DUP3 PUSH1 0x1F DUP4 ADD SLT PUSH2 0x942 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP2 MLOAD PUSH2 0x950 PUSH2 0x6C2 DUP3 PUSH2 0x67B JUMP JUMPDEST DUP2 DUP2 MSTORE DUP5 PUSH1 0x20 DUP4 DUP7 ADD ADD GT ISZERO PUSH2 0x965 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0x72E DUP3 PUSH1 0x20 DUP4 ADD PUSH1 0x20 DUP8 ADD PUSH2 0x736 JUMP JUMPDEST PUSH1 0x0 PUSH1 0x20 DUP3 DUP5 SUB SLT ISZERO PUSH2 0x988 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP2 MLOAD PUSH8 0xFFFFFFFFFFFFFFFF DUP1 DUP3 GT ISZERO PUSH2 0x9A0 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST SWAP1 DUP4 ADD SWAP1 PUSH2 0x100 DUP3 DUP7 SUB SLT ISZERO PUSH2 0x9B5 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0x9BD PUSH2 0x620 JUMP JUMPDEST PUSH2 0x9C6 DUP4 PUSH2 0x915 JUMP JUMPDEST DUP2 MSTORE PUSH1 0x20 DUP4 ADD MLOAD PUSH1 0x20 DUP3 ADD MSTORE PUSH1 0x40 DUP4 ADD MLOAD PUSH1 0x40 DUP3 ADD MSTORE PUSH2 0x9E8 PUSH1 0x60 DUP5 ADD PUSH2 0x926 JUMP JUMPDEST PUSH1 0x60 DUP3 ADD MSTORE PUSH1 0x80 DUP4 ADD MLOAD PUSH1 0x80 DUP3 ADD MSTORE PUSH2 0xA03 PUSH1 0xA0 DUP5 ADD PUSH2 0x926 JUMP JUMPDEST PUSH1 0xA0 DUP3 ADD MSTORE PUSH1 0xC0 DUP4 ADD MLOAD PUSH1 0xC0 DUP3 ADD MSTORE PUSH1 0xE0 DUP4 ADD MLOAD DUP3 DUP2 GT ISZERO PUSH2 0xA24 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0xA30 DUP8 DUP3 DUP7 ADD PUSH2 0x931 JUMP JUMPDEST PUSH1 0xE0 DUP4 ADD MSTORE POP SWAP6 SWAP5 POP POP POP POP POP JUMP INVALID LOG2 PUSH5 0x6970667358 0x22 SLT KECCAK256 SWAP2 RETURNDATASIZE 0xE8 0xD1 0xDB PUSH16 0xA583B976D45F865E25F5FD92A6626C1B 0xDD 0xCA PUSH23 0xAD1D23088EEE1764736F6C634300081100330000000000 ",
       "sourceMap": "344:3655:119:-:0;;;1094:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1142:13;:30;;-1:-1:-1;;;;;;1142:30:119;-1:-1:-1;;;;;1142:30:119;;;;;;;;;;344:3655;;14:309:125;103:6;156:2;144:9;135:7;131:23;127:32;124:52;;;172:1;169;162:12;124:52;198:16;;-1:-1:-1;;;;;243:31:125;;233:42;;223:70;;289:1;286;279:12;223:70;312:5;14:309;-1:-1:-1;;;14:309:125:o;:::-;344:3655:119;;;;;;"
     },
     "deployedBytecode": {
       "functionDebugData": {
-        "@completeTransferWithPayload_41214": {
+        "@completeTransferWithPayload_41170": {
           "entryPoint": 672,
-          "id": 41214,
+          "id": 41170,
           "parameterSlots": 1,
           "returnSlots": 1
         },
-        "@mintWormholeToken_41324": {
+        "@mintWormholeToken_41280": {
           "entryPoint": 1226,
-          "id": 41324,
+          "id": 41280,
           "parameterSlots": 2,
           "returnSlots": 0
         },
-        "@parseTransferWithPayload_41289": {
+        "@parseTransferWithPayload_41245": {
           "entryPoint": 1135,
-          "id": 41289,
+          "id": 41245,
           "parameterSlots": 1,
           "returnSlots": 1
         },
-        "@receiverAddress_41126": {
+        "@receiverAddress_41082": {
           "entryPoint": null,
-          "id": 41126,
+          "id": 41082,
           "parameterSlots": 0,
           "returnSlots": 0
         },
-        "@setReceiverAddress_41309": {
+        "@setReceiverAddress_41265": {
           "entryPoint": null,
-          "id": 41309,
+          "id": 41265,
           "parameterSlots": 1,
           "returnSlots": 0
         },
-        "@setTransferAmount_41299": {
+        "@setTransferAmount_41255": {
           "entryPoint": null,
-          "id": 41299,
+          "id": 41255,
           "parameterSlots": 1,
           "returnSlots": 0
         },
-        "@transferAmount_41124": {
+        "@transferAmount_41080": {
           "entryPoint": null,
-          "id": 41124,
+          "id": 41080,
           "parameterSlots": 0,
           "returnSlots": 0
         },
-        "@transferTokensWithPayload_41272": {
+        "@transferTokensWithPayload_41228": {
           "entryPoint": 1054,
-          "id": 41272,
+          "id": 41228,
           "parameterSlots": 6,
           "returnSlots": 1
         },
-        "@transferTokens_41243": {
+        "@transferTokens_41199": {
           "entryPoint": 552,
-          "id": 41243,
+          "id": 41199,
           "parameterSlots": 6,
           "returnSlots": 1
         },
-        "@wormholeToken_41122": {
+        "@wormholeToken_41078": {
           "entryPoint": null,
-          "id": 41122,
+          "id": 41078,
           "parameterSlots": 0,
           "returnSlots": 0
         },
@@ -869,7 +869,7 @@
           "parameterSlots": 2,
           "returnSlots": 1
         },
-        "abi_encode_tuple_t_contract$_TestERC20_$41058__to_t_address__fromStack_reversed": {
+        "abi_encode_tuple_t_contract$_TestERC20_$41014__to_t_address__fromStack_reversed": {
           "entryPoint": null,
           "id": null,
           "parameterSlots": 2,
@@ -2287,7 +2287,7 @@
                     }
                   ]
                 },
-                "name": "abi_encode_tuple_t_contract$_TestERC20_$41058__to_t_address__fromStack_reversed",
+                "name": "abi_encode_tuple_t_contract$_TestERC20_$41014__to_t_address__fromStack_reversed",
                 "nodeType": "YulFunctionDefinition",
                 "parameters": [
                   {
@@ -8568,7 +8568,7 @@
               }
             ]
           },
-          "contents": "{\n    { }\n    function abi_decode_address(offset) -> value\n    {\n        value := calldataload(offset)\n        if iszero(eq(value, and(value, 0xffffffffffffffffffffffffffffffffffffffff))) { revert(0, 0) }\n    }\n    function validator_revert_uint16(value)\n    {\n        if iszero(eq(value, and(value, 0xffff))) { revert(0, 0) }\n    }\n    function abi_decode_uint32(offset) -> value\n    {\n        value := calldataload(offset)\n        if iszero(eq(value, and(value, 0xffffffff))) { revert(0, 0) }\n    }\n    function abi_decode_tuple_t_addresst_uint256t_uint16t_bytes32t_uint256t_uint32(headStart, dataEnd) -> value0, value1, value2, value3, value4, value5\n    {\n        if slt(sub(dataEnd, headStart), 192) { revert(0, 0) }\n        value0 := abi_decode_address(headStart)\n        value1 := calldataload(add(headStart, 32))\n        let value := calldataload(add(headStart, 64))\n        validator_revert_uint16(value)\n        value2 := value\n        value3 := calldataload(add(headStart, 96))\n        value4 := calldataload(add(headStart, 128))\n        value5 := abi_decode_uint32(add(headStart, 160))\n    }\n    function abi_encode_tuple_t_uint64__to_t_uint64__fromStack_reversed(headStart, value0) -> tail\n    {\n        tail := add(headStart, 32)\n        mstore(headStart, and(value0, 0xffffffffffffffff))\n    }\n    function abi_encode_tuple_t_bytes32__to_t_bytes32__fromStack_reversed(headStart, value0) -> tail\n    {\n        tail := add(headStart, 32)\n        mstore(headStart, value0)\n    }\n    function abi_encode_tuple_t_uint256__to_t_uint256__fromStack_reversed(headStart, value0) -> tail\n    {\n        tail := add(headStart, 32)\n        mstore(headStart, value0)\n    }\n    function abi_decode_tuple_t_uint256(headStart, dataEnd) -> value0\n    {\n        if slt(sub(dataEnd, headStart), 32) { revert(0, 0) }\n        value0 := calldataload(headStart)\n    }\n    function abi_encode_tuple_t_contract$_TestERC20_$41058__to_t_address__fromStack_reversed(headStart, value0) -> tail\n    {\n        tail := add(headStart, 32)\n        mstore(headStart, and(value0, 0xffffffffffffffffffffffffffffffffffffffff))\n    }\n    function panic_error_0x41()\n    {\n        mstore(0, 35408467139433450592217433187231851964531694900788300625387963629091585785856)\n        mstore(4, 0x41)\n        revert(0, 0x24)\n    }\n    function allocate_memory_1198() -> memPtr\n    {\n        memPtr := mload(64)\n        let newFreePtr := add(memPtr, 0x0100)\n        if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr)) { panic_error_0x41() }\n        mstore(64, newFreePtr)\n    }\n    function allocate_memory(size) -> memPtr\n    {\n        memPtr := mload(64)\n        let newFreePtr := add(memPtr, and(add(size, 31), not(31)))\n        if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr)) { panic_error_0x41() }\n        mstore(64, newFreePtr)\n    }\n    function array_allocation_size_bytes(length) -> size\n    {\n        if gt(length, 0xffffffffffffffff) { panic_error_0x41() }\n        size := add(and(add(length, 31), not(31)), 0x20)\n    }\n    function abi_decode_bytes(offset, end) -> array\n    {\n        if iszero(slt(add(offset, 0x1f), end)) { revert(0, 0) }\n        let _1 := calldataload(offset)\n        let array_1 := allocate_memory(array_allocation_size_bytes(_1))\n        mstore(array_1, _1)\n        if gt(add(add(offset, _1), 0x20), end) { revert(0, 0) }\n        calldatacopy(add(array_1, 0x20), add(offset, 0x20), _1)\n        mstore(add(add(array_1, _1), 0x20), 0)\n        array := array_1\n    }\n    function abi_decode_tuple_t_bytes_memory_ptr(headStart, dataEnd) -> value0\n    {\n        if slt(sub(dataEnd, headStart), 32) { revert(0, 0) }\n        let offset := calldataload(headStart)\n        if gt(offset, 0xffffffffffffffff) { revert(0, 0) }\n        value0 := abi_decode_bytes(add(headStart, offset), dataEnd)\n    }\n    function copy_memory_to_memory_with_cleanup(src, dst, length)\n    {\n        let i := 0\n        for { } lt(i, length) { i := add(i, 32) }\n        {\n            mstore(add(dst, i), mload(add(src, i)))\n        }\n        mstore(add(dst, length), 0)\n    }\n    function abi_encode_bytes(value, pos) -> end\n    {\n        let length := mload(value)\n        mstore(pos, length)\n        copy_memory_to_memory_with_cleanup(add(value, 0x20), add(pos, 0x20), length)\n        end := add(add(pos, and(add(length, 31), not(31))), 0x20)\n    }\n    function abi_encode_tuple_t_bytes_memory_ptr__to_t_bytes_memory_ptr__fromStack_reversed(headStart, value0) -> tail\n    {\n        mstore(headStart, 32)\n        tail := abi_encode_bytes(value0, add(headStart, 32))\n    }\n    function abi_decode_tuple_t_addresst_uint256t_uint16t_bytes32t_uint32t_bytes_memory_ptr(headStart, dataEnd) -> value0, value1, value2, value3, value4, value5\n    {\n        if slt(sub(dataEnd, headStart), 192) { revert(0, 0) }\n        value0 := abi_decode_address(headStart)\n        value1 := calldataload(add(headStart, 32))\n        let value := calldataload(add(headStart, 64))\n        validator_revert_uint16(value)\n        value2 := value\n        value3 := calldataload(add(headStart, 96))\n        value4 := abi_decode_uint32(add(headStart, 128))\n        let offset := calldataload(add(headStart, 160))\n        if gt(offset, 0xffffffffffffffff) { revert(0, 0) }\n        value5 := abi_decode_bytes(add(headStart, offset), dataEnd)\n    }\n    function abi_decode_tuple_t_bytes32(headStart, dataEnd) -> value0\n    {\n        if slt(sub(dataEnd, headStart), 32) { revert(0, 0) }\n        value0 := calldataload(headStart)\n    }\n    function abi_encode_uint16(value, pos)\n    {\n        mstore(pos, and(value, 0xffff))\n    }\n    function abi_encode_tuple_t_struct$_TransferWithPayload_$37598_memory_ptr__to_t_struct$_TransferWithPayload_$37598_memory_ptr__fromStack_reversed(headStart, value0) -> tail\n    {\n        mstore(headStart, 32)\n        mstore(add(headStart, 32), and(mload(value0), 0xff))\n        mstore(add(headStart, 64), mload(add(value0, 32)))\n        mstore(add(headStart, 96), mload(add(value0, 64)))\n        mstore(add(headStart, 128), and(mload(add(value0, 96)), 0xffff))\n        mstore(add(headStart, 160), mload(add(value0, 128)))\n        let memberValue0 := mload(add(value0, 160))\n        abi_encode_uint16(memberValue0, add(headStart, 192))\n        mstore(add(headStart, 224), mload(add(value0, 192)))\n        let memberValue0_1 := mload(add(value0, 224))\n        let _1 := 0x0100\n        mstore(add(headStart, _1), _1)\n        tail := abi_encode_bytes(memberValue0_1, add(headStart, 288))\n    }\n    function abi_decode_tuple_t_addresst_uint256(headStart, dataEnd) -> value0, value1\n    {\n        if slt(sub(dataEnd, headStart), 64) { revert(0, 0) }\n        value0 := abi_decode_address(headStart)\n        value1 := calldataload(add(headStart, 32))\n    }\n    function abi_encode_tuple_t_address_t_uint256_t_uint16_t_bytes32_t_uint256_t_uint32__to_t_address_t_uint256_t_uint16_t_bytes32_t_uint256_t_uint32__fromStack_reversed(headStart, value5, value4, value3, value2, value1, value0) -> tail\n    {\n        tail := add(headStart, 192)\n        mstore(headStart, and(value0, 0xffffffffffffffffffffffffffffffffffffffff))\n        mstore(add(headStart, 32), value1)\n        mstore(add(headStart, 64), and(value2, 0xffff))\n        mstore(add(headStart, 96), value3)\n        mstore(add(headStart, 128), value4)\n        mstore(add(headStart, 160), and(value5, 0xffffffff))\n    }\n    function abi_encode_tuple_t_address_t_uint256__to_t_address_t_uint256__fromStack_reversed(headStart, value1, value0) -> tail\n    {\n        tail := add(headStart, 64)\n        mstore(headStart, and(value0, 0xffffffffffffffffffffffffffffffffffffffff))\n        mstore(add(headStart, 32), value1)\n    }\n    function abi_encode_tuple_t_address_t_uint256_t_uint16_t_bytes32_t_uint32_t_bytes_memory_ptr__to_t_address_t_uint256_t_uint16_t_bytes32_t_uint32_t_bytes_memory_ptr__fromStack_reversed(headStart, value5, value4, value3, value2, value1, value0) -> tail\n    {\n        mstore(headStart, and(value0, 0xffffffffffffffffffffffffffffffffffffffff))\n        mstore(add(headStart, 32), value1)\n        mstore(add(headStart, 64), and(value2, 0xffff))\n        mstore(add(headStart, 96), value3)\n        mstore(add(headStart, 128), and(value4, 0xffffffff))\n        mstore(add(headStart, 160), 192)\n        tail := abi_encode_bytes(value5, add(headStart, 192))\n    }\n    function abi_decode_uint8_fromMemory(offset) -> value\n    {\n        value := mload(offset)\n        if iszero(eq(value, and(value, 0xff))) { revert(0, 0) }\n    }\n    function abi_decode_uint16_fromMemory(offset) -> value\n    {\n        value := mload(offset)\n        validator_revert_uint16(value)\n    }\n    function abi_decode_bytes_fromMemory(offset, end) -> array\n    {\n        if iszero(slt(add(offset, 0x1f), end)) { revert(0, 0) }\n        let _1 := mload(offset)\n        let array_1 := allocate_memory(array_allocation_size_bytes(_1))\n        mstore(array_1, _1)\n        if gt(add(add(offset, _1), 0x20), end) { revert(0, 0) }\n        copy_memory_to_memory_with_cleanup(add(offset, 0x20), add(array_1, 0x20), _1)\n        array := array_1\n    }\n    function abi_decode_tuple_t_struct$_TransferWithPayload_$37598_memory_ptr_fromMemory(headStart, dataEnd) -> value0\n    {\n        if slt(sub(dataEnd, headStart), 32) { revert(0, 0) }\n        let offset := mload(headStart)\n        let _1 := 0xffffffffffffffff\n        if gt(offset, _1) { revert(0, 0) }\n        let _2 := add(headStart, offset)\n        if slt(sub(dataEnd, _2), 0x0100) { revert(0, 0) }\n        let value := allocate_memory_1198()\n        mstore(value, abi_decode_uint8_fromMemory(_2))\n        mstore(add(value, 32), mload(add(_2, 32)))\n        mstore(add(value, 64), mload(add(_2, 64)))\n        mstore(add(value, 96), abi_decode_uint16_fromMemory(add(_2, 96)))\n        mstore(add(value, 128), mload(add(_2, 128)))\n        mstore(add(value, 160), abi_decode_uint16_fromMemory(add(_2, 160)))\n        mstore(add(value, 192), mload(add(_2, 192)))\n        let offset_1 := mload(add(_2, 224))\n        if gt(offset_1, _1) { revert(0, 0) }\n        mstore(add(value, 224), abi_decode_bytes_fromMemory(add(_2, offset_1), dataEnd))\n        value0 := value\n    }\n}",
+          "contents": "{\n    { }\n    function abi_decode_address(offset) -> value\n    {\n        value := calldataload(offset)\n        if iszero(eq(value, and(value, 0xffffffffffffffffffffffffffffffffffffffff))) { revert(0, 0) }\n    }\n    function validator_revert_uint16(value)\n    {\n        if iszero(eq(value, and(value, 0xffff))) { revert(0, 0) }\n    }\n    function abi_decode_uint32(offset) -> value\n    {\n        value := calldataload(offset)\n        if iszero(eq(value, and(value, 0xffffffff))) { revert(0, 0) }\n    }\n    function abi_decode_tuple_t_addresst_uint256t_uint16t_bytes32t_uint256t_uint32(headStart, dataEnd) -> value0, value1, value2, value3, value4, value5\n    {\n        if slt(sub(dataEnd, headStart), 192) { revert(0, 0) }\n        value0 := abi_decode_address(headStart)\n        value1 := calldataload(add(headStart, 32))\n        let value := calldataload(add(headStart, 64))\n        validator_revert_uint16(value)\n        value2 := value\n        value3 := calldataload(add(headStart, 96))\n        value4 := calldataload(add(headStart, 128))\n        value5 := abi_decode_uint32(add(headStart, 160))\n    }\n    function abi_encode_tuple_t_uint64__to_t_uint64__fromStack_reversed(headStart, value0) -> tail\n    {\n        tail := add(headStart, 32)\n        mstore(headStart, and(value0, 0xffffffffffffffff))\n    }\n    function abi_encode_tuple_t_bytes32__to_t_bytes32__fromStack_reversed(headStart, value0) -> tail\n    {\n        tail := add(headStart, 32)\n        mstore(headStart, value0)\n    }\n    function abi_encode_tuple_t_uint256__to_t_uint256__fromStack_reversed(headStart, value0) -> tail\n    {\n        tail := add(headStart, 32)\n        mstore(headStart, value0)\n    }\n    function abi_decode_tuple_t_uint256(headStart, dataEnd) -> value0\n    {\n        if slt(sub(dataEnd, headStart), 32) { revert(0, 0) }\n        value0 := calldataload(headStart)\n    }\n    function abi_encode_tuple_t_contract$_TestERC20_$41014__to_t_address__fromStack_reversed(headStart, value0) -> tail\n    {\n        tail := add(headStart, 32)\n        mstore(headStart, and(value0, 0xffffffffffffffffffffffffffffffffffffffff))\n    }\n    function panic_error_0x41()\n    {\n        mstore(0, 35408467139433450592217433187231851964531694900788300625387963629091585785856)\n        mstore(4, 0x41)\n        revert(0, 0x24)\n    }\n    function allocate_memory_1198() -> memPtr\n    {\n        memPtr := mload(64)\n        let newFreePtr := add(memPtr, 0x0100)\n        if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr)) { panic_error_0x41() }\n        mstore(64, newFreePtr)\n    }\n    function allocate_memory(size) -> memPtr\n    {\n        memPtr := mload(64)\n        let newFreePtr := add(memPtr, and(add(size, 31), not(31)))\n        if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr)) { panic_error_0x41() }\n        mstore(64, newFreePtr)\n    }\n    function array_allocation_size_bytes(length) -> size\n    {\n        if gt(length, 0xffffffffffffffff) { panic_error_0x41() }\n        size := add(and(add(length, 31), not(31)), 0x20)\n    }\n    function abi_decode_bytes(offset, end) -> array\n    {\n        if iszero(slt(add(offset, 0x1f), end)) { revert(0, 0) }\n        let _1 := calldataload(offset)\n        let array_1 := allocate_memory(array_allocation_size_bytes(_1))\n        mstore(array_1, _1)\n        if gt(add(add(offset, _1), 0x20), end) { revert(0, 0) }\n        calldatacopy(add(array_1, 0x20), add(offset, 0x20), _1)\n        mstore(add(add(array_1, _1), 0x20), 0)\n        array := array_1\n    }\n    function abi_decode_tuple_t_bytes_memory_ptr(headStart, dataEnd) -> value0\n    {\n        if slt(sub(dataEnd, headStart), 32) { revert(0, 0) }\n        let offset := calldataload(headStart)\n        if gt(offset, 0xffffffffffffffff) { revert(0, 0) }\n        value0 := abi_decode_bytes(add(headStart, offset), dataEnd)\n    }\n    function copy_memory_to_memory_with_cleanup(src, dst, length)\n    {\n        let i := 0\n        for { } lt(i, length) { i := add(i, 32) }\n        {\n            mstore(add(dst, i), mload(add(src, i)))\n        }\n        mstore(add(dst, length), 0)\n    }\n    function abi_encode_bytes(value, pos) -> end\n    {\n        let length := mload(value)\n        mstore(pos, length)\n        copy_memory_to_memory_with_cleanup(add(value, 0x20), add(pos, 0x20), length)\n        end := add(add(pos, and(add(length, 31), not(31))), 0x20)\n    }\n    function abi_encode_tuple_t_bytes_memory_ptr__to_t_bytes_memory_ptr__fromStack_reversed(headStart, value0) -> tail\n    {\n        mstore(headStart, 32)\n        tail := abi_encode_bytes(value0, add(headStart, 32))\n    }\n    function abi_decode_tuple_t_addresst_uint256t_uint16t_bytes32t_uint32t_bytes_memory_ptr(headStart, dataEnd) -> value0, value1, value2, value3, value4, value5\n    {\n        if slt(sub(dataEnd, headStart), 192) { revert(0, 0) }\n        value0 := abi_decode_address(headStart)\n        value1 := calldataload(add(headStart, 32))\n        let value := calldataload(add(headStart, 64))\n        validator_revert_uint16(value)\n        value2 := value\n        value3 := calldataload(add(headStart, 96))\n        value4 := abi_decode_uint32(add(headStart, 128))\n        let offset := calldataload(add(headStart, 160))\n        if gt(offset, 0xffffffffffffffff) { revert(0, 0) }\n        value5 := abi_decode_bytes(add(headStart, offset), dataEnd)\n    }\n    function abi_decode_tuple_t_bytes32(headStart, dataEnd) -> value0\n    {\n        if slt(sub(dataEnd, headStart), 32) { revert(0, 0) }\n        value0 := calldataload(headStart)\n    }\n    function abi_encode_uint16(value, pos)\n    {\n        mstore(pos, and(value, 0xffff))\n    }\n    function abi_encode_tuple_t_struct$_TransferWithPayload_$37598_memory_ptr__to_t_struct$_TransferWithPayload_$37598_memory_ptr__fromStack_reversed(headStart, value0) -> tail\n    {\n        mstore(headStart, 32)\n        mstore(add(headStart, 32), and(mload(value0), 0xff))\n        mstore(add(headStart, 64), mload(add(value0, 32)))\n        mstore(add(headStart, 96), mload(add(value0, 64)))\n        mstore(add(headStart, 128), and(mload(add(value0, 96)), 0xffff))\n        mstore(add(headStart, 160), mload(add(value0, 128)))\n        let memberValue0 := mload(add(value0, 160))\n        abi_encode_uint16(memberValue0, add(headStart, 192))\n        mstore(add(headStart, 224), mload(add(value0, 192)))\n        let memberValue0_1 := mload(add(value0, 224))\n        let _1 := 0x0100\n        mstore(add(headStart, _1), _1)\n        tail := abi_encode_bytes(memberValue0_1, add(headStart, 288))\n    }\n    function abi_decode_tuple_t_addresst_uint256(headStart, dataEnd) -> value0, value1\n    {\n        if slt(sub(dataEnd, headStart), 64) { revert(0, 0) }\n        value0 := abi_decode_address(headStart)\n        value1 := calldataload(add(headStart, 32))\n    }\n    function abi_encode_tuple_t_address_t_uint256_t_uint16_t_bytes32_t_uint256_t_uint32__to_t_address_t_uint256_t_uint16_t_bytes32_t_uint256_t_uint32__fromStack_reversed(headStart, value5, value4, value3, value2, value1, value0) -> tail\n    {\n        tail := add(headStart, 192)\n        mstore(headStart, and(value0, 0xffffffffffffffffffffffffffffffffffffffff))\n        mstore(add(headStart, 32), value1)\n        mstore(add(headStart, 64), and(value2, 0xffff))\n        mstore(add(headStart, 96), value3)\n        mstore(add(headStart, 128), value4)\n        mstore(add(headStart, 160), and(value5, 0xffffffff))\n    }\n    function abi_encode_tuple_t_address_t_uint256__to_t_address_t_uint256__fromStack_reversed(headStart, value1, value0) -> tail\n    {\n        tail := add(headStart, 64)\n        mstore(headStart, and(value0, 0xffffffffffffffffffffffffffffffffffffffff))\n        mstore(add(headStart, 32), value1)\n    }\n    function abi_encode_tuple_t_address_t_uint256_t_uint16_t_bytes32_t_uint32_t_bytes_memory_ptr__to_t_address_t_uint256_t_uint16_t_bytes32_t_uint32_t_bytes_memory_ptr__fromStack_reversed(headStart, value5, value4, value3, value2, value1, value0) -> tail\n    {\n        mstore(headStart, and(value0, 0xffffffffffffffffffffffffffffffffffffffff))\n        mstore(add(headStart, 32), value1)\n        mstore(add(headStart, 64), and(value2, 0xffff))\n        mstore(add(headStart, 96), value3)\n        mstore(add(headStart, 128), and(value4, 0xffffffff))\n        mstore(add(headStart, 160), 192)\n        tail := abi_encode_bytes(value5, add(headStart, 192))\n    }\n    function abi_decode_uint8_fromMemory(offset) -> value\n    {\n        value := mload(offset)\n        if iszero(eq(value, and(value, 0xff))) { revert(0, 0) }\n    }\n    function abi_decode_uint16_fromMemory(offset) -> value\n    {\n        value := mload(offset)\n        validator_revert_uint16(value)\n    }\n    function abi_decode_bytes_fromMemory(offset, end) -> array\n    {\n        if iszero(slt(add(offset, 0x1f), end)) { revert(0, 0) }\n        let _1 := mload(offset)\n        let array_1 := allocate_memory(array_allocation_size_bytes(_1))\n        mstore(array_1, _1)\n        if gt(add(add(offset, _1), 0x20), end) { revert(0, 0) }\n        copy_memory_to_memory_with_cleanup(add(offset, 0x20), add(array_1, 0x20), _1)\n        array := array_1\n    }\n    function abi_decode_tuple_t_struct$_TransferWithPayload_$37598_memory_ptr_fromMemory(headStart, dataEnd) -> value0\n    {\n        if slt(sub(dataEnd, headStart), 32) { revert(0, 0) }\n        let offset := mload(headStart)\n        let _1 := 0xffffffffffffffff\n        if gt(offset, _1) { revert(0, 0) }\n        let _2 := add(headStart, offset)\n        if slt(sub(dataEnd, _2), 0x0100) { revert(0, 0) }\n        let value := allocate_memory_1198()\n        mstore(value, abi_decode_uint8_fromMemory(_2))\n        mstore(add(value, 32), mload(add(_2, 32)))\n        mstore(add(value, 64), mload(add(_2, 64)))\n        mstore(add(value, 96), abi_decode_uint16_fromMemory(add(_2, 96)))\n        mstore(add(value, 128), mload(add(_2, 128)))\n        mstore(add(value, 160), abi_decode_uint16_fromMemory(add(_2, 160)))\n        mstore(add(value, 192), mload(add(_2, 192)))\n        let offset_1 := mload(add(_2, 224))\n        if gt(offset_1, _1) { revert(0, 0) }\n        mstore(add(value, 224), abi_decode_bytes_fromMemory(add(_2, offset_1), dataEnd))\n        value0 := value\n    }\n}",
           "id": 125,
           "language": "Yul",
           "name": "#utility.yul"
@@ -8576,7 +8576,7 @@
       ],
       "immutableReferences": {},
       "linkReferences": {},
-      "opcodes": "PUSH1 0x80 PUSH1 0x40 MSTORE PUSH1 0x4 CALLDATASIZE LT PUSH2 0xB1 JUMPI PUSH1 0x0 CALLDATALOAD PUSH1 0xE0 SHR DUP1 PUSH4 0xC3F511C1 GT PUSH2 0x69 JUMPI DUP1 PUSH4 0xE566DF31 GT PUSH2 0x4E JUMPI DUP1 PUSH4 0xE566DF31 EQ PUSH2 0x1BB JUMPI DUP1 PUSH4 0xEA63738D EQ PUSH2 0x1DB JUMPI DUP1 PUSH4 0xEFCB70C0 EQ PUSH2 0x208 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP1 PUSH4 0xC3F511C1 EQ PUSH2 0x17B JUMPI DUP1 PUSH4 0xC5A5EBDA EQ PUSH2 0x1A8 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP1 PUSH4 0x504D27FD GT PUSH2 0x9A JUMPI DUP1 PUSH4 0x504D27FD EQ PUSH2 0x10B JUMPI DUP1 PUSH4 0x81C82233 EQ PUSH2 0x121 JUMPI DUP1 PUSH4 0x9542C9F1 EQ PUSH2 0x143 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP1 PUSH4 0xF5287B0 EQ PUSH2 0xB6 JUMPI DUP1 PUSH4 0x16FED3E2 EQ PUSH2 0xE7 JUMPI JUMPDEST PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0xC9 PUSH2 0xC4 CALLDATASIZE PUSH1 0x4 PUSH2 0x577 JUMP JUMPDEST PUSH2 0x228 JUMP JUMPDEST PUSH1 0x40 MLOAD PUSH8 0xFFFFFFFFFFFFFFFF SWAP1 SWAP2 AND DUP2 MSTORE PUSH1 0x20 ADD JUMPDEST PUSH1 0x40 MLOAD DUP1 SWAP2 SUB SWAP1 RETURN JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0xF3 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0xFD PUSH1 0x2 SLOAD DUP2 JUMP JUMPDEST PUSH1 0x40 MLOAD SWAP1 DUP2 MSTORE PUSH1 0x20 ADD PUSH2 0xDE JUMP JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x117 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0xFD PUSH1 0x1 SLOAD DUP2 JUMP JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x12D JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0x141 PUSH2 0x13C CALLDATASIZE PUSH1 0x4 PUSH2 0x5D8 JUMP JUMPDEST PUSH1 0x1 SSTORE JUMP JUMPDEST STOP JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x14F JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH1 0x0 SLOAD PUSH2 0x163 SWAP1 PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB AND DUP2 JUMP JUMPDEST PUSH1 0x40 MLOAD PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB SWAP1 SWAP2 AND DUP2 MSTORE PUSH1 0x20 ADD PUSH2 0xDE JUMP JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x187 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0x19B PUSH2 0x196 CALLDATASIZE PUSH1 0x4 PUSH2 0x6F9 JUMP JUMPDEST PUSH2 0x2A0 JUMP JUMPDEST PUSH1 0x40 MLOAD PUSH2 0xDE SWAP2 SWAP1 PUSH2 0x786 JUMP JUMPDEST PUSH2 0xC9 PUSH2 0x1B6 CALLDATASIZE PUSH1 0x4 PUSH2 0x7A0 JUMP JUMPDEST PUSH2 0x41E JUMP JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x1C7 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0x141 PUSH2 0x1D6 CALLDATASIZE PUSH1 0x4 PUSH2 0x5D8 JUMP JUMPDEST PUSH1 0x2 SSTORE JUMP JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x1E7 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0x1FB PUSH2 0x1F6 CALLDATASIZE PUSH1 0x4 PUSH2 0x6F9 JUMP JUMPDEST PUSH2 0x46F JUMP JUMPDEST PUSH1 0x40 MLOAD PUSH2 0xDE SWAP2 SWAP1 PUSH2 0x823 JUMP JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x214 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0x141 PUSH2 0x223 CALLDATASIZE PUSH1 0x4 PUSH2 0x89B JUMP JUMPDEST PUSH2 0x4CA JUMP JUMPDEST PUSH1 0x40 DUP1 MLOAD PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB DUP9 AND DUP2 MSTORE PUSH1 0x20 DUP2 ADD DUP8 SWAP1 MSTORE PUSH2 0xFFFF DUP7 AND DUP2 DUP4 ADD MSTORE PUSH1 0x60 DUP2 ADD DUP6 SWAP1 MSTORE PUSH1 0x80 DUP2 ADD DUP5 SWAP1 MSTORE PUSH4 0xFFFFFFFF DUP4 AND PUSH1 0xA0 DUP3 ADD MSTORE SWAP1 MLOAD PUSH1 0x0 SWAP2 PUSH32 0x4D24EF3F381C3D7E8696045268F69C41EC3DEE2C5BD1AAA48DAF8EC2EC7FE436 SWAP2 SWAP1 DUP2 SWAP1 SUB PUSH1 0xC0 ADD SWAP1 LOG1 POP PUSH2 0x309 SWAP7 SWAP6 POP POP POP POP POP POP JUMP JUMPDEST PUSH1 0x60 PUSH32 0x6EFACCD86B6CE8325DB6AD038D68E09F9B1AF9A0FC1ED121EBE9D870AAFC2086 DUP3 PUSH1 0x40 MLOAD PUSH2 0x2D1 SWAP2 SWAP1 PUSH2 0x786 JUMP JUMPDEST PUSH1 0x40 MLOAD DUP1 SWAP2 SUB SWAP1 LOG1 PUSH1 0x0 SLOAD PUSH1 0x1 SLOAD PUSH1 0x40 MLOAD PUSH4 0x40C10F19 PUSH1 0xE0 SHL DUP2 MSTORE CALLER PUSH1 0x4 DUP3 ADD MSTORE PUSH1 0x24 DUP2 ADD SWAP2 SWAP1 SWAP2 MSTORE PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB SWAP1 SWAP2 AND SWAP1 PUSH4 0x40C10F19 SWAP1 PUSH1 0x44 ADD PUSH1 0x0 PUSH1 0x40 MLOAD DUP1 DUP4 SUB DUP2 PUSH1 0x0 DUP8 DUP1 EXTCODESIZE ISZERO DUP1 ISZERO PUSH2 0x329 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP GAS CALL ISZERO DUP1 ISZERO PUSH2 0x33D JUMPI RETURNDATASIZE PUSH1 0x0 DUP1 RETURNDATACOPY RETURNDATASIZE PUSH1 0x0 REVERT JUMPDEST POP POP PUSH1 0x40 DUP1 MLOAD PUSH2 0x100 DUP2 ADD DUP3 MSTORE PUSH1 0x1 DUP2 MSTORE PUSH1 0x2 PUSH1 0x20 DUP1 DUP4 ADD DUP3 SWAP1 MSTORE PUSH32 0x3000000000000000000000000000000000000000000000000000000000000000 DUP4 DUP6 ADD MSTORE PUSH1 0x4 PUSH1 0x60 DUP5 ADD MSTORE PUSH32 0x5000000000000000000000000000000000000000000000000000000000000000 PUSH1 0x80 DUP5 ADD MSTORE PUSH1 0x6 PUSH1 0xA0 DUP5 ADD MSTORE PUSH32 0x7000000000000000000000000000000000000000000000000000000000000000 PUSH1 0xC0 DUP5 ADD MSTORE SWAP1 SLOAD DUP4 MLOAD DUP1 DUP4 ADD SWAP2 SWAP1 SWAP2 MSTORE DUP4 MLOAD DUP1 DUP3 SUB DUP4 ADD DUP2 MSTORE SWAP1 DUP5 ADD DUP5 MSTORE PUSH1 0xE0 DUP4 ADD MSTORE SWAP2 MLOAD SWAP1 SWAP4 POP PUSH2 0x407 SWAP3 POP DUP4 SWAP2 ADD PUSH2 0x823 JUMP JUMPDEST PUSH1 0x40 MLOAD PUSH1 0x20 DUP2 DUP4 SUB SUB DUP2 MSTORE SWAP1 PUSH1 0x40 MSTORE SWAP2 POP POP SWAP2 SWAP1 POP JUMP JUMPDEST PUSH1 0x0 PUSH32 0x8F36AA28E4F86A5B6D397422D004B60E74EDA866A331D074749B789D70CA3144 DUP8 DUP8 DUP8 DUP8 DUP8 DUP8 PUSH1 0x40 MLOAD PUSH2 0x459 SWAP7 SWAP6 SWAP5 SWAP4 SWAP3 SWAP2 SWAP1 PUSH2 0x8C5 JUMP JUMPDEST PUSH1 0x40 MLOAD DUP1 SWAP2 SUB SWAP1 LOG1 POP PUSH2 0x378 SWAP7 SWAP6 POP POP POP POP POP POP JUMP JUMPDEST PUSH1 0x40 DUP1 MLOAD PUSH2 0x100 DUP2 ADD DUP3 MSTORE PUSH1 0x0 DUP1 DUP3 MSTORE PUSH1 0x20 DUP1 DUP4 ADD DUP3 SWAP1 MSTORE SWAP3 DUP3 ADD DUP2 SWAP1 MSTORE PUSH1 0x60 DUP1 DUP4 ADD DUP3 SWAP1 MSTORE PUSH1 0x80 DUP4 ADD DUP3 SWAP1 MSTORE PUSH1 0xA0 DUP4 ADD DUP3 SWAP1 MSTORE PUSH1 0xC0 DUP4 ADD SWAP2 SWAP1 SWAP2 MSTORE PUSH1 0xE0 DUP3 ADD MSTORE DUP3 MLOAD SWAP1 SWAP2 PUSH2 0x4C4 SWAP2 DUP5 ADD DUP2 ADD SWAP1 DUP5 ADD PUSH2 0x976 JUMP JUMPDEST SWAP3 SWAP2 POP POP JUMP JUMPDEST PUSH1 0x0 SLOAD PUSH1 0x40 MLOAD PUSH4 0x40C10F19 PUSH1 0xE0 SHL DUP2 MSTORE PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB DUP5 DUP2 AND PUSH1 0x4 DUP4 ADD MSTORE PUSH1 0x24 DUP3 ADD DUP5 SWAP1 MSTORE SWAP1 SWAP2 AND SWAP1 PUSH4 0x40C10F19 SWAP1 PUSH1 0x44 ADD PUSH1 0x0 PUSH1 0x40 MLOAD DUP1 DUP4 SUB DUP2 PUSH1 0x0 DUP8 DUP1 EXTCODESIZE ISZERO DUP1 ISZERO PUSH2 0x518 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP GAS CALL ISZERO DUP1 ISZERO PUSH2 0x52C JUMPI RETURNDATASIZE PUSH1 0x0 DUP1 RETURNDATACOPY RETURNDATASIZE PUSH1 0x0 REVERT JUMPDEST POP POP POP POP POP POP JUMP JUMPDEST DUP1 CALLDATALOAD PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB DUP2 AND DUP2 EQ PUSH2 0x54B JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST SWAP2 SWAP1 POP JUMP JUMPDEST PUSH2 0xFFFF DUP2 AND DUP2 EQ PUSH2 0x560 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP JUMP JUMPDEST DUP1 CALLDATALOAD PUSH4 0xFFFFFFFF DUP2 AND DUP2 EQ PUSH2 0x54B JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH1 0x0 DUP1 PUSH1 0x0 DUP1 PUSH1 0x0 DUP1 PUSH1 0xC0 DUP8 DUP10 SUB SLT ISZERO PUSH2 0x590 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0x599 DUP8 PUSH2 0x534 JUMP JUMPDEST SWAP6 POP PUSH1 0x20 DUP8 ADD CALLDATALOAD SWAP5 POP PUSH1 0x40 DUP8 ADD CALLDATALOAD PUSH2 0x5B0 DUP2 PUSH2 0x550 JUMP JUMPDEST SWAP4 POP PUSH1 0x60 DUP8 ADD CALLDATALOAD SWAP3 POP PUSH1 0x80 DUP8 ADD CALLDATALOAD SWAP2 POP PUSH2 0x5CC PUSH1 0xA0 DUP9 ADD PUSH2 0x563 JUMP JUMPDEST SWAP1 POP SWAP3 SWAP6 POP SWAP3 SWAP6 POP SWAP3 SWAP6 JUMP JUMPDEST PUSH1 0x0 PUSH1 0x20 DUP3 DUP5 SUB SLT ISZERO PUSH2 0x5EA JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP CALLDATALOAD SWAP2 SWAP1 POP JUMP JUMPDEST PUSH32 0x4E487B7100000000000000000000000000000000000000000000000000000000 PUSH1 0x0 MSTORE PUSH1 0x41 PUSH1 0x4 MSTORE PUSH1 0x24 PUSH1 0x0 REVERT JUMPDEST PUSH1 0x40 MLOAD PUSH2 0x100 DUP2 ADD PUSH8 0xFFFFFFFFFFFFFFFF DUP2 GT DUP3 DUP3 LT OR ISZERO PUSH2 0x644 JUMPI PUSH2 0x644 PUSH2 0x5F1 JUMP JUMPDEST PUSH1 0x40 MSTORE SWAP1 JUMP JUMPDEST PUSH1 0x40 MLOAD PUSH1 0x1F DUP3 ADD PUSH1 0x1F NOT AND DUP2 ADD PUSH8 0xFFFFFFFFFFFFFFFF DUP2 GT DUP3 DUP3 LT OR ISZERO PUSH2 0x673 JUMPI PUSH2 0x673 PUSH2 0x5F1 JUMP JUMPDEST PUSH1 0x40 MSTORE SWAP2 SWAP1 POP JUMP JUMPDEST PUSH1 0x0 PUSH8 0xFFFFFFFFFFFFFFFF DUP3 GT ISZERO PUSH2 0x695 JUMPI PUSH2 0x695 PUSH2 0x5F1 JUMP JUMPDEST POP PUSH1 0x1F ADD PUSH1 0x1F NOT AND PUSH1 0x20 ADD SWAP1 JUMP JUMPDEST PUSH1 0x0 DUP3 PUSH1 0x1F DUP4 ADD SLT PUSH2 0x6B4 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP2 CALLDATALOAD PUSH2 0x6C7 PUSH2 0x6C2 DUP3 PUSH2 0x67B JUMP JUMPDEST PUSH2 0x64A JUMP JUMPDEST DUP2 DUP2 MSTORE DUP5 PUSH1 0x20 DUP4 DUP7 ADD ADD GT ISZERO PUSH2 0x6DC JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP2 PUSH1 0x20 DUP6 ADD PUSH1 0x20 DUP4 ADD CALLDATACOPY PUSH1 0x0 SWAP2 DUP2 ADD PUSH1 0x20 ADD SWAP2 SWAP1 SWAP2 MSTORE SWAP4 SWAP3 POP POP POP JUMP JUMPDEST PUSH1 0x0 PUSH1 0x20 DUP3 DUP5 SUB SLT ISZERO PUSH2 0x70B JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP2 CALLDATALOAD PUSH8 0xFFFFFFFFFFFFFFFF DUP2 GT ISZERO PUSH2 0x722 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0x72E DUP5 DUP3 DUP6 ADD PUSH2 0x6A3 JUMP JUMPDEST SWAP5 SWAP4 POP POP POP POP JUMP JUMPDEST PUSH1 0x0 JUMPDEST DUP4 DUP2 LT ISZERO PUSH2 0x751 JUMPI DUP2 DUP2 ADD MLOAD DUP4 DUP3 ADD MSTORE PUSH1 0x20 ADD PUSH2 0x739 JUMP JUMPDEST POP POP PUSH1 0x0 SWAP2 ADD MSTORE JUMP JUMPDEST PUSH1 0x0 DUP2 MLOAD DUP1 DUP5 MSTORE PUSH2 0x772 DUP2 PUSH1 0x20 DUP7 ADD PUSH1 0x20 DUP7 ADD PUSH2 0x736 JUMP JUMPDEST PUSH1 0x1F ADD PUSH1 0x1F NOT AND SWAP3 SWAP1 SWAP3 ADD PUSH1 0x20 ADD SWAP3 SWAP2 POP POP JUMP JUMPDEST PUSH1 0x20 DUP2 MSTORE PUSH1 0x0 PUSH2 0x799 PUSH1 0x20 DUP4 ADD DUP5 PUSH2 0x75A JUMP JUMPDEST SWAP4 SWAP3 POP POP POP JUMP JUMPDEST PUSH1 0x0 DUP1 PUSH1 0x0 DUP1 PUSH1 0x0 DUP1 PUSH1 0xC0 DUP8 DUP10 SUB SLT ISZERO PUSH2 0x7B9 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0x7C2 DUP8 PUSH2 0x534 JUMP JUMPDEST SWAP6 POP PUSH1 0x20 DUP8 ADD CALLDATALOAD SWAP5 POP PUSH1 0x40 DUP8 ADD CALLDATALOAD PUSH2 0x7D9 DUP2 PUSH2 0x550 JUMP JUMPDEST SWAP4 POP PUSH1 0x60 DUP8 ADD CALLDATALOAD SWAP3 POP PUSH2 0x7EE PUSH1 0x80 DUP9 ADD PUSH2 0x563 JUMP JUMPDEST SWAP2 POP PUSH1 0xA0 DUP8 ADD CALLDATALOAD PUSH8 0xFFFFFFFFFFFFFFFF DUP2 GT ISZERO PUSH2 0x80A JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0x816 DUP10 DUP3 DUP11 ADD PUSH2 0x6A3 JUMP JUMPDEST SWAP2 POP POP SWAP3 SWAP6 POP SWAP3 SWAP6 POP SWAP3 SWAP6 JUMP JUMPDEST PUSH1 0x20 DUP2 MSTORE PUSH1 0xFF DUP3 MLOAD AND PUSH1 0x20 DUP3 ADD MSTORE PUSH1 0x20 DUP3 ADD MLOAD PUSH1 0x40 DUP3 ADD MSTORE PUSH1 0x40 DUP3 ADD MLOAD PUSH1 0x60 DUP3 ADD MSTORE PUSH2 0xFFFF PUSH1 0x60 DUP4 ADD MLOAD AND PUSH1 0x80 DUP3 ADD MSTORE PUSH1 0x80 DUP3 ADD MLOAD PUSH1 0xA0 DUP3 ADD MSTORE PUSH1 0x0 PUSH1 0xA0 DUP4 ADD MLOAD PUSH2 0x874 PUSH1 0xC0 DUP5 ADD DUP3 PUSH2 0xFFFF AND SWAP1 MSTORE JUMP JUMPDEST POP PUSH1 0xC0 DUP4 ADD MLOAD PUSH1 0xE0 DUP4 ADD MSTORE PUSH1 0xE0 DUP4 ADD MLOAD PUSH2 0x100 DUP1 DUP2 DUP6 ADD MSTORE POP PUSH2 0x72E PUSH2 0x120 DUP5 ADD DUP3 PUSH2 0x75A JUMP JUMPDEST PUSH1 0x0 DUP1 PUSH1 0x40 DUP4 DUP6 SUB SLT ISZERO PUSH2 0x8AE JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0x8B7 DUP4 PUSH2 0x534 JUMP JUMPDEST SWAP5 PUSH1 0x20 SWAP4 SWAP1 SWAP4 ADD CALLDATALOAD SWAP4 POP POP POP JUMP JUMPDEST PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB DUP8 AND DUP2 MSTORE DUP6 PUSH1 0x20 DUP3 ADD MSTORE PUSH2 0xFFFF DUP6 AND PUSH1 0x40 DUP3 ADD MSTORE DUP4 PUSH1 0x60 DUP3 ADD MSTORE PUSH4 0xFFFFFFFF DUP4 AND PUSH1 0x80 DUP3 ADD MSTORE PUSH1 0xC0 PUSH1 0xA0 DUP3 ADD MSTORE PUSH1 0x0 PUSH2 0x909 PUSH1 0xC0 DUP4 ADD DUP5 PUSH2 0x75A JUMP JUMPDEST SWAP9 SWAP8 POP POP POP POP POP POP POP POP JUMP JUMPDEST DUP1 MLOAD PUSH1 0xFF DUP2 AND DUP2 EQ PUSH2 0x54B JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP1 MLOAD PUSH2 0x54B DUP2 PUSH2 0x550 JUMP JUMPDEST PUSH1 0x0 DUP3 PUSH1 0x1F DUP4 ADD SLT PUSH2 0x942 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP2 MLOAD PUSH2 0x950 PUSH2 0x6C2 DUP3 PUSH2 0x67B JUMP JUMPDEST DUP2 DUP2 MSTORE DUP5 PUSH1 0x20 DUP4 DUP7 ADD ADD GT ISZERO PUSH2 0x965 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0x72E DUP3 PUSH1 0x20 DUP4 ADD PUSH1 0x20 DUP8 ADD PUSH2 0x736 JUMP JUMPDEST PUSH1 0x0 PUSH1 0x20 DUP3 DUP5 SUB SLT ISZERO PUSH2 0x988 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP2 MLOAD PUSH8 0xFFFFFFFFFFFFFFFF DUP1 DUP3 GT ISZERO PUSH2 0x9A0 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST SWAP1 DUP4 ADD SWAP1 PUSH2 0x100 DUP3 DUP7 SUB SLT ISZERO PUSH2 0x9B5 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0x9BD PUSH2 0x620 JUMP JUMPDEST PUSH2 0x9C6 DUP4 PUSH2 0x915 JUMP JUMPDEST DUP2 MSTORE PUSH1 0x20 DUP4 ADD MLOAD PUSH1 0x20 DUP3 ADD MSTORE PUSH1 0x40 DUP4 ADD MLOAD PUSH1 0x40 DUP3 ADD MSTORE PUSH2 0x9E8 PUSH1 0x60 DUP5 ADD PUSH2 0x926 JUMP JUMPDEST PUSH1 0x60 DUP3 ADD MSTORE PUSH1 0x80 DUP4 ADD MLOAD PUSH1 0x80 DUP3 ADD MSTORE PUSH2 0xA03 PUSH1 0xA0 DUP5 ADD PUSH2 0x926 JUMP JUMPDEST PUSH1 0xA0 DUP3 ADD MSTORE PUSH1 0xC0 DUP4 ADD MLOAD PUSH1 0xC0 DUP3 ADD MSTORE PUSH1 0xE0 DUP4 ADD MLOAD DUP3 DUP2 GT ISZERO PUSH2 0xA24 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0xA30 DUP8 DUP3 DUP7 ADD PUSH2 0x931 JUMP JUMPDEST PUSH1 0xE0 DUP4 ADD MSTORE POP SWAP6 SWAP5 POP POP POP POP POP JUMP INVALID LOG2 PUSH5 0x6970667358 0x22 SLT KECCAK256 0xD6 PUSH7 0xF4ABAA644E652F PUSH11 0xF266DCFACD11E95277B42F BALANCE DUP1 0xB2 0xFB 0xD1 BALANCE 0xDC 0x28 NOT 0x4E 0xF8 PUSH5 0x736F6C6343 STOP ADDMOD GT STOP CALLER ",
+      "opcodes": "PUSH1 0x80 PUSH1 0x40 MSTORE PUSH1 0x4 CALLDATASIZE LT PUSH2 0xB1 JUMPI PUSH1 0x0 CALLDATALOAD PUSH1 0xE0 SHR DUP1 PUSH4 0xC3F511C1 GT PUSH2 0x69 JUMPI DUP1 PUSH4 0xE566DF31 GT PUSH2 0x4E JUMPI DUP1 PUSH4 0xE566DF31 EQ PUSH2 0x1BB JUMPI DUP1 PUSH4 0xEA63738D EQ PUSH2 0x1DB JUMPI DUP1 PUSH4 0xEFCB70C0 EQ PUSH2 0x208 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP1 PUSH4 0xC3F511C1 EQ PUSH2 0x17B JUMPI DUP1 PUSH4 0xC5A5EBDA EQ PUSH2 0x1A8 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP1 PUSH4 0x504D27FD GT PUSH2 0x9A JUMPI DUP1 PUSH4 0x504D27FD EQ PUSH2 0x10B JUMPI DUP1 PUSH4 0x81C82233 EQ PUSH2 0x121 JUMPI DUP1 PUSH4 0x9542C9F1 EQ PUSH2 0x143 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP1 PUSH4 0xF5287B0 EQ PUSH2 0xB6 JUMPI DUP1 PUSH4 0x16FED3E2 EQ PUSH2 0xE7 JUMPI JUMPDEST PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0xC9 PUSH2 0xC4 CALLDATASIZE PUSH1 0x4 PUSH2 0x577 JUMP JUMPDEST PUSH2 0x228 JUMP JUMPDEST PUSH1 0x40 MLOAD PUSH8 0xFFFFFFFFFFFFFFFF SWAP1 SWAP2 AND DUP2 MSTORE PUSH1 0x20 ADD JUMPDEST PUSH1 0x40 MLOAD DUP1 SWAP2 SUB SWAP1 RETURN JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0xF3 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0xFD PUSH1 0x2 SLOAD DUP2 JUMP JUMPDEST PUSH1 0x40 MLOAD SWAP1 DUP2 MSTORE PUSH1 0x20 ADD PUSH2 0xDE JUMP JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x117 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0xFD PUSH1 0x1 SLOAD DUP2 JUMP JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x12D JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0x141 PUSH2 0x13C CALLDATASIZE PUSH1 0x4 PUSH2 0x5D8 JUMP JUMPDEST PUSH1 0x1 SSTORE JUMP JUMPDEST STOP JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x14F JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH1 0x0 SLOAD PUSH2 0x163 SWAP1 PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB AND DUP2 JUMP JUMPDEST PUSH1 0x40 MLOAD PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB SWAP1 SWAP2 AND DUP2 MSTORE PUSH1 0x20 ADD PUSH2 0xDE JUMP JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x187 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0x19B PUSH2 0x196 CALLDATASIZE PUSH1 0x4 PUSH2 0x6F9 JUMP JUMPDEST PUSH2 0x2A0 JUMP JUMPDEST PUSH1 0x40 MLOAD PUSH2 0xDE SWAP2 SWAP1 PUSH2 0x786 JUMP JUMPDEST PUSH2 0xC9 PUSH2 0x1B6 CALLDATASIZE PUSH1 0x4 PUSH2 0x7A0 JUMP JUMPDEST PUSH2 0x41E JUMP JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x1C7 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0x141 PUSH2 0x1D6 CALLDATASIZE PUSH1 0x4 PUSH2 0x5D8 JUMP JUMPDEST PUSH1 0x2 SSTORE JUMP JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x1E7 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0x1FB PUSH2 0x1F6 CALLDATASIZE PUSH1 0x4 PUSH2 0x6F9 JUMP JUMPDEST PUSH2 0x46F JUMP JUMPDEST PUSH1 0x40 MLOAD PUSH2 0xDE SWAP2 SWAP1 PUSH2 0x823 JUMP JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x214 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0x141 PUSH2 0x223 CALLDATASIZE PUSH1 0x4 PUSH2 0x89B JUMP JUMPDEST PUSH2 0x4CA JUMP JUMPDEST PUSH1 0x40 DUP1 MLOAD PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB DUP9 AND DUP2 MSTORE PUSH1 0x20 DUP2 ADD DUP8 SWAP1 MSTORE PUSH2 0xFFFF DUP7 AND DUP2 DUP4 ADD MSTORE PUSH1 0x60 DUP2 ADD DUP6 SWAP1 MSTORE PUSH1 0x80 DUP2 ADD DUP5 SWAP1 MSTORE PUSH4 0xFFFFFFFF DUP4 AND PUSH1 0xA0 DUP3 ADD MSTORE SWAP1 MLOAD PUSH1 0x0 SWAP2 PUSH32 0x4D24EF3F381C3D7E8696045268F69C41EC3DEE2C5BD1AAA48DAF8EC2EC7FE436 SWAP2 SWAP1 DUP2 SWAP1 SUB PUSH1 0xC0 ADD SWAP1 LOG1 POP PUSH2 0x309 SWAP7 SWAP6 POP POP POP POP POP POP JUMP JUMPDEST PUSH1 0x60 PUSH32 0x6EFACCD86B6CE8325DB6AD038D68E09F9B1AF9A0FC1ED121EBE9D870AAFC2086 DUP3 PUSH1 0x40 MLOAD PUSH2 0x2D1 SWAP2 SWAP1 PUSH2 0x786 JUMP JUMPDEST PUSH1 0x40 MLOAD DUP1 SWAP2 SUB SWAP1 LOG1 PUSH1 0x0 SLOAD PUSH1 0x1 SLOAD PUSH1 0x40 MLOAD PUSH4 0x40C10F19 PUSH1 0xE0 SHL DUP2 MSTORE CALLER PUSH1 0x4 DUP3 ADD MSTORE PUSH1 0x24 DUP2 ADD SWAP2 SWAP1 SWAP2 MSTORE PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB SWAP1 SWAP2 AND SWAP1 PUSH4 0x40C10F19 SWAP1 PUSH1 0x44 ADD PUSH1 0x0 PUSH1 0x40 MLOAD DUP1 DUP4 SUB DUP2 PUSH1 0x0 DUP8 DUP1 EXTCODESIZE ISZERO DUP1 ISZERO PUSH2 0x329 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP GAS CALL ISZERO DUP1 ISZERO PUSH2 0x33D JUMPI RETURNDATASIZE PUSH1 0x0 DUP1 RETURNDATACOPY RETURNDATASIZE PUSH1 0x0 REVERT JUMPDEST POP POP PUSH1 0x40 DUP1 MLOAD PUSH2 0x100 DUP2 ADD DUP3 MSTORE PUSH1 0x1 DUP2 MSTORE PUSH1 0x2 PUSH1 0x20 DUP1 DUP4 ADD DUP3 SWAP1 MSTORE PUSH32 0x3000000000000000000000000000000000000000000000000000000000000000 DUP4 DUP6 ADD MSTORE PUSH1 0x4 PUSH1 0x60 DUP5 ADD MSTORE PUSH32 0x5000000000000000000000000000000000000000000000000000000000000000 PUSH1 0x80 DUP5 ADD MSTORE PUSH1 0x6 PUSH1 0xA0 DUP5 ADD MSTORE PUSH32 0x7000000000000000000000000000000000000000000000000000000000000000 PUSH1 0xC0 DUP5 ADD MSTORE SWAP1 SLOAD DUP4 MLOAD DUP1 DUP4 ADD SWAP2 SWAP1 SWAP2 MSTORE DUP4 MLOAD DUP1 DUP3 SUB DUP4 ADD DUP2 MSTORE SWAP1 DUP5 ADD DUP5 MSTORE PUSH1 0xE0 DUP4 ADD MSTORE SWAP2 MLOAD SWAP1 SWAP4 POP PUSH2 0x407 SWAP3 POP DUP4 SWAP2 ADD PUSH2 0x823 JUMP JUMPDEST PUSH1 0x40 MLOAD PUSH1 0x20 DUP2 DUP4 SUB SUB DUP2 MSTORE SWAP1 PUSH1 0x40 MSTORE SWAP2 POP POP SWAP2 SWAP1 POP JUMP JUMPDEST PUSH1 0x0 PUSH32 0x8F36AA28E4F86A5B6D397422D004B60E74EDA866A331D074749B789D70CA3144 DUP8 DUP8 DUP8 DUP8 DUP8 DUP8 PUSH1 0x40 MLOAD PUSH2 0x459 SWAP7 SWAP6 SWAP5 SWAP4 SWAP3 SWAP2 SWAP1 PUSH2 0x8C5 JUMP JUMPDEST PUSH1 0x40 MLOAD DUP1 SWAP2 SUB SWAP1 LOG1 POP PUSH2 0x378 SWAP7 SWAP6 POP POP POP POP POP POP JUMP JUMPDEST PUSH1 0x40 DUP1 MLOAD PUSH2 0x100 DUP2 ADD DUP3 MSTORE PUSH1 0x0 DUP1 DUP3 MSTORE PUSH1 0x20 DUP1 DUP4 ADD DUP3 SWAP1 MSTORE SWAP3 DUP3 ADD DUP2 SWAP1 MSTORE PUSH1 0x60 DUP1 DUP4 ADD DUP3 SWAP1 MSTORE PUSH1 0x80 DUP4 ADD DUP3 SWAP1 MSTORE PUSH1 0xA0 DUP4 ADD DUP3 SWAP1 MSTORE PUSH1 0xC0 DUP4 ADD SWAP2 SWAP1 SWAP2 MSTORE PUSH1 0xE0 DUP3 ADD MSTORE DUP3 MLOAD SWAP1 SWAP2 PUSH2 0x4C4 SWAP2 DUP5 ADD DUP2 ADD SWAP1 DUP5 ADD PUSH2 0x976 JUMP JUMPDEST SWAP3 SWAP2 POP POP JUMP JUMPDEST PUSH1 0x0 SLOAD PUSH1 0x40 MLOAD PUSH4 0x40C10F19 PUSH1 0xE0 SHL DUP2 MSTORE PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB DUP5 DUP2 AND PUSH1 0x4 DUP4 ADD MSTORE PUSH1 0x24 DUP3 ADD DUP5 SWAP1 MSTORE SWAP1 SWAP2 AND SWAP1 PUSH4 0x40C10F19 SWAP1 PUSH1 0x44 ADD PUSH1 0x0 PUSH1 0x40 MLOAD DUP1 DUP4 SUB DUP2 PUSH1 0x0 DUP8 DUP1 EXTCODESIZE ISZERO DUP1 ISZERO PUSH2 0x518 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP GAS CALL ISZERO DUP1 ISZERO PUSH2 0x52C JUMPI RETURNDATASIZE PUSH1 0x0 DUP1 RETURNDATACOPY RETURNDATASIZE PUSH1 0x0 REVERT JUMPDEST POP POP POP POP POP POP JUMP JUMPDEST DUP1 CALLDATALOAD PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB DUP2 AND DUP2 EQ PUSH2 0x54B JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST SWAP2 SWAP1 POP JUMP JUMPDEST PUSH2 0xFFFF DUP2 AND DUP2 EQ PUSH2 0x560 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP JUMP JUMPDEST DUP1 CALLDATALOAD PUSH4 0xFFFFFFFF DUP2 AND DUP2 EQ PUSH2 0x54B JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH1 0x0 DUP1 PUSH1 0x0 DUP1 PUSH1 0x0 DUP1 PUSH1 0xC0 DUP8 DUP10 SUB SLT ISZERO PUSH2 0x590 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0x599 DUP8 PUSH2 0x534 JUMP JUMPDEST SWAP6 POP PUSH1 0x20 DUP8 ADD CALLDATALOAD SWAP5 POP PUSH1 0x40 DUP8 ADD CALLDATALOAD PUSH2 0x5B0 DUP2 PUSH2 0x550 JUMP JUMPDEST SWAP4 POP PUSH1 0x60 DUP8 ADD CALLDATALOAD SWAP3 POP PUSH1 0x80 DUP8 ADD CALLDATALOAD SWAP2 POP PUSH2 0x5CC PUSH1 0xA0 DUP9 ADD PUSH2 0x563 JUMP JUMPDEST SWAP1 POP SWAP3 SWAP6 POP SWAP3 SWAP6 POP SWAP3 SWAP6 JUMP JUMPDEST PUSH1 0x0 PUSH1 0x20 DUP3 DUP5 SUB SLT ISZERO PUSH2 0x5EA JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP CALLDATALOAD SWAP2 SWAP1 POP JUMP JUMPDEST PUSH32 0x4E487B7100000000000000000000000000000000000000000000000000000000 PUSH1 0x0 MSTORE PUSH1 0x41 PUSH1 0x4 MSTORE PUSH1 0x24 PUSH1 0x0 REVERT JUMPDEST PUSH1 0x40 MLOAD PUSH2 0x100 DUP2 ADD PUSH8 0xFFFFFFFFFFFFFFFF DUP2 GT DUP3 DUP3 LT OR ISZERO PUSH2 0x644 JUMPI PUSH2 0x644 PUSH2 0x5F1 JUMP JUMPDEST PUSH1 0x40 MSTORE SWAP1 JUMP JUMPDEST PUSH1 0x40 MLOAD PUSH1 0x1F DUP3 ADD PUSH1 0x1F NOT AND DUP2 ADD PUSH8 0xFFFFFFFFFFFFFFFF DUP2 GT DUP3 DUP3 LT OR ISZERO PUSH2 0x673 JUMPI PUSH2 0x673 PUSH2 0x5F1 JUMP JUMPDEST PUSH1 0x40 MSTORE SWAP2 SWAP1 POP JUMP JUMPDEST PUSH1 0x0 PUSH8 0xFFFFFFFFFFFFFFFF DUP3 GT ISZERO PUSH2 0x695 JUMPI PUSH2 0x695 PUSH2 0x5F1 JUMP JUMPDEST POP PUSH1 0x1F ADD PUSH1 0x1F NOT AND PUSH1 0x20 ADD SWAP1 JUMP JUMPDEST PUSH1 0x0 DUP3 PUSH1 0x1F DUP4 ADD SLT PUSH2 0x6B4 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP2 CALLDATALOAD PUSH2 0x6C7 PUSH2 0x6C2 DUP3 PUSH2 0x67B JUMP JUMPDEST PUSH2 0x64A JUMP JUMPDEST DUP2 DUP2 MSTORE DUP5 PUSH1 0x20 DUP4 DUP7 ADD ADD GT ISZERO PUSH2 0x6DC JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP2 PUSH1 0x20 DUP6 ADD PUSH1 0x20 DUP4 ADD CALLDATACOPY PUSH1 0x0 SWAP2 DUP2 ADD PUSH1 0x20 ADD SWAP2 SWAP1 SWAP2 MSTORE SWAP4 SWAP3 POP POP POP JUMP JUMPDEST PUSH1 0x0 PUSH1 0x20 DUP3 DUP5 SUB SLT ISZERO PUSH2 0x70B JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP2 CALLDATALOAD PUSH8 0xFFFFFFFFFFFFFFFF DUP2 GT ISZERO PUSH2 0x722 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0x72E DUP5 DUP3 DUP6 ADD PUSH2 0x6A3 JUMP JUMPDEST SWAP5 SWAP4 POP POP POP POP JUMP JUMPDEST PUSH1 0x0 JUMPDEST DUP4 DUP2 LT ISZERO PUSH2 0x751 JUMPI DUP2 DUP2 ADD MLOAD DUP4 DUP3 ADD MSTORE PUSH1 0x20 ADD PUSH2 0x739 JUMP JUMPDEST POP POP PUSH1 0x0 SWAP2 ADD MSTORE JUMP JUMPDEST PUSH1 0x0 DUP2 MLOAD DUP1 DUP5 MSTORE PUSH2 0x772 DUP2 PUSH1 0x20 DUP7 ADD PUSH1 0x20 DUP7 ADD PUSH2 0x736 JUMP JUMPDEST PUSH1 0x1F ADD PUSH1 0x1F NOT AND SWAP3 SWAP1 SWAP3 ADD PUSH1 0x20 ADD SWAP3 SWAP2 POP POP JUMP JUMPDEST PUSH1 0x20 DUP2 MSTORE PUSH1 0x0 PUSH2 0x799 PUSH1 0x20 DUP4 ADD DUP5 PUSH2 0x75A JUMP JUMPDEST SWAP4 SWAP3 POP POP POP JUMP JUMPDEST PUSH1 0x0 DUP1 PUSH1 0x0 DUP1 PUSH1 0x0 DUP1 PUSH1 0xC0 DUP8 DUP10 SUB SLT ISZERO PUSH2 0x7B9 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0x7C2 DUP8 PUSH2 0x534 JUMP JUMPDEST SWAP6 POP PUSH1 0x20 DUP8 ADD CALLDATALOAD SWAP5 POP PUSH1 0x40 DUP8 ADD CALLDATALOAD PUSH2 0x7D9 DUP2 PUSH2 0x550 JUMP JUMPDEST SWAP4 POP PUSH1 0x60 DUP8 ADD CALLDATALOAD SWAP3 POP PUSH2 0x7EE PUSH1 0x80 DUP9 ADD PUSH2 0x563 JUMP JUMPDEST SWAP2 POP PUSH1 0xA0 DUP8 ADD CALLDATALOAD PUSH8 0xFFFFFFFFFFFFFFFF DUP2 GT ISZERO PUSH2 0x80A JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0x816 DUP10 DUP3 DUP11 ADD PUSH2 0x6A3 JUMP JUMPDEST SWAP2 POP POP SWAP3 SWAP6 POP SWAP3 SWAP6 POP SWAP3 SWAP6 JUMP JUMPDEST PUSH1 0x20 DUP2 MSTORE PUSH1 0xFF DUP3 MLOAD AND PUSH1 0x20 DUP3 ADD MSTORE PUSH1 0x20 DUP3 ADD MLOAD PUSH1 0x40 DUP3 ADD MSTORE PUSH1 0x40 DUP3 ADD MLOAD PUSH1 0x60 DUP3 ADD MSTORE PUSH2 0xFFFF PUSH1 0x60 DUP4 ADD MLOAD AND PUSH1 0x80 DUP3 ADD MSTORE PUSH1 0x80 DUP3 ADD MLOAD PUSH1 0xA0 DUP3 ADD MSTORE PUSH1 0x0 PUSH1 0xA0 DUP4 ADD MLOAD PUSH2 0x874 PUSH1 0xC0 DUP5 ADD DUP3 PUSH2 0xFFFF AND SWAP1 MSTORE JUMP JUMPDEST POP PUSH1 0xC0 DUP4 ADD MLOAD PUSH1 0xE0 DUP4 ADD MSTORE PUSH1 0xE0 DUP4 ADD MLOAD PUSH2 0x100 DUP1 DUP2 DUP6 ADD MSTORE POP PUSH2 0x72E PUSH2 0x120 DUP5 ADD DUP3 PUSH2 0x75A JUMP JUMPDEST PUSH1 0x0 DUP1 PUSH1 0x40 DUP4 DUP6 SUB SLT ISZERO PUSH2 0x8AE JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0x8B7 DUP4 PUSH2 0x534 JUMP JUMPDEST SWAP5 PUSH1 0x20 SWAP4 SWAP1 SWAP4 ADD CALLDATALOAD SWAP4 POP POP POP JUMP JUMPDEST PUSH1 0x1 PUSH1 0x1 PUSH1 0xA0 SHL SUB DUP8 AND DUP2 MSTORE DUP6 PUSH1 0x20 DUP3 ADD MSTORE PUSH2 0xFFFF DUP6 AND PUSH1 0x40 DUP3 ADD MSTORE DUP4 PUSH1 0x60 DUP3 ADD MSTORE PUSH4 0xFFFFFFFF DUP4 AND PUSH1 0x80 DUP3 ADD MSTORE PUSH1 0xC0 PUSH1 0xA0 DUP3 ADD MSTORE PUSH1 0x0 PUSH2 0x909 PUSH1 0xC0 DUP4 ADD DUP5 PUSH2 0x75A JUMP JUMPDEST SWAP9 SWAP8 POP POP POP POP POP POP POP POP JUMP JUMPDEST DUP1 MLOAD PUSH1 0xFF DUP2 AND DUP2 EQ PUSH2 0x54B JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP1 MLOAD PUSH2 0x54B DUP2 PUSH2 0x550 JUMP JUMPDEST PUSH1 0x0 DUP3 PUSH1 0x1F DUP4 ADD SLT PUSH2 0x942 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP2 MLOAD PUSH2 0x950 PUSH2 0x6C2 DUP3 PUSH2 0x67B JUMP JUMPDEST DUP2 DUP2 MSTORE DUP5 PUSH1 0x20 DUP4 DUP7 ADD ADD GT ISZERO PUSH2 0x965 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0x72E DUP3 PUSH1 0x20 DUP4 ADD PUSH1 0x20 DUP8 ADD PUSH2 0x736 JUMP JUMPDEST PUSH1 0x0 PUSH1 0x20 DUP3 DUP5 SUB SLT ISZERO PUSH2 0x988 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP2 MLOAD PUSH8 0xFFFFFFFFFFFFFFFF DUP1 DUP3 GT ISZERO PUSH2 0x9A0 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST SWAP1 DUP4 ADD SWAP1 PUSH2 0x100 DUP3 DUP7 SUB SLT ISZERO PUSH2 0x9B5 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0x9BD PUSH2 0x620 JUMP JUMPDEST PUSH2 0x9C6 DUP4 PUSH2 0x915 JUMP JUMPDEST DUP2 MSTORE PUSH1 0x20 DUP4 ADD MLOAD PUSH1 0x20 DUP3 ADD MSTORE PUSH1 0x40 DUP4 ADD MLOAD PUSH1 0x40 DUP3 ADD MSTORE PUSH2 0x9E8 PUSH1 0x60 DUP5 ADD PUSH2 0x926 JUMP JUMPDEST PUSH1 0x60 DUP3 ADD MSTORE PUSH1 0x80 DUP4 ADD MLOAD PUSH1 0x80 DUP3 ADD MSTORE PUSH2 0xA03 PUSH1 0xA0 DUP5 ADD PUSH2 0x926 JUMP JUMPDEST PUSH1 0xA0 DUP3 ADD MSTORE PUSH1 0xC0 DUP4 ADD MLOAD PUSH1 0xC0 DUP3 ADD MSTORE PUSH1 0xE0 DUP4 ADD MLOAD DUP3 DUP2 GT ISZERO PUSH2 0xA24 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST PUSH2 0xA30 DUP8 DUP3 DUP7 ADD PUSH2 0x931 JUMP JUMPDEST PUSH1 0xE0 DUP4 ADD MSTORE POP SWAP6 SWAP5 POP POP POP POP POP JUMP INVALID LOG2 PUSH5 0x6970667358 0x22 SLT KECCAK256 SWAP2 RETURNDATASIZE 0xE8 0xD1 0xDB PUSH16 0xA583B976D45F865E25F5FD92A6626C1B 0xDD 0xCA PUSH23 0xAD1D23088EEE1764736F6C634300081100330000000000 ",
       "sourceMap": "344:3655:119:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2395:446;;;;;;:::i;:::-;;:::i;:::-;;;1282:18:125;1270:31;;;1252:50;;1240:2;1225:18;2395:446:119;;;;;;;;474:30;;;;;;;;;;;;;;;;;;;1459:25:125;;;1447:2;1432:18;474:30:119;1313:177:125;439:29:119;;;;;;;;;;;;;;;;3578:110;;;;;;;;;;-1:-1:-1;3578:110:119;;;;;:::i;:::-;3649:14;:32;3578:110;;;402:30;;;;;;;;;;-1:-1:-1;402:30:119;;;;-1:-1:-1;;;;;402:30:119;;;;;;-1:-1:-1;;;;;2045:55:125;;;2027:74;;2015:2;2000:18;402:30:119;1862:245:125;1185:1204:119;;;;;;;;;;-1:-1:-1;1185:1204:119;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;2847:467::-;;;;;;:::i;:::-;;:::i;3694:114::-;;;;;;;;;;-1:-1:-1;3694:114:119;;;;;:::i;:::-;3767:15;:34;3694:114;3320:252;;;;;;;;;;-1:-1:-1;3320:252:119;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;3886:111::-;;;;;;;;;;-1:-1:-1;3886:111:119;;;;;:::i;:::-;;:::i;2395:446::-;2638:176;;;-1:-1:-1;;;;;7053:55:125;;7035:74;;7140:2;7125:18;;7118:34;;;7200:6;7188:19;;7168:18;;;7161:47;7239:2;7224:18;;7217:34;;;7282:3;7267:19;;7260:35;;;7344:10;7332:23;;7326:3;7311:19;;7304:52;2638:176:119;;-1:-1:-1;;2638:176:119;;;;;;7022:3:125;2638:176:119;;;-1:-1:-1;2831:3:119;2395:446;;;;;;;;:::o;1185:1204::-;1280:12;1313:57;1360:9;1313:57;;;;;;:::i;:::-;;;;;;;;1380:13;;;1411:14;1380:46;;-1:-1:-1;;;1380:46:119;;1399:10;1380:46;;;7541:74:125;7631:18;;;7624:34;;;;-1:-1:-1;;;;;1380:13:119;;;;:18;;7514::125;;1380:46:119;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;1808:536:119;;;;;;;;1879:1;1808:536;;1911:1;1808:536;;;;;;;1940:66;1808:536;;;;2040:1;1808:536;;;;2073:66;1808:536;;;;2163:1;1808:536;;;;2193:66;1808:536;;;;2303:15;;2292:27;;;;;1459:25:125;;;;2292:27:119;;;;;;;;;1432:18:125;;;2292:27:119;;1808:536;;;;2362:20;;1808:536;;-1:-1:-1;2362:20:119;;-1:-1:-1;1808:536:119;;2362:20;;:::i;:::-;;;;;;;;;;;;;2355:27;;;1185:1204;;;:::o;2847:467::-;3071:15;3103:184;3161:5;3180:6;3200:14;3228:9;3251:5;3270:7;3103:184;;;;;;;;;;;:::i;:::-;;;;;;;;-1:-1:-1;3304:3:119;2847:467;;;;;;;;:::o;3320:252::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3502:63:119;;-1:-1:-1;;3502:63:119;;;;;;;;;;:::i;:::-;3495:70;3320:252;-1:-1:-1;;3320:252:119:o;3886:111::-;3960:13;;:30;;-1:-1:-1;;;3960:30:119;;-1:-1:-1;;;;;7559:55:125;;;3960:30:119;;;7541:74:125;7631:18;;;7624:34;;;3960:13:119;;;;:18;;7514::125;;3960:30:119;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3886:111;;:::o;14:196:125:-;82:20;;-1:-1:-1;;;;;131:54:125;;121:65;;111:93;;200:1;197;190:12;111:93;14:196;;;:::o;215:117::-;300:6;293:5;289:18;282:5;279:29;269:57;;322:1;319;312:12;269:57;215:117;:::o;337:163::-;404:20;;464:10;453:22;;443:33;;433:61;;490:1;487;480:12;505:598;607:6;615;623;631;639;647;700:3;688:9;679:7;675:23;671:33;668:53;;;717:1;714;707:12;668:53;740:29;759:9;740:29;:::i;:::-;730:39;;816:2;805:9;801:18;788:32;778:42;;870:2;859:9;855:18;842:32;883:30;907:5;883:30;:::i;:::-;932:5;-1:-1:-1;984:2:125;969:18;;956:32;;-1:-1:-1;1035:3:125;1020:19;;1007:33;;-1:-1:-1;1059:38:125;1092:3;1077:19;;1059:38;:::i;:::-;1049:48;;505:598;;;;;;;;:::o;1677:180::-;1736:6;1789:2;1777:9;1768:7;1764:23;1760:32;1757:52;;;1805:1;1802;1795:12;1757:52;-1:-1:-1;1828:23:125;;1677:180;-1:-1:-1;1677:180:125:o;2112:184::-;2164:77;2161:1;2154:88;2261:4;2258:1;2251:15;2285:4;2282:1;2275:15;2301:255;2373:2;2367:9;2415:6;2403:19;;2452:18;2437:34;;2473:22;;;2434:62;2431:88;;;2499:18;;:::i;:::-;2535:2;2528:22;2301:255;:::o;2561:275::-;2632:2;2626:9;2697:2;2678:13;;-1:-1:-1;;2674:27:125;2662:40;;2732:18;2717:34;;2753:22;;;2714:62;2711:88;;;2779:18;;:::i;:::-;2815:2;2808:22;2561:275;;-1:-1:-1;2561:275:125:o;2841:186::-;2889:4;2922:18;2914:6;2911:30;2908:56;;;2944:18;;:::i;:::-;-1:-1:-1;3010:2:125;2989:15;-1:-1:-1;;2985:29:125;3016:4;2981:40;;2841:186::o;3032:462::-;3074:5;3127:3;3120:4;3112:6;3108:17;3104:27;3094:55;;3145:1;3142;3135:12;3094:55;3181:6;3168:20;3212:48;3228:31;3256:2;3228:31;:::i;:::-;3212:48;:::i;:::-;3285:2;3276:7;3269:19;3331:3;3324:4;3319:2;3311:6;3307:15;3303:26;3300:35;3297:55;;;3348:1;3345;3338:12;3297:55;3413:2;3406:4;3398:6;3394:17;3387:4;3378:7;3374:18;3361:55;3461:1;3436:16;;;3454:4;3432:27;3425:38;;;;3440:7;3032:462;-1:-1:-1;;;3032:462:125:o;3499:320::-;3567:6;3620:2;3608:9;3599:7;3595:23;3591:32;3588:52;;;3636:1;3633;3626:12;3588:52;3676:9;3663:23;3709:18;3701:6;3698:30;3695:50;;;3741:1;3738;3731:12;3695:50;3764:49;3805:7;3796:6;3785:9;3781:22;3764:49;:::i;:::-;3754:59;3499:320;-1:-1:-1;;;;3499:320:125:o;3824:250::-;3909:1;3919:113;3933:6;3930:1;3927:13;3919:113;;;4009:11;;;4003:18;3990:11;;;3983:39;3955:2;3948:10;3919:113;;;-1:-1:-1;;4066:1:125;4048:16;;4041:27;3824:250::o;4079:270::-;4120:3;4158:5;4152:12;4185:6;4180:3;4173:19;4201:76;4270:6;4263:4;4258:3;4254:14;4247:4;4240:5;4236:16;4201:76;:::i;:::-;4331:2;4310:15;-1:-1:-1;;4306:29:125;4297:39;;;;4338:4;4293:50;;4079:270;-1:-1:-1;;4079:270:125:o;4354:217::-;4501:2;4490:9;4483:21;4464:4;4521:44;4561:2;4550:9;4546:18;4538:6;4521:44;:::i;:::-;4513:52;4354:217;-1:-1:-1;;;4354:217:125:o;4576:738::-;4687:6;4695;4703;4711;4719;4727;4780:3;4768:9;4759:7;4755:23;4751:33;4748:53;;;4797:1;4794;4787:12;4748:53;4820:29;4839:9;4820:29;:::i;:::-;4810:39;;4896:2;4885:9;4881:18;4868:32;4858:42;;4950:2;4939:9;4935:18;4922:32;4963:30;4987:5;4963:30;:::i;:::-;5012:5;-1:-1:-1;5064:2:125;5049:18;;5036:32;;-1:-1:-1;5087:38:125;5120:3;5105:19;;5087:38;:::i;:::-;5077:48;;5176:3;5165:9;5161:19;5148:33;5204:18;5196:6;5193:30;5190:50;;;5236:1;5233;5226:12;5190:50;5259:49;5300:7;5291:6;5280:9;5276:22;5259:49;:::i;:::-;5249:59;;;4576:738;;;;;;;;:::o;5599:889::-;5804:2;5793:9;5786:21;5862:4;5853:6;5847:13;5843:24;5838:2;5827:9;5823:18;5816:52;5922:2;5914:6;5910:15;5904:22;5899:2;5888:9;5884:18;5877:50;5981:2;5973:6;5969:15;5963:22;5958:2;5947:9;5943:18;5936:50;6051:6;6045:2;6037:6;6033:15;6027:22;6023:35;6017:3;6006:9;6002:19;5995:64;6114:3;6106:6;6102:16;6096:23;6090:3;6079:9;6075:19;6068:52;5767:4;6167:3;6159:6;6155:16;6149:23;6181:52;6228:3;6217:9;6213:19;6199:12;5580:6;5569:18;5557:31;;5504:90;6181:52;;6288:3;6280:6;6276:16;6270:23;6264:3;6253:9;6249:19;6242:52;6343:3;6335:6;6331:16;6325:23;6367:6;6409:2;6404;6393:9;6389:18;6382:30;;6429:53;6477:3;6466:9;6462:19;6446:14;6429:53;:::i;6493:254::-;6561:6;6569;6622:2;6610:9;6601:7;6597:23;6593:32;6590:52;;;6638:1;6635;6628:12;6590:52;6661:29;6680:9;6661:29;:::i;:::-;6651:39;6737:2;6722:18;;;;6709:32;;-1:-1:-1;;;6493:254:125:o;7669:651::-;-1:-1:-1;;;;;7956:6:125;7952:55;7941:9;7934:74;8044:6;8039:2;8028:9;8024:18;8017:34;8099:6;8091;8087:19;8082:2;8071:9;8067:18;8060:47;8143:6;8138:2;8127:9;8123:18;8116:34;8199:10;8191:6;8187:23;8181:3;8170:9;8166:19;8159:52;8248:3;8242;8231:9;8227:19;8220:32;7915:4;8269:45;8309:3;8298:9;8294:19;8286:6;8269:45;:::i;:::-;8261:53;7669:651;-1:-1:-1;;;;;;;;7669:651:125:o;8325:160::-;8402:13;;8455:4;8444:16;;8434:27;;8424:55;;8475:1;8472;8465:12;8490:136;8568:13;;8590:30;8568:13;8590:30;:::i;8631:441::-;8684:5;8737:3;8730:4;8722:6;8718:17;8714:27;8704:55;;8755:1;8752;8745:12;8704:55;8784:6;8778:13;8815:48;8831:31;8859:2;8831:31;:::i;8815:48::-;8888:2;8879:7;8872:19;8934:3;8927:4;8922:2;8914:6;8910:15;8906:26;8903:35;8900:55;;;8951:1;8948;8941:12;8900:55;8964:77;9038:2;9031:4;9022:7;9018:18;9011:4;9003:6;8999:17;8964:77;:::i;9077:1064::-;9185:6;9238:2;9226:9;9217:7;9213:23;9209:32;9206:52;;;9254:1;9251;9244:12;9206:52;9287:9;9281:16;9316:18;9357:2;9349:6;9346:14;9343:34;;;9373:1;9370;9363:12;9343:34;9396:22;;;;9452:6;9434:16;;;9430:29;9427:49;;;9472:1;9469;9462:12;9427:49;9498:22;;:::i;:::-;9543:31;9571:2;9543:31;:::i;:::-;9536:5;9529:46;9621:2;9617;9613:11;9607:18;9602:2;9595:5;9591:14;9584:42;9672:2;9668;9664:11;9658:18;9653:2;9646:5;9642:14;9635:42;9709:41;9746:2;9742;9738:11;9709:41;:::i;:::-;9704:2;9697:5;9693:14;9686:65;9798:3;9794:2;9790:12;9784:19;9778:3;9771:5;9767:15;9760:44;9837:42;9874:3;9870:2;9866:12;9837:42;:::i;:::-;9831:3;9824:5;9820:15;9813:67;9927:3;9923:2;9919:12;9913:19;9907:3;9900:5;9896:15;9889:44;9972:3;9968:2;9964:12;9958:19;10002:2;9992:8;9989:16;9986:36;;;10018:1;10015;10008:12;9986:36;10055:55;10102:7;10091:8;10087:2;10083:17;10055:55;:::i;:::-;10049:3;10038:15;;10031:80;-1:-1:-1;10042:5:125;9077:1064;-1:-1:-1;;;;;9077:1064:125:o"
     },
     "gasEstimates": {
@@ -8611,19 +8611,19 @@
       "wormholeToken()": "9542c9f1"
     }
   },
-  "metadata": "{\"compiler\":{\"version\":\"0.8.17+commit.8df45f5f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"contract TestERC20\",\"name\":\"_wormholeToken\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"encodedVm\",\"type\":\"bytes\"}],\"name\":\"WormholeBridgeStub_completeTransferWithPayload\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint16\",\"name\":\"recipientChain\",\"type\":\"uint16\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"recipient\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"arbiterFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"nonce\",\"type\":\"uint32\"}],\"name\":\"WormholeBridgeStub_transferTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint16\",\"name\":\"recipientChain\",\"type\":\"uint16\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"recipient\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"nonce\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"WormholeBridgeStub_transferTokensWithPayload\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"encodedVm\",\"type\":\"bytes\"}],\"name\":\"completeTransferWithPayload\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"mintWormholeToken\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"encoded\",\"type\":\"bytes\"}],\"name\":\"parseTransferWithPayload\",\"outputs\":[{\"components\":[{\"internalType\":\"uint8\",\"name\":\"payloadID\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"tokenAddress\",\"type\":\"bytes32\"},{\"internalType\":\"uint16\",\"name\":\"tokenChain\",\"type\":\"uint16\"},{\"internalType\":\"bytes32\",\"name\":\"to\",\"type\":\"bytes32\"},{\"internalType\":\"uint16\",\"name\":\"toChain\",\"type\":\"uint16\"},{\"internalType\":\"bytes32\",\"name\":\"fromAddress\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"internalType\":\"struct IWormholeTokenBridge.TransferWithPayload\",\"name\":\"transfer\",\"type\":\"tuple\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"receiverAddress\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"_receiverAddress\",\"type\":\"bytes32\"}],\"name\":\"setReceiverAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_transferAmount\",\"type\":\"uint256\"}],\"name\":\"setTransferAmount\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"transferAmount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint16\",\"name\":\"recipientChain\",\"type\":\"uint16\"},{\"internalType\":\"bytes32\",\"name\":\"recipient\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"arbiterFee\",\"type\":\"uint256\"},{\"internalType\":\"uint32\",\"name\":\"nonce\",\"type\":\"uint32\"}],\"name\":\"transferTokens\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"sequence\",\"type\":\"uint64\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint16\",\"name\":\"recipientChain\",\"type\":\"uint16\"},{\"internalType\":\"bytes32\",\"name\":\"recipient\",\"type\":\"bytes32\"},{\"internalType\":\"uint32\",\"name\":\"nonce\",\"type\":\"uint32\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"transferTokensWithPayload\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"sequence\",\"type\":\"uint64\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"wormholeToken\",\"outputs\":[{\"internalType\":\"contract TestERC20\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"Stub contract used in L2WormholeGateway unit tests.      Stub contract is used instead of a smock because of the token transfer      that needs to happen in completeTransferWithPayload function.\",\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/test/WormholeBridgeStub.sol\":\"WormholeBridgeStub\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\\n    address private _owner;\\n\\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n    /**\\n     * @dev Initializes the contract setting the deployer as the initial owner.\\n     */\\n    function __Ownable_init() internal onlyInitializing {\\n        __Ownable_init_unchained();\\n    }\\n\\n    function __Ownable_init_unchained() internal onlyInitializing {\\n        _transferOwnership(_msgSender());\\n    }\\n\\n    /**\\n     * @dev Throws if called by any account other than the owner.\\n     */\\n    modifier onlyOwner() {\\n        _checkOwner();\\n        _;\\n    }\\n\\n    /**\\n     * @dev Returns the address of the current owner.\\n     */\\n    function owner() public view virtual returns (address) {\\n        return _owner;\\n    }\\n\\n    /**\\n     * @dev Throws if the sender is not the owner.\\n     */\\n    function _checkOwner() internal view virtual {\\n        require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n    }\\n\\n    /**\\n     * @dev Leaves the contract without owner. It will not be possible to call\\n     * `onlyOwner` functions anymore. Can only be called by the current owner.\\n     *\\n     * NOTE: Renouncing ownership will leave the contract without an owner,\\n     * thereby removing any functionality that is only available to the owner.\\n     */\\n    function renounceOwnership() public virtual onlyOwner {\\n        _transferOwnership(address(0));\\n    }\\n\\n    /**\\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n     * Can only be called by the current owner.\\n     */\\n    function transferOwnership(address newOwner) public virtual onlyOwner {\\n        require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n        _transferOwnership(newOwner);\\n    }\\n\\n    /**\\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n     * Internal function without access restriction.\\n     */\\n    function _transferOwnership(address newOwner) internal virtual {\\n        address oldOwner = _owner;\\n        _owner = newOwner;\\n        emit OwnershipTransferred(oldOwner, newOwner);\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x247c62047745915c0af6b955470a72d1696ebad4352d7d3011aef1a2463cd888\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.1) (proxy/utils/Initializable.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\\n * reused. This mechanism prevents re-execution of each \\\"step\\\" but allows the creation of new initialization steps in\\n * case an upgrade adds a module that needs to be initialized.\\n *\\n * For example:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * contract MyToken is ERC20Upgradeable {\\n *     function initialize() initializer public {\\n *         __ERC20_init(\\\"MyToken\\\", \\\"MTK\\\");\\n *     }\\n * }\\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\\n *     function initializeV2() reinitializer(2) public {\\n *         __ERC20Permit_init(\\\"MyToken\\\");\\n *     }\\n * }\\n * ```\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n *\\n * [CAUTION]\\n * ====\\n * Avoid leaving a contract uninitialized.\\n *\\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * /// @custom:oz-upgrades-unsafe-allow constructor\\n * constructor() {\\n *     _disableInitializers();\\n * }\\n * ```\\n * ====\\n */\\nabstract contract Initializable {\\n    /**\\n     * @dev Indicates that the contract has been initialized.\\n     * @custom:oz-retyped-from bool\\n     */\\n    uint8 private _initialized;\\n\\n    /**\\n     * @dev Indicates that the contract is in the process of being initialized.\\n     */\\n    bool private _initializing;\\n\\n    /**\\n     * @dev Triggered when the contract has been initialized or reinitialized.\\n     */\\n    event Initialized(uint8 version);\\n\\n    /**\\n     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\\n     * `onlyInitializing` functions can be used to initialize parent contracts.\\n     *\\n     * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a\\n     * constructor.\\n     *\\n     * Emits an {Initialized} event.\\n     */\\n    modifier initializer() {\\n        bool isTopLevelCall = !_initializing;\\n        require(\\n            (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\\n            \\\"Initializable: contract is already initialized\\\"\\n        );\\n        _initialized = 1;\\n        if (isTopLevelCall) {\\n            _initializing = true;\\n        }\\n        _;\\n        if (isTopLevelCall) {\\n            _initializing = false;\\n            emit Initialized(1);\\n        }\\n    }\\n\\n    /**\\n     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\\n     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\\n     * used to initialize parent contracts.\\n     *\\n     * A reinitializer may be used after the original initialization step. This is essential to configure modules that\\n     * are added through upgrades and that require initialization.\\n     *\\n     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\\n     * cannot be nested. If one is invoked in the context of another, execution will revert.\\n     *\\n     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\\n     * a contract, executing them in the right order is up to the developer or operator.\\n     *\\n     * WARNING: setting the version to 255 will prevent any future reinitialization.\\n     *\\n     * Emits an {Initialized} event.\\n     */\\n    modifier reinitializer(uint8 version) {\\n        require(!_initializing && _initialized < version, \\\"Initializable: contract is already initialized\\\");\\n        _initialized = version;\\n        _initializing = true;\\n        _;\\n        _initializing = false;\\n        emit Initialized(version);\\n    }\\n\\n    /**\\n     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\\n     * {initializer} and {reinitializer} modifiers, directly or indirectly.\\n     */\\n    modifier onlyInitializing() {\\n        require(_initializing, \\\"Initializable: contract is not initializing\\\");\\n        _;\\n    }\\n\\n    /**\\n     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\\n     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\\n     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\\n     * through proxies.\\n     *\\n     * Emits an {Initialized} event the first time it is successfully executed.\\n     */\\n    function _disableInitializers() internal virtual {\\n        require(!_initializing, \\\"Initializable: contract is initializing\\\");\\n        if (_initialized < type(uint8).max) {\\n            _initialized = type(uint8).max;\\n            emit Initialized(type(uint8).max);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the highest version that has been initialized. See {reinitializer}.\\n     */\\n    function _getInitializedVersion() internal view returns (uint8) {\\n        return _initialized;\\n    }\\n\\n    /**\\n     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\\n     */\\n    function _isInitializing() internal view returns (bool) {\\n        return _initializing;\\n    }\\n}\\n\",\"keccak256\":\"0x037c334add4b033ad3493038c25be1682d78c00992e1acb0e2795caff3925271\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which allows children to implement an emergency stop\\n * mechanism that can be triggered by an authorized account.\\n *\\n * This module is used through inheritance. It will make available the\\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\\n * the functions of your contract. Note that they will not be pausable by\\n * simply including this module, only once the modifiers are put in place.\\n */\\nabstract contract PausableUpgradeable is Initializable, ContextUpgradeable {\\n    /**\\n     * @dev Emitted when the pause is triggered by `account`.\\n     */\\n    event Paused(address account);\\n\\n    /**\\n     * @dev Emitted when the pause is lifted by `account`.\\n     */\\n    event Unpaused(address account);\\n\\n    bool private _paused;\\n\\n    /**\\n     * @dev Initializes the contract in unpaused state.\\n     */\\n    function __Pausable_init() internal onlyInitializing {\\n        __Pausable_init_unchained();\\n    }\\n\\n    function __Pausable_init_unchained() internal onlyInitializing {\\n        _paused = false;\\n    }\\n\\n    /**\\n     * @dev Modifier to make a function callable only when the contract is not paused.\\n     *\\n     * Requirements:\\n     *\\n     * - The contract must not be paused.\\n     */\\n    modifier whenNotPaused() {\\n        _requireNotPaused();\\n        _;\\n    }\\n\\n    /**\\n     * @dev Modifier to make a function callable only when the contract is paused.\\n     *\\n     * Requirements:\\n     *\\n     * - The contract must be paused.\\n     */\\n    modifier whenPaused() {\\n        _requirePaused();\\n        _;\\n    }\\n\\n    /**\\n     * @dev Returns true if the contract is paused, and false otherwise.\\n     */\\n    function paused() public view virtual returns (bool) {\\n        return _paused;\\n    }\\n\\n    /**\\n     * @dev Throws if the contract is paused.\\n     */\\n    function _requireNotPaused() internal view virtual {\\n        require(!paused(), \\\"Pausable: paused\\\");\\n    }\\n\\n    /**\\n     * @dev Throws if the contract is not paused.\\n     */\\n    function _requirePaused() internal view virtual {\\n        require(paused(), \\\"Pausable: not paused\\\");\\n    }\\n\\n    /**\\n     * @dev Triggers stopped state.\\n     *\\n     * Requirements:\\n     *\\n     * - The contract must not be paused.\\n     */\\n    function _pause() internal virtual whenNotPaused {\\n        _paused = true;\\n        emit Paused(_msgSender());\\n    }\\n\\n    /**\\n     * @dev Returns to normal state.\\n     *\\n     * Requirements:\\n     *\\n     * - The contract must be paused.\\n     */\\n    function _unpause() internal virtual whenPaused {\\n        _paused = false;\\n        emit Unpaused(_msgSender());\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x40c636b4572ff5f1dc50cf22097e93c0723ee14eff87e99ac2b02636eeca1250\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol)\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ReentrancyGuardUpgradeable is Initializable {\\n    // Booleans are more expensive than uint256 or any type that takes up a full\\n    // word because each write operation emits an extra SLOAD to first read the\\n    // slot's contents, replace the bits taken up by the boolean, and then write\\n    // back. This is the compiler's defense against contract upgrades and\\n    // pointer aliasing, and it cannot be disabled.\\n\\n    // The values being non-zero value makes deployment a bit more expensive,\\n    // but in exchange the refund on every call to nonReentrant will be lower in\\n    // amount. Since refunds are capped to a percentage of the total\\n    // transaction's gas, it is best to keep them low in cases like this one, to\\n    // increase the likelihood of the full refund coming into effect.\\n    uint256 private constant _NOT_ENTERED = 1;\\n    uint256 private constant _ENTERED = 2;\\n\\n    uint256 private _status;\\n\\n    function __ReentrancyGuard_init() internal onlyInitializing {\\n        __ReentrancyGuard_init_unchained();\\n    }\\n\\n    function __ReentrancyGuard_init_unchained() internal onlyInitializing {\\n        _status = _NOT_ENTERED;\\n    }\\n\\n    /**\\n     * @dev Prevents a contract from calling itself, directly or indirectly.\\n     * Calling a `nonReentrant` function from another `nonReentrant`\\n     * function is not supported. It is possible to prevent this from happening\\n     * by making the `nonReentrant` function external, and making it call a\\n     * `private` function that does the actual work.\\n     */\\n    modifier nonReentrant() {\\n        _nonReentrantBefore();\\n        _;\\n        _nonReentrantAfter();\\n    }\\n\\n    function _nonReentrantBefore() private {\\n        // On the first call to nonReentrant, _status will be _NOT_ENTERED\\n        require(_status != _ENTERED, \\\"ReentrancyGuard: reentrant call\\\");\\n\\n        // Any calls to nonReentrant after this point will fail\\n        _status = _ENTERED;\\n    }\\n\\n    function _nonReentrantAfter() private {\\n        // By storing the original value once again, a refund is triggered (see\\n        // https://eips.ethereum.org/EIPS/eip-2200)\\n        _status = _NOT_ENTERED;\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x2b3005a0064cfc558bdf64b2bae94b565f4574a536aadd61c13838d4f2157790\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/ERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\\n * instead returning `false` on failure. This behavior is nonetheless\\n * conventional and does not conflict with the expectations of ERC20\\n * applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n    mapping(address => uint256) private _balances;\\n\\n    mapping(address => mapping(address => uint256)) private _allowances;\\n\\n    uint256 private _totalSupply;\\n\\n    string private _name;\\n    string private _symbol;\\n\\n    /**\\n     * @dev Sets the values for {name} and {symbol}.\\n     *\\n     * The default value of {decimals} is 18. To select a different value for\\n     * {decimals} you should overload it.\\n     *\\n     * All two of these values are immutable: they can only be set once during\\n     * construction.\\n     */\\n    function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {\\n        __ERC20_init_unchained(name_, symbol_);\\n    }\\n\\n    function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {\\n        _name = name_;\\n        _symbol = symbol_;\\n    }\\n\\n    /**\\n     * @dev Returns the name of the token.\\n     */\\n    function name() public view virtual override returns (string memory) {\\n        return _name;\\n    }\\n\\n    /**\\n     * @dev Returns the symbol of the token, usually a shorter version of the\\n     * name.\\n     */\\n    function symbol() public view virtual override returns (string memory) {\\n        return _symbol;\\n    }\\n\\n    /**\\n     * @dev Returns the number of decimals used to get its user representation.\\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n     * be displayed to a user as `5.05` (`505 / 10 ** 2`).\\n     *\\n     * Tokens usually opt for a value of 18, imitating the relationship between\\n     * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n     * overridden;\\n     *\\n     * NOTE: This information is only used for _display_ purposes: it in\\n     * no way affects any of the arithmetic of the contract, including\\n     * {IERC20-balanceOf} and {IERC20-transfer}.\\n     */\\n    function decimals() public view virtual override returns (uint8) {\\n        return 18;\\n    }\\n\\n    /**\\n     * @dev See {IERC20-totalSupply}.\\n     */\\n    function totalSupply() public view virtual override returns (uint256) {\\n        return _totalSupply;\\n    }\\n\\n    /**\\n     * @dev See {IERC20-balanceOf}.\\n     */\\n    function balanceOf(address account) public view virtual override returns (uint256) {\\n        return _balances[account];\\n    }\\n\\n    /**\\n     * @dev See {IERC20-transfer}.\\n     *\\n     * Requirements:\\n     *\\n     * - `to` cannot be the zero address.\\n     * - the caller must have a balance of at least `amount`.\\n     */\\n    function transfer(address to, uint256 amount) public virtual override returns (bool) {\\n        address owner = _msgSender();\\n        _transfer(owner, to, amount);\\n        return true;\\n    }\\n\\n    /**\\n     * @dev See {IERC20-allowance}.\\n     */\\n    function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n        return _allowances[owner][spender];\\n    }\\n\\n    /**\\n     * @dev See {IERC20-approve}.\\n     *\\n     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\\n     * `transferFrom`. This is semantically equivalent to an infinite approval.\\n     *\\n     * Requirements:\\n     *\\n     * - `spender` cannot be the zero address.\\n     */\\n    function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n        address owner = _msgSender();\\n        _approve(owner, spender, amount);\\n        return true;\\n    }\\n\\n    /**\\n     * @dev See {IERC20-transferFrom}.\\n     *\\n     * Emits an {Approval} event indicating the updated allowance. This is not\\n     * required by the EIP. See the note at the beginning of {ERC20}.\\n     *\\n     * NOTE: Does not update the allowance if the current allowance\\n     * is the maximum `uint256`.\\n     *\\n     * Requirements:\\n     *\\n     * - `from` and `to` cannot be the zero address.\\n     * - `from` must have a balance of at least `amount`.\\n     * - the caller must have allowance for ``from``'s tokens of at least\\n     * `amount`.\\n     */\\n    function transferFrom(\\n        address from,\\n        address to,\\n        uint256 amount\\n    ) public virtual override returns (bool) {\\n        address spender = _msgSender();\\n        _spendAllowance(from, spender, amount);\\n        _transfer(from, to, amount);\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Atomically increases the allowance granted to `spender` by the caller.\\n     *\\n     * This is an alternative to {approve} that can be used as a mitigation for\\n     * problems described in {IERC20-approve}.\\n     *\\n     * Emits an {Approval} event indicating the updated allowance.\\n     *\\n     * Requirements:\\n     *\\n     * - `spender` cannot be the zero address.\\n     */\\n    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n        address owner = _msgSender();\\n        _approve(owner, spender, allowance(owner, spender) + addedValue);\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n     *\\n     * This is an alternative to {approve} that can be used as a mitigation for\\n     * problems described in {IERC20-approve}.\\n     *\\n     * Emits an {Approval} event indicating the updated allowance.\\n     *\\n     * Requirements:\\n     *\\n     * - `spender` cannot be the zero address.\\n     * - `spender` must have allowance for the caller of at least\\n     * `subtractedValue`.\\n     */\\n    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n        address owner = _msgSender();\\n        uint256 currentAllowance = allowance(owner, spender);\\n        require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n        unchecked {\\n            _approve(owner, spender, currentAllowance - subtractedValue);\\n        }\\n\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Moves `amount` of tokens from `from` to `to`.\\n     *\\n     * This internal function is equivalent to {transfer}, and can be used to\\n     * e.g. implement automatic token fees, slashing mechanisms, etc.\\n     *\\n     * Emits a {Transfer} event.\\n     *\\n     * Requirements:\\n     *\\n     * - `from` cannot be the zero address.\\n     * - `to` cannot be the zero address.\\n     * - `from` must have a balance of at least `amount`.\\n     */\\n    function _transfer(\\n        address from,\\n        address to,\\n        uint256 amount\\n    ) internal virtual {\\n        require(from != address(0), \\\"ERC20: transfer from the zero address\\\");\\n        require(to != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n        _beforeTokenTransfer(from, to, amount);\\n\\n        uint256 fromBalance = _balances[from];\\n        require(fromBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n        unchecked {\\n            _balances[from] = fromBalance - amount;\\n            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\\n            // decrementing then incrementing.\\n            _balances[to] += amount;\\n        }\\n\\n        emit Transfer(from, to, amount);\\n\\n        _afterTokenTransfer(from, to, amount);\\n    }\\n\\n    /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n     * the total supply.\\n     *\\n     * Emits a {Transfer} event with `from` set to the zero address.\\n     *\\n     * Requirements:\\n     *\\n     * - `account` cannot be the zero address.\\n     */\\n    function _mint(address account, uint256 amount) internal virtual {\\n        require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n        _beforeTokenTransfer(address(0), account, amount);\\n\\n        _totalSupply += amount;\\n        unchecked {\\n            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\\n            _balances[account] += amount;\\n        }\\n        emit Transfer(address(0), account, amount);\\n\\n        _afterTokenTransfer(address(0), account, amount);\\n    }\\n\\n    /**\\n     * @dev Destroys `amount` tokens from `account`, reducing the\\n     * total supply.\\n     *\\n     * Emits a {Transfer} event with `to` set to the zero address.\\n     *\\n     * Requirements:\\n     *\\n     * - `account` cannot be the zero address.\\n     * - `account` must have at least `amount` tokens.\\n     */\\n    function _burn(address account, uint256 amount) internal virtual {\\n        require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n        _beforeTokenTransfer(account, address(0), amount);\\n\\n        uint256 accountBalance = _balances[account];\\n        require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n        unchecked {\\n            _balances[account] = accountBalance - amount;\\n            // Overflow not possible: amount <= accountBalance <= totalSupply.\\n            _totalSupply -= amount;\\n        }\\n\\n        emit Transfer(account, address(0), amount);\\n\\n        _afterTokenTransfer(account, address(0), amount);\\n    }\\n\\n    /**\\n     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n     *\\n     * This internal function is equivalent to `approve`, and can be used to\\n     * e.g. set automatic allowances for certain subsystems, etc.\\n     *\\n     * Emits an {Approval} event.\\n     *\\n     * Requirements:\\n     *\\n     * - `owner` cannot be the zero address.\\n     * - `spender` cannot be the zero address.\\n     */\\n    function _approve(\\n        address owner,\\n        address spender,\\n        uint256 amount\\n    ) internal virtual {\\n        require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n        require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n        _allowances[owner][spender] = amount;\\n        emit Approval(owner, spender, amount);\\n    }\\n\\n    /**\\n     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.\\n     *\\n     * Does not update the allowance amount in case of infinite allowance.\\n     * Revert if not enough allowance is available.\\n     *\\n     * Might emit an {Approval} event.\\n     */\\n    function _spendAllowance(\\n        address owner,\\n        address spender,\\n        uint256 amount\\n    ) internal virtual {\\n        uint256 currentAllowance = allowance(owner, spender);\\n        if (currentAllowance != type(uint256).max) {\\n            require(currentAllowance >= amount, \\\"ERC20: insufficient allowance\\\");\\n            unchecked {\\n                _approve(owner, spender, currentAllowance - amount);\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Hook that is called before any transfer of tokens. This includes\\n     * minting and burning.\\n     *\\n     * Calling conditions:\\n     *\\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n     * will be transferred to `to`.\\n     * - when `from` is zero, `amount` tokens will be minted for `to`.\\n     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n     * - `from` and `to` are never both zero.\\n     *\\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n     */\\n    function _beforeTokenTransfer(\\n        address from,\\n        address to,\\n        uint256 amount\\n    ) internal virtual {}\\n\\n    /**\\n     * @dev Hook that is called after any transfer of tokens. This includes\\n     * minting and burning.\\n     *\\n     * Calling conditions:\\n     *\\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n     * has been transferred to `to`.\\n     * - when `from` is zero, `amount` tokens have been minted for `to`.\\n     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\\n     * - `from` and `to` are never both zero.\\n     *\\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n     */\\n    function _afterTokenTransfer(\\n        address from,\\n        address to,\\n        uint256 amount\\n    ) internal virtual {}\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0xb1d9e69cf8073efa574b31b1f840e20709139c19bfb27e60b16393d6073f3d42\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the amount of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the amount of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves `amount` tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 amount) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 amount) external returns (bool);\\n\\n    /**\\n     * @dev Moves `amount` tokens from `from` to `to` using the\\n     * allowance mechanism. `amount` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(\\n        address from,\\n        address to,\\n        uint256 amount\\n    ) external returns (bool);\\n}\\n\",\"keccak256\":\"0x4e733d3164f73f461eaf9d8087a7ad1ea180bdc8ba0d3d61b0e1ae16d8e63dff\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20BurnableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Burnable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../ERC20Upgradeable.sol\\\";\\nimport \\\"../../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Extension of {ERC20} that allows token holders to destroy both their own\\n * tokens and those that they have an allowance for, in a way that can be\\n * recognized off-chain (via event analysis).\\n */\\nabstract contract ERC20BurnableUpgradeable is Initializable, ContextUpgradeable, ERC20Upgradeable {\\n    function __ERC20Burnable_init() internal onlyInitializing {\\n    }\\n\\n    function __ERC20Burnable_init_unchained() internal onlyInitializing {\\n    }\\n    /**\\n     * @dev Destroys `amount` tokens from the caller.\\n     *\\n     * See {ERC20-_burn}.\\n     */\\n    function burn(uint256 amount) public virtual {\\n        _burn(_msgSender(), amount);\\n    }\\n\\n    /**\\n     * @dev Destroys `amount` tokens from `account`, deducting from the caller's\\n     * allowance.\\n     *\\n     * See {ERC20-_burn} and {ERC20-allowance}.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must have allowance for ``accounts``'s tokens of at least\\n     * `amount`.\\n     */\\n    function burnFrom(address account, uint256 amount) public virtual {\\n        _spendAllowance(account, _msgSender(), amount);\\n        _burn(account, amount);\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0xea2c6f9d434127bf36b1e3e5ebaaf6d28a64dbaeea560508e570014e905a5ad2\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\n    /**\\n     * @dev Returns the name of the token.\\n     */\\n    function name() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the symbol of the token.\\n     */\\n    function symbol() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the decimals places of the token.\\n     */\\n    function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x605434219ebbe4653f703640f06969faa5a1d78f0bfef878e5ddbb1ca369ceeb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/draft-ERC20PermitUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/extensions/draft-ERC20Permit.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./draft-IERC20PermitUpgradeable.sol\\\";\\nimport \\\"../ERC20Upgradeable.sol\\\";\\nimport \\\"../../../utils/cryptography/ECDSAUpgradeable.sol\\\";\\nimport \\\"../../../utils/cryptography/EIP712Upgradeable.sol\\\";\\nimport \\\"../../../utils/CountersUpgradeable.sol\\\";\\nimport \\\"../../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't\\n * need to send a transaction, and thus is not required to hold Ether at all.\\n *\\n * _Available since v3.4._\\n *\\n * @custom:storage-size 51\\n */\\nabstract contract ERC20PermitUpgradeable is Initializable, ERC20Upgradeable, IERC20PermitUpgradeable, EIP712Upgradeable {\\n    using CountersUpgradeable for CountersUpgradeable.Counter;\\n\\n    mapping(address => CountersUpgradeable.Counter) private _nonces;\\n\\n    // solhint-disable-next-line var-name-mixedcase\\n    bytes32 private constant _PERMIT_TYPEHASH =\\n        keccak256(\\\"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\\\");\\n    /**\\n     * @dev In previous versions `_PERMIT_TYPEHASH` was declared as `immutable`.\\n     * However, to ensure consistency with the upgradeable transpiler, we will continue\\n     * to reserve a slot.\\n     * @custom:oz-renamed-from _PERMIT_TYPEHASH\\n     */\\n    // solhint-disable-next-line var-name-mixedcase\\n    bytes32 private _PERMIT_TYPEHASH_DEPRECATED_SLOT;\\n\\n    /**\\n     * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `\\\"1\\\"`.\\n     *\\n     * It's a good idea to use the same `name` that is defined as the ERC20 token name.\\n     */\\n    function __ERC20Permit_init(string memory name) internal onlyInitializing {\\n        __EIP712_init_unchained(name, \\\"1\\\");\\n    }\\n\\n    function __ERC20Permit_init_unchained(string memory) internal onlyInitializing {}\\n\\n    /**\\n     * @dev See {IERC20Permit-permit}.\\n     */\\n    function permit(\\n        address owner,\\n        address spender,\\n        uint256 value,\\n        uint256 deadline,\\n        uint8 v,\\n        bytes32 r,\\n        bytes32 s\\n    ) public virtual override {\\n        require(block.timestamp <= deadline, \\\"ERC20Permit: expired deadline\\\");\\n\\n        bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));\\n\\n        bytes32 hash = _hashTypedDataV4(structHash);\\n\\n        address signer = ECDSAUpgradeable.recover(hash, v, r, s);\\n        require(signer == owner, \\\"ERC20Permit: invalid signature\\\");\\n\\n        _approve(owner, spender, value);\\n    }\\n\\n    /**\\n     * @dev See {IERC20Permit-nonces}.\\n     */\\n    function nonces(address owner) public view virtual override returns (uint256) {\\n        return _nonces[owner].current();\\n    }\\n\\n    /**\\n     * @dev See {IERC20Permit-DOMAIN_SEPARATOR}.\\n     */\\n    // solhint-disable-next-line func-name-mixedcase\\n    function DOMAIN_SEPARATOR() external view override returns (bytes32) {\\n        return _domainSeparatorV4();\\n    }\\n\\n    /**\\n     * @dev \\\"Consume a nonce\\\": return the current value and increment.\\n     *\\n     * _Available since v4.1._\\n     */\\n    function _useNonce(address owner) internal virtual returns (uint256 current) {\\n        CountersUpgradeable.Counter storage nonce = _nonces[owner];\\n        current = nonce.current();\\n        nonce.increment();\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0xfe1053f3a6ee4527cde96c8152b8b1dbb98774639a64e819087bc80e618d7f7f\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/draft-IERC20PermitUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\\n * need to send a transaction, and thus is not required to hold Ether at all.\\n */\\ninterface IERC20PermitUpgradeable {\\n    /**\\n     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\\n     * given ``owner``'s signed approval.\\n     *\\n     * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n     * ordering also apply here.\\n     *\\n     * Emits an {Approval} event.\\n     *\\n     * Requirements:\\n     *\\n     * - `spender` cannot be the zero address.\\n     * - `deadline` must be a timestamp in the future.\\n     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n     * over the EIP712-formatted function arguments.\\n     * - the signature must use ``owner``'s current nonce (see {nonces}).\\n     *\\n     * For more information on the signature format, see the\\n     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n     * section].\\n     */\\n    function permit(\\n        address owner,\\n        address spender,\\n        uint256 value,\\n        uint256 deadline,\\n        uint8 v,\\n        bytes32 r,\\n        bytes32 s\\n    ) external;\\n\\n    /**\\n     * @dev Returns the current nonce for `owner`. This value must be\\n     * included whenever a signature is generated for {permit}.\\n     *\\n     * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n     * prevents a signature from being used multiple times.\\n     */\\n    function nonces(address owner) external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\\n     */\\n    // solhint-disable-next-line func-name-mixedcase\\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0xcc70d8e2281fb3ff69e8ab242500f10142cd0a7fa8dd9e45882be270d4d09024\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\nimport \\\"../extensions/draft-IERC20PermitUpgradeable.sol\\\";\\nimport \\\"../../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20Upgradeable {\\n    using AddressUpgradeable for address;\\n\\n    function safeTransfer(\\n        IERC20Upgradeable token,\\n        address to,\\n        uint256 value\\n    ) internal {\\n        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n    }\\n\\n    function safeTransferFrom(\\n        IERC20Upgradeable token,\\n        address from,\\n        address to,\\n        uint256 value\\n    ) internal {\\n        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n    }\\n\\n    /**\\n     * @dev Deprecated. This function has issues similar to the ones found in\\n     * {IERC20-approve}, and its usage is discouraged.\\n     *\\n     * Whenever possible, use {safeIncreaseAllowance} and\\n     * {safeDecreaseAllowance} instead.\\n     */\\n    function safeApprove(\\n        IERC20Upgradeable token,\\n        address spender,\\n        uint256 value\\n    ) internal {\\n        // safeApprove should only be called when setting an initial allowance,\\n        // or when resetting it to zero. To increase and decrease it, use\\n        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n        require(\\n            (value == 0) || (token.allowance(address(this), spender) == 0),\\n            \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n        );\\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n    }\\n\\n    function safeIncreaseAllowance(\\n        IERC20Upgradeable token,\\n        address spender,\\n        uint256 value\\n    ) internal {\\n        uint256 newAllowance = token.allowance(address(this), spender) + value;\\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n    }\\n\\n    function safeDecreaseAllowance(\\n        IERC20Upgradeable token,\\n        address spender,\\n        uint256 value\\n    ) internal {\\n        unchecked {\\n            uint256 oldAllowance = token.allowance(address(this), spender);\\n            require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n            uint256 newAllowance = oldAllowance - value;\\n            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n        }\\n    }\\n\\n    function safePermit(\\n        IERC20PermitUpgradeable token,\\n        address owner,\\n        address spender,\\n        uint256 value,\\n        uint256 deadline,\\n        uint8 v,\\n        bytes32 r,\\n        bytes32 s\\n    ) internal {\\n        uint256 nonceBefore = token.nonces(owner);\\n        token.permit(owner, spender, value, deadline, v, r, s);\\n        uint256 nonceAfter = token.nonces(owner);\\n        require(nonceAfter == nonceBefore + 1, \\\"SafeERC20: permit did not succeed\\\");\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     */\\n    function _callOptionalReturn(IERC20Upgradeable token, bytes memory data) private {\\n        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\\n        // the target address contains contract code and also asserts for success in the low-level call.\\n\\n        bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n        if (returndata.length > 0) {\\n            // Return data is optional\\n            require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x220c4a5af915e656be2aaa85ca57505d102418e476b1e2ef6c62e0c6ac143871\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n    /**\\n     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n    /**\\n     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n     */\\n    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n    /**\\n     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n     */\\n    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n    /**\\n     * @dev Returns the number of tokens in ``owner``'s account.\\n     */\\n    function balanceOf(address owner) external view returns (uint256 balance);\\n\\n    /**\\n     * @dev Returns the owner of the `tokenId` token.\\n     *\\n     * Requirements:\\n     *\\n     * - `tokenId` must exist.\\n     */\\n    function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n    /**\\n     * @dev Safely transfers `tokenId` token from `from` to `to`.\\n     *\\n     * Requirements:\\n     *\\n     * - `from` cannot be the zero address.\\n     * - `to` cannot be the zero address.\\n     * - `tokenId` token must exist and be owned by `from`.\\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function safeTransferFrom(\\n        address from,\\n        address to,\\n        uint256 tokenId,\\n        bytes calldata data\\n    ) external;\\n\\n    /**\\n     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n     * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n     *\\n     * Requirements:\\n     *\\n     * - `from` cannot be the zero address.\\n     * - `to` cannot be the zero address.\\n     * - `tokenId` token must exist and be owned by `from`.\\n     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function safeTransferFrom(\\n        address from,\\n        address to,\\n        uint256 tokenId\\n    ) external;\\n\\n    /**\\n     * @dev Transfers `tokenId` token from `from` to `to`.\\n     *\\n     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721\\n     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must\\n     * understand this adds an external call which potentially creates a reentrancy vulnerability.\\n     *\\n     * Requirements:\\n     *\\n     * - `from` cannot be the zero address.\\n     * - `to` cannot be the zero address.\\n     * - `tokenId` token must be owned by `from`.\\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(\\n        address from,\\n        address to,\\n        uint256 tokenId\\n    ) external;\\n\\n    /**\\n     * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n     * The approval is cleared when the token is transferred.\\n     *\\n     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n     *\\n     * Requirements:\\n     *\\n     * - The caller must own the token or be an approved operator.\\n     * - `tokenId` must exist.\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address to, uint256 tokenId) external;\\n\\n    /**\\n     * @dev Approve or remove `operator` as an operator for the caller.\\n     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n     *\\n     * Requirements:\\n     *\\n     * - The `operator` cannot be the caller.\\n     *\\n     * Emits an {ApprovalForAll} event.\\n     */\\n    function setApprovalForAll(address operator, bool _approved) external;\\n\\n    /**\\n     * @dev Returns the account approved for `tokenId` token.\\n     *\\n     * Requirements:\\n     *\\n     * - `tokenId` must exist.\\n     */\\n    function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n    /**\\n     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n     *\\n     * See {setApprovalForAll}\\n     */\\n    function isApprovedForAll(address owner, address operator) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x2c0b89cef83f353c6f9488c013d8a5968587ffdd6dfc26aad53774214b97e229\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n    /**\\n     * @dev Returns true if `account` is a contract.\\n     *\\n     * [IMPORTANT]\\n     * ====\\n     * It is unsafe to assume that an address for which this function returns\\n     * false is an externally-owned account (EOA) and not a contract.\\n     *\\n     * Among others, `isContract` will return false for the following\\n     * types of addresses:\\n     *\\n     *  - an externally-owned account\\n     *  - a contract in construction\\n     *  - an address where a contract will be created\\n     *  - an address where a contract lived, but was destroyed\\n     * ====\\n     *\\n     * [IMPORTANT]\\n     * ====\\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n     *\\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n     * constructor.\\n     * ====\\n     */\\n    function isContract(address account) internal view returns (bool) {\\n        // This method relies on extcodesize/address.code.length, which returns 0\\n        // for contracts in construction, since the code is only stored at the end\\n        // of the constructor execution.\\n\\n        return account.code.length > 0;\\n    }\\n\\n    /**\\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n     * `recipient`, forwarding all available gas and reverting on errors.\\n     *\\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n     * imposed by `transfer`, making them unable to receive funds via\\n     * `transfer`. {sendValue} removes this limitation.\\n     *\\n     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n     *\\n     * IMPORTANT: because control is transferred to `recipient`, care must be\\n     * taken to not create reentrancy vulnerabilities. Consider using\\n     * {ReentrancyGuard} or the\\n     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n     */\\n    function sendValue(address payable recipient, uint256 amount) internal {\\n        require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n        (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n        require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n    }\\n\\n    /**\\n     * @dev Performs a Solidity function call using a low level `call`. A\\n     * plain `call` is an unsafe replacement for a function call: use this\\n     * function instead.\\n     *\\n     * If `target` reverts with a revert reason, it is bubbled up by this\\n     * function (like regular Solidity function calls).\\n     *\\n     * Returns the raw returned data. To convert to the expected return value,\\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n     *\\n     * Requirements:\\n     *\\n     * - `target` must be a contract.\\n     * - calling `target` with `data` must not revert.\\n     *\\n     * _Available since v3.1._\\n     */\\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n        return functionCallWithValue(target, data, 0, \\\"Address: low-level call failed\\\");\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n     * `errorMessage` as a fallback revert reason when `target` reverts.\\n     *\\n     * _Available since v3.1._\\n     */\\n    function functionCall(\\n        address target,\\n        bytes memory data,\\n        string memory errorMessage\\n    ) internal returns (bytes memory) {\\n        return functionCallWithValue(target, data, 0, errorMessage);\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n     * but also transferring `value` wei to `target`.\\n     *\\n     * Requirements:\\n     *\\n     * - the calling contract must have an ETH balance of at least `value`.\\n     * - the called Solidity function must be `payable`.\\n     *\\n     * _Available since v3.1._\\n     */\\n    function functionCallWithValue(\\n        address target,\\n        bytes memory data,\\n        uint256 value\\n    ) internal returns (bytes memory) {\\n        return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\\n     *\\n     * _Available since v3.1._\\n     */\\n    function functionCallWithValue(\\n        address target,\\n        bytes memory data,\\n        uint256 value,\\n        string memory errorMessage\\n    ) internal returns (bytes memory) {\\n        require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n     * but performing a static call.\\n     *\\n     * _Available since v3.3._\\n     */\\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n        return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n     * but performing a static call.\\n     *\\n     * _Available since v3.3._\\n     */\\n    function functionStaticCall(\\n        address target,\\n        bytes memory data,\\n        string memory errorMessage\\n    ) internal view returns (bytes memory) {\\n        (bool success, bytes memory returndata) = target.staticcall(data);\\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n    }\\n\\n    /**\\n     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\\n     *\\n     * _Available since v4.8._\\n     */\\n    function verifyCallResultFromTarget(\\n        address target,\\n        bool success,\\n        bytes memory returndata,\\n        string memory errorMessage\\n    ) internal view returns (bytes memory) {\\n        if (success) {\\n            if (returndata.length == 0) {\\n                // only check isContract if the call was successful and the return data is empty\\n                // otherwise we already know that it was a contract\\n                require(isContract(target), \\\"Address: call to non-contract\\\");\\n            }\\n            return returndata;\\n        } else {\\n            _revert(returndata, errorMessage);\\n        }\\n    }\\n\\n    /**\\n     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\\n     * revert reason or using the provided one.\\n     *\\n     * _Available since v4.3._\\n     */\\n    function verifyCallResult(\\n        bool success,\\n        bytes memory returndata,\\n        string memory errorMessage\\n    ) internal pure returns (bytes memory) {\\n        if (success) {\\n            return returndata;\\n        } else {\\n            _revert(returndata, errorMessage);\\n        }\\n    }\\n\\n    function _revert(bytes memory returndata, string memory errorMessage) private pure {\\n        // Look for revert reason and bubble it up if present\\n        if (returndata.length > 0) {\\n            // The easiest way to bubble the revert reason is using memory via assembly\\n            /// @solidity memory-safe-assembly\\n            assembly {\\n                let returndata_size := mload(returndata)\\n                revert(add(32, returndata), returndata_size)\\n            }\\n        } else {\\n            revert(errorMessage);\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x2edcb41c121abc510932e8d83ff8b82cf9cdde35e7c297622f5c29ef0af25183\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n    function __Context_init() internal onlyInitializing {\\n    }\\n\\n    function __Context_init_unchained() internal onlyInitializing {\\n    }\\n    function _msgSender() internal view virtual returns (address) {\\n        return msg.sender;\\n    }\\n\\n    function _msgData() internal view virtual returns (bytes calldata) {\\n        return msg.data;\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x963ea7f0b48b032eef72fe3a7582edf78408d6f834115b9feadd673a4d5bd149\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/Counters.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary CountersUpgradeable {\\n    struct Counter {\\n        // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n        // this feature: see https://github.com/ethereum/solidity/issues/4637\\n        uint256 _value; // default: 0\\n    }\\n\\n    function current(Counter storage counter) internal view returns (uint256) {\\n        return counter._value;\\n    }\\n\\n    function increment(Counter storage counter) internal {\\n        unchecked {\\n            counter._value += 1;\\n        }\\n    }\\n\\n    function decrement(Counter storage counter) internal {\\n        uint256 value = counter._value;\\n        require(value > 0, \\\"Counter: decrement overflow\\\");\\n        unchecked {\\n            counter._value = value - 1;\\n        }\\n    }\\n\\n    function reset(Counter storage counter) internal {\\n        counter._value = 0;\\n    }\\n}\\n\",\"keccak256\":\"0x798741e231b22b81e2dd2eddaaf8832dee4baf5cd8e2dbaa5c1dd12a1c053c4d\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./math/MathUpgradeable.sol\\\";\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n    bytes16 private constant _SYMBOLS = \\\"0123456789abcdef\\\";\\n    uint8 private constant _ADDRESS_LENGTH = 20;\\n\\n    /**\\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n     */\\n    function toString(uint256 value) internal pure returns (string memory) {\\n        unchecked {\\n            uint256 length = MathUpgradeable.log10(value) + 1;\\n            string memory buffer = new string(length);\\n            uint256 ptr;\\n            /// @solidity memory-safe-assembly\\n            assembly {\\n                ptr := add(buffer, add(32, length))\\n            }\\n            while (true) {\\n                ptr--;\\n                /// @solidity memory-safe-assembly\\n                assembly {\\n                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\\n                }\\n                value /= 10;\\n                if (value == 0) break;\\n            }\\n            return buffer;\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n     */\\n    function toHexString(uint256 value) internal pure returns (string memory) {\\n        unchecked {\\n            return toHexString(value, MathUpgradeable.log256(value) + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n     */\\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n        bytes memory buffer = new bytes(2 * length + 2);\\n        buffer[0] = \\\"0\\\";\\n        buffer[1] = \\\"x\\\";\\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\\n            buffer[i] = _SYMBOLS[value & 0xf];\\n            value >>= 4;\\n        }\\n        require(value == 0, \\\"Strings: hex length insufficient\\\");\\n        return string(buffer);\\n    }\\n\\n    /**\\n     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.\\n     */\\n    function toHexString(address addr) internal pure returns (string memory) {\\n        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);\\n    }\\n}\\n\",\"keccak256\":\"0x6b9a5d35b744b25529a2856a8093e7c03fb35a34b1c4fb5499e560f8ade140da\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/cryptography/ECDSAUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/ECDSA.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../StringsUpgradeable.sol\\\";\\n\\n/**\\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\\n *\\n * These functions can be used to verify that a message was signed by the holder\\n * of the private keys of a given address.\\n */\\nlibrary ECDSAUpgradeable {\\n    enum RecoverError {\\n        NoError,\\n        InvalidSignature,\\n        InvalidSignatureLength,\\n        InvalidSignatureS,\\n        InvalidSignatureV // Deprecated in v4.8\\n    }\\n\\n    function _throwError(RecoverError error) private pure {\\n        if (error == RecoverError.NoError) {\\n            return; // no error: do nothing\\n        } else if (error == RecoverError.InvalidSignature) {\\n            revert(\\\"ECDSA: invalid signature\\\");\\n        } else if (error == RecoverError.InvalidSignatureLength) {\\n            revert(\\\"ECDSA: invalid signature length\\\");\\n        } else if (error == RecoverError.InvalidSignatureS) {\\n            revert(\\\"ECDSA: invalid signature 's' value\\\");\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the address that signed a hashed message (`hash`) with\\n     * `signature` or error string. This address can then be used for verification purposes.\\n     *\\n     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n     * this function rejects them by requiring the `s` value to be in the lower\\n     * half order, and the `v` value to be either 27 or 28.\\n     *\\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n     * verification to be secure: it is possible to craft signatures that\\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n     * this is by receiving a hash of the original message (which may otherwise\\n     * be too long), and then calling {toEthSignedMessageHash} on it.\\n     *\\n     * Documentation for signature generation:\\n     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\\n     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]\\n     *\\n     * _Available since v4.3._\\n     */\\n    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {\\n        if (signature.length == 65) {\\n            bytes32 r;\\n            bytes32 s;\\n            uint8 v;\\n            // ecrecover takes the signature parameters, and the only way to get them\\n            // currently is to use assembly.\\n            /// @solidity memory-safe-assembly\\n            assembly {\\n                r := mload(add(signature, 0x20))\\n                s := mload(add(signature, 0x40))\\n                v := byte(0, mload(add(signature, 0x60)))\\n            }\\n            return tryRecover(hash, v, r, s);\\n        } else {\\n            return (address(0), RecoverError.InvalidSignatureLength);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the address that signed a hashed message (`hash`) with\\n     * `signature`. This address can then be used for verification purposes.\\n     *\\n     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n     * this function rejects them by requiring the `s` value to be in the lower\\n     * half order, and the `v` value to be either 27 or 28.\\n     *\\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n     * verification to be secure: it is possible to craft signatures that\\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n     * this is by receiving a hash of the original message (which may otherwise\\n     * be too long), and then calling {toEthSignedMessageHash} on it.\\n     */\\n    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\\n        (address recovered, RecoverError error) = tryRecover(hash, signature);\\n        _throwError(error);\\n        return recovered;\\n    }\\n\\n    /**\\n     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.\\n     *\\n     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]\\n     *\\n     * _Available since v4.3._\\n     */\\n    function tryRecover(\\n        bytes32 hash,\\n        bytes32 r,\\n        bytes32 vs\\n    ) internal pure returns (address, RecoverError) {\\n        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);\\n        uint8 v = uint8((uint256(vs) >> 255) + 27);\\n        return tryRecover(hash, v, r, s);\\n    }\\n\\n    /**\\n     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.\\n     *\\n     * _Available since v4.2._\\n     */\\n    function recover(\\n        bytes32 hash,\\n        bytes32 r,\\n        bytes32 vs\\n    ) internal pure returns (address) {\\n        (address recovered, RecoverError error) = tryRecover(hash, r, vs);\\n        _throwError(error);\\n        return recovered;\\n    }\\n\\n    /**\\n     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\\n     * `r` and `s` signature fields separately.\\n     *\\n     * _Available since v4.3._\\n     */\\n    function tryRecover(\\n        bytes32 hash,\\n        uint8 v,\\n        bytes32 r,\\n        bytes32 s\\n    ) internal pure returns (address, RecoverError) {\\n        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\\n        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\\n        // the valid range for s in (301): 0 < s < secp256k1n \\u00f7 2 + 1, and for v in (302): v \\u2208 {27, 28}. Most\\n        // signatures from current libraries generate a unique signature with an s-value in the lower half order.\\n        //\\n        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\\n        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\\n        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\\n        // these malleable signatures as well.\\n        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\\n            return (address(0), RecoverError.InvalidSignatureS);\\n        }\\n\\n        // If the signature is valid (and not malleable), return the signer address\\n        address signer = ecrecover(hash, v, r, s);\\n        if (signer == address(0)) {\\n            return (address(0), RecoverError.InvalidSignature);\\n        }\\n\\n        return (signer, RecoverError.NoError);\\n    }\\n\\n    /**\\n     * @dev Overload of {ECDSA-recover} that receives the `v`,\\n     * `r` and `s` signature fields separately.\\n     */\\n    function recover(\\n        bytes32 hash,\\n        uint8 v,\\n        bytes32 r,\\n        bytes32 s\\n    ) internal pure returns (address) {\\n        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);\\n        _throwError(error);\\n        return recovered;\\n    }\\n\\n    /**\\n     * @dev Returns an Ethereum Signed Message, created from a `hash`. This\\n     * produces hash corresponding to the one signed with the\\n     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n     * JSON-RPC method as part of EIP-191.\\n     *\\n     * See {recover}.\\n     */\\n    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {\\n        // 32 is the length in bytes of hash,\\n        // enforced by the type signature above\\n        return keccak256(abi.encodePacked(\\\"\\\\x19Ethereum Signed Message:\\\\n32\\\", hash));\\n    }\\n\\n    /**\\n     * @dev Returns an Ethereum Signed Message, created from `s`. This\\n     * produces hash corresponding to the one signed with the\\n     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n     * JSON-RPC method as part of EIP-191.\\n     *\\n     * See {recover}.\\n     */\\n    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {\\n        return keccak256(abi.encodePacked(\\\"\\\\x19Ethereum Signed Message:\\\\n\\\", StringsUpgradeable.toString(s.length), s));\\n    }\\n\\n    /**\\n     * @dev Returns an Ethereum Signed Typed Data, created from a\\n     * `domainSeparator` and a `structHash`. This produces hash corresponding\\n     * to the one signed with the\\n     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]\\n     * JSON-RPC method as part of EIP-712.\\n     *\\n     * See {recover}.\\n     */\\n    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {\\n        return keccak256(abi.encodePacked(\\\"\\\\x19\\\\x01\\\", domainSeparator, structHash));\\n    }\\n}\\n\",\"keccak256\":\"0x12f297cafe6e2847ae0378502f155654d0764b532a9873c8afe4350950fa7971\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/cryptography/EIP712Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/EIP712.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./ECDSAUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.\\n *\\n * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,\\n * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding\\n * they need in their contracts using a combination of `abi.encode` and `keccak256`.\\n *\\n * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding\\n * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA\\n * ({_hashTypedDataV4}).\\n *\\n * The implementation of the domain separator was designed to be as efficient as possible while still properly updating\\n * the chain id to protect against replay attacks on an eventual fork of the chain.\\n *\\n * NOTE: This contract implements the version of the encoding known as \\\"v4\\\", as implemented by the JSON RPC method\\n * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].\\n *\\n * _Available since v3.4._\\n *\\n * @custom:storage-size 52\\n */\\nabstract contract EIP712Upgradeable is Initializable {\\n    /* solhint-disable var-name-mixedcase */\\n    bytes32 private _HASHED_NAME;\\n    bytes32 private _HASHED_VERSION;\\n    bytes32 private constant _TYPE_HASH = keccak256(\\\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\\\");\\n\\n    /* solhint-enable var-name-mixedcase */\\n\\n    /**\\n     * @dev Initializes the domain separator and parameter caches.\\n     *\\n     * The meaning of `name` and `version` is specified in\\n     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:\\n     *\\n     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.\\n     * - `version`: the current major version of the signing domain.\\n     *\\n     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart\\n     * contract upgrade].\\n     */\\n    function __EIP712_init(string memory name, string memory version) internal onlyInitializing {\\n        __EIP712_init_unchained(name, version);\\n    }\\n\\n    function __EIP712_init_unchained(string memory name, string memory version) internal onlyInitializing {\\n        bytes32 hashedName = keccak256(bytes(name));\\n        bytes32 hashedVersion = keccak256(bytes(version));\\n        _HASHED_NAME = hashedName;\\n        _HASHED_VERSION = hashedVersion;\\n    }\\n\\n    /**\\n     * @dev Returns the domain separator for the current chain.\\n     */\\n    function _domainSeparatorV4() internal view returns (bytes32) {\\n        return _buildDomainSeparator(_TYPE_HASH, _EIP712NameHash(), _EIP712VersionHash());\\n    }\\n\\n    function _buildDomainSeparator(\\n        bytes32 typeHash,\\n        bytes32 nameHash,\\n        bytes32 versionHash\\n    ) private view returns (bytes32) {\\n        return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));\\n    }\\n\\n    /**\\n     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this\\n     * function returns the hash of the fully encoded EIP712 message for this domain.\\n     *\\n     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:\\n     *\\n     * ```solidity\\n     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(\\n     *     keccak256(\\\"Mail(address to,string contents)\\\"),\\n     *     mailTo,\\n     *     keccak256(bytes(mailContents))\\n     * )));\\n     * address signer = ECDSA.recover(digest, signature);\\n     * ```\\n     */\\n    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {\\n        return ECDSAUpgradeable.toTypedDataHash(_domainSeparatorV4(), structHash);\\n    }\\n\\n    /**\\n     * @dev The hash of the name parameter for the EIP712 domain.\\n     *\\n     * NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs\\n     * are a concern.\\n     */\\n    function _EIP712NameHash() internal virtual view returns (bytes32) {\\n        return _HASHED_NAME;\\n    }\\n\\n    /**\\n     * @dev The hash of the version parameter for the EIP712 domain.\\n     *\\n     * NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs\\n     * are a concern.\\n     */\\n    function _EIP712VersionHash() internal virtual view returns (bytes32) {\\n        return _HASHED_VERSION;\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x3017aded62c4a2b9707f5f06f92934e592c1c9b6f384b91b51340a6d5f841931\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xc6cef87559d0aeffdf0a99803de655938a7779ec0a3cd5d4383483ad85565a09\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/math/MathUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary MathUpgradeable {\\n    enum Rounding {\\n        Down, // Toward negative infinity\\n        Up, // Toward infinity\\n        Zero // Toward zero\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return a > b ? a : b;\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return a < b ? a : b;\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds up instead\\n     * of rounding down.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b - 1) / b can overflow on addition, so we distribute.\\n        return a == 0 ? 0 : (a - 1) / b + 1;\\n    }\\n\\n    /**\\n     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\\n     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\\n     * with further edits by Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(\\n        uint256 x,\\n        uint256 y,\\n        uint256 denominator\\n    ) internal pure returns (uint256 result) {\\n        unchecked {\\n            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\\n            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n            // variables such that product = prod1 * 2^256 + prod0.\\n            uint256 prod0; // Least significant 256 bits of the product\\n            uint256 prod1; // Most significant 256 bits of the product\\n            assembly {\\n                let mm := mulmod(x, y, not(0))\\n                prod0 := mul(x, y)\\n                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n            }\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (prod1 == 0) {\\n                return prod0 / denominator;\\n            }\\n\\n            // Make sure the result is less than 2^256. Also prevents denominator == 0.\\n            require(denominator > prod1);\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [prod1 prod0].\\n            uint256 remainder;\\n            assembly {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                prod1 := sub(prod1, gt(remainder, prod0))\\n                prod0 := sub(prod0, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\\n            // See https://cs.stackexchange.com/q/138556/92363.\\n\\n            // Does not overflow because the denominator cannot be zero at this stage in the function.\\n            uint256 twos = denominator & (~denominator + 1);\\n            assembly {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [prod1 prod0] by twos.\\n                prod0 := div(prod0, twos)\\n\\n                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from prod1 into prod0.\\n            prod0 |= prod1 * twos;\\n\\n            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\\n            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv = 1 mod 2^4.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\\n            // in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n            inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n            inverse *= 2 - denominator * inverse; // inverse mod 2^32\\n            inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n            inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n            inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n            // is no longer required.\\n            result = prod0 * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(\\n        uint256 x,\\n        uint256 y,\\n        uint256 denominator,\\n        Rounding rounding\\n    ) internal pure returns (uint256) {\\n        uint256 result = mulDiv(x, y, denominator);\\n        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n            result += 1;\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\\n     *\\n     * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        if (a == 0) {\\n            return 0;\\n        }\\n\\n        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\\n        //\\n        // We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\\n        //\\n        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\\n        // \\u2192 `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\\n        // \\u2192 `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\\n        //\\n        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n        uint256 result = 1 << (log2(a) >> 1);\\n\\n        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n        // into the expected uint128 result.\\n        unchecked {\\n            result = (result + a / result) >> 1;\\n            result = (result + a / result) >> 1;\\n            result = (result + a / result) >> 1;\\n            result = (result + a / result) >> 1;\\n            result = (result + a / result) >> 1;\\n            result = (result + a / result) >> 1;\\n            result = (result + a / result) >> 1;\\n            return min(result, a / result);\\n        }\\n    }\\n\\n    /**\\n     * @notice Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, rounded down, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >> 128 > 0) {\\n                value >>= 128;\\n                result += 128;\\n            }\\n            if (value >> 64 > 0) {\\n                value >>= 64;\\n                result += 64;\\n            }\\n            if (value >> 32 > 0) {\\n                value >>= 32;\\n                result += 32;\\n            }\\n            if (value >> 16 > 0) {\\n                value >>= 16;\\n                result += 16;\\n            }\\n            if (value >> 8 > 0) {\\n                value >>= 8;\\n                result += 8;\\n            }\\n            if (value >> 4 > 0) {\\n                value >>= 4;\\n                result += 4;\\n            }\\n            if (value >> 2 > 0) {\\n                value >>= 2;\\n                result += 2;\\n            }\\n            if (value >> 1 > 0) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, rounded down, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10**64) {\\n                value /= 10**64;\\n                result += 64;\\n            }\\n            if (value >= 10**32) {\\n                value /= 10**32;\\n                result += 32;\\n            }\\n            if (value >= 10**16) {\\n                value /= 10**16;\\n                result += 16;\\n            }\\n            if (value >= 10**8) {\\n                value /= 10**8;\\n                result += 8;\\n            }\\n            if (value >= 10**4) {\\n                value /= 10**4;\\n                result += 4;\\n            }\\n            if (value >= 10**2) {\\n                value /= 10**2;\\n                result += 2;\\n            }\\n            if (value >= 10**1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, rounded down, of a positive value.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >> 128 > 0) {\\n                value >>= 128;\\n                result += 16;\\n            }\\n            if (value >> 64 > 0) {\\n                value >>= 64;\\n                result += 8;\\n            }\\n            if (value >> 32 > 0) {\\n                value >>= 32;\\n                result += 4;\\n            }\\n            if (value >> 16 > 0) {\\n                value >>= 16;\\n                result += 2;\\n            }\\n            if (value >> 8 > 0) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xc1bd5b53319c68f84e3becd75694d941e8f4be94049903232cd8bc7c535aaa5a\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n    address private _owner;\\n\\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n    /**\\n     * @dev Initializes the contract setting the deployer as the initial owner.\\n     */\\n    constructor() {\\n        _transferOwnership(_msgSender());\\n    }\\n\\n    /**\\n     * @dev Throws if called by any account other than the owner.\\n     */\\n    modifier onlyOwner() {\\n        _checkOwner();\\n        _;\\n    }\\n\\n    /**\\n     * @dev Returns the address of the current owner.\\n     */\\n    function owner() public view virtual returns (address) {\\n        return _owner;\\n    }\\n\\n    /**\\n     * @dev Throws if the sender is not the owner.\\n     */\\n    function _checkOwner() internal view virtual {\\n        require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n    }\\n\\n    /**\\n     * @dev Leaves the contract without owner. It will not be possible to call\\n     * `onlyOwner` functions anymore. Can only be called by the current owner.\\n     *\\n     * NOTE: Renouncing ownership will leave the contract without an owner,\\n     * thereby removing any functionality that is only available to the owner.\\n     */\\n    function renounceOwnership() public virtual onlyOwner {\\n        _transferOwnership(address(0));\\n    }\\n\\n    /**\\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n     * Can only be called by the current owner.\\n     */\\n    function transferOwnership(address newOwner) public virtual onlyOwner {\\n        require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n        _transferOwnership(newOwner);\\n    }\\n\\n    /**\\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n     * Internal function without access restriction.\\n     */\\n    function _transferOwnership(address newOwner) internal virtual {\\n        address oldOwner = _owner;\\n        _owner = newOwner;\\n        emit OwnershipTransferred(oldOwner, newOwner);\\n    }\\n}\\n\",\"keccak256\":\"0xa94b34880e3c1b0b931662cb1c09e5dfa6662f31cba80e07c5ee71cd135c9673\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the amount of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the amount of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves `amount` tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 amount) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 amount) external returns (bool);\\n\\n    /**\\n     * @dev Moves `amount` tokens from `from` to `to` using the\\n     * allowance mechanism. `amount` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(\\n        address from,\\n        address to,\\n        uint256 amount\\n    ) external returns (bool);\\n}\\n\",\"keccak256\":\"0x9750c6b834f7b43000631af5cc30001c5f547b3ceb3635488f140f60e897ea6b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n    /**\\n     * @dev Returns the name of the token.\\n     */\\n    function name() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the symbol of the token.\\n     */\\n    function symbol() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the decimals places of the token.\\n     */\\n    function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x8de418a5503946cabe331f35fe242d3201a73f67f77aaeb7110acb1f30423aca\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n    function _msgSender() internal view virtual returns (address) {\\n        return msg.sender;\\n    }\\n\\n    function _msgData() internal view virtual returns (bytes calldata) {\\n        return msg.data;\\n    }\\n}\\n\",\"keccak256\":\"0xe2e337e6dde9ef6b680e07338c493ebea1b5fd09b43424112868e9cc1706bca7\",\"license\":\"MIT\"},\"@thesis/solidity-contracts/contracts/token/ERC20WithPermit.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.4;\\n\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\n\\nimport \\\"./IERC20WithPermit.sol\\\";\\nimport \\\"./IReceiveApproval.sol\\\";\\n\\n/// @title  ERC20WithPermit\\n/// @notice Burnable ERC20 token with EIP2612 permit functionality. User can\\n///         authorize a transfer of their token with a signature conforming\\n///         EIP712 standard instead of an on-chain transaction from their\\n///         address. Anyone can submit this signature on the user's behalf by\\n///         calling the permit function, as specified in EIP2612 standard,\\n///         paying gas fees, and possibly performing other actions in the same\\n///         transaction.\\ncontract ERC20WithPermit is IERC20WithPermit, Ownable {\\n    /// @notice The amount of tokens owned by the given account.\\n    mapping(address => uint256) public override balanceOf;\\n\\n    /// @notice The remaining number of tokens that spender will be\\n    ///         allowed to spend on behalf of owner through `transferFrom` and\\n    ///         `burnFrom`. This is zero by default.\\n    mapping(address => mapping(address => uint256)) public override allowance;\\n\\n    /// @notice Returns the current nonce for EIP2612 permission for the\\n    ///         provided token owner for a replay protection. Used to construct\\n    ///         EIP2612 signature provided to `permit` function.\\n    mapping(address => uint256) public override nonce;\\n\\n    uint256 public immutable cachedChainId;\\n    bytes32 public immutable cachedDomainSeparator;\\n\\n    /// @notice Returns EIP2612 Permit message hash. Used to construct EIP2612\\n    ///         signature provided to `permit` function.\\n    bytes32 public constant override PERMIT_TYPEHASH =\\n        keccak256(\\n            \\\"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\\\"\\n        );\\n\\n    /// @notice The amount of tokens in existence.\\n    uint256 public override totalSupply;\\n\\n    /// @notice The name of the token.\\n    string public override name;\\n\\n    /// @notice The symbol of the token.\\n    string public override symbol;\\n\\n    /// @notice The decimals places of the token.\\n    uint8 public constant override decimals = 18;\\n\\n    constructor(string memory _name, string memory _symbol) {\\n        name = _name;\\n        symbol = _symbol;\\n\\n        cachedChainId = block.chainid;\\n        cachedDomainSeparator = buildDomainSeparator();\\n    }\\n\\n    /// @notice Moves `amount` tokens from the caller's account to `recipient`.\\n    /// @return True if the operation succeeded, reverts otherwise.\\n    /// @dev Requirements:\\n    ///       - `recipient` cannot be the zero address,\\n    ///       - the caller must have a balance of at least `amount`.\\n    function transfer(address recipient, uint256 amount)\\n        external\\n        override\\n        returns (bool)\\n    {\\n        _transfer(msg.sender, recipient, amount);\\n        return true;\\n    }\\n\\n    /// @notice Moves `amount` tokens from `spender` to `recipient` using the\\n    ///         allowance mechanism. `amount` is then deducted from the caller's\\n    ///         allowance unless the allowance was made for `type(uint256).max`.\\n    /// @return True if the operation succeeded, reverts otherwise.\\n    /// @dev Requirements:\\n    ///      - `spender` and `recipient` cannot be the zero address,\\n    ///      - `spender` must have a balance of at least `amount`,\\n    ///      - the caller must have allowance for `spender`'s tokens of at least\\n    ///        `amount`.\\n    function transferFrom(\\n        address spender,\\n        address recipient,\\n        uint256 amount\\n    ) external override returns (bool) {\\n        uint256 currentAllowance = allowance[spender][msg.sender];\\n        if (currentAllowance != type(uint256).max) {\\n            require(\\n                currentAllowance >= amount,\\n                \\\"Transfer amount exceeds allowance\\\"\\n            );\\n            _approve(spender, msg.sender, currentAllowance - amount);\\n        }\\n        _transfer(spender, recipient, amount);\\n        return true;\\n    }\\n\\n    /// @notice EIP2612 approval made with secp256k1 signature.\\n    ///         Users can authorize a transfer of their tokens with a signature\\n    ///         conforming EIP712 standard, rather than an on-chain transaction\\n    ///         from their address. Anyone can submit this signature on the\\n    ///         user's behalf by calling the permit function, paying gas fees,\\n    ///         and possibly performing other actions in the same transaction.\\n    /// @dev    The deadline argument can be set to `type(uint256).max to create\\n    ///         permits that effectively never expire.  If the `amount` is set\\n    ///         to `type(uint256).max` then `transferFrom` and `burnFrom` will\\n    ///         not reduce an allowance.\\n    function permit(\\n        address owner,\\n        address spender,\\n        uint256 amount,\\n        uint256 deadline,\\n        uint8 v,\\n        bytes32 r,\\n        bytes32 s\\n    ) external override {\\n        /* solhint-disable-next-line not-rely-on-time */\\n        require(deadline >= block.timestamp, \\\"Permission expired\\\");\\n\\n        // Validate `s` and `v` values for a malleability concern described in EIP2.\\n        // Only signatures with `s` value in the lower half of the secp256k1\\n        // curve's order and `v` value of 27 or 28 are considered valid.\\n        require(\\n            uint256(s) <=\\n                0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0,\\n            \\\"Invalid signature 's' value\\\"\\n        );\\n        require(v == 27 || v == 28, \\\"Invalid signature 'v' value\\\");\\n\\n        bytes32 digest = keccak256(\\n            abi.encodePacked(\\n                \\\"\\\\x19\\\\x01\\\",\\n                DOMAIN_SEPARATOR(),\\n                keccak256(\\n                    abi.encode(\\n                        PERMIT_TYPEHASH,\\n                        owner,\\n                        spender,\\n                        amount,\\n                        nonce[owner]++,\\n                        deadline\\n                    )\\n                )\\n            )\\n        );\\n        address recoveredAddress = ecrecover(digest, v, r, s);\\n        require(\\n            recoveredAddress != address(0) && recoveredAddress == owner,\\n            \\\"Invalid signature\\\"\\n        );\\n        _approve(owner, spender, amount);\\n    }\\n\\n    /// @notice Creates `amount` tokens and assigns them to `account`,\\n    ///         increasing the total supply.\\n    /// @dev Requirements:\\n    ///      - `recipient` cannot be the zero address.\\n    function mint(address recipient, uint256 amount) external onlyOwner {\\n        require(recipient != address(0), \\\"Mint to the zero address\\\");\\n\\n        beforeTokenTransfer(address(0), recipient, amount);\\n\\n        totalSupply += amount;\\n        balanceOf[recipient] += amount;\\n        emit Transfer(address(0), recipient, amount);\\n    }\\n\\n    /// @notice Destroys `amount` tokens from the caller.\\n    /// @dev Requirements:\\n    ///       - the caller must have a balance of at least `amount`.\\n    function burn(uint256 amount) external override {\\n        _burn(msg.sender, amount);\\n    }\\n\\n    /// @notice Destroys `amount` of tokens from `account` using the allowance\\n    ///         mechanism. `amount` is then deducted from the caller's allowance\\n    ///         unless the allowance was made for `type(uint256).max`.\\n    /// @dev Requirements:\\n    ///      - `account` must have a balance of at least `amount`,\\n    ///      - the caller must have allowance for `account`'s tokens of at least\\n    ///        `amount`.\\n    function burnFrom(address account, uint256 amount) external override {\\n        uint256 currentAllowance = allowance[account][msg.sender];\\n        if (currentAllowance != type(uint256).max) {\\n            require(\\n                currentAllowance >= amount,\\n                \\\"Burn amount exceeds allowance\\\"\\n            );\\n            _approve(account, msg.sender, currentAllowance - amount);\\n        }\\n        _burn(account, amount);\\n    }\\n\\n    /// @notice Calls `receiveApproval` function on spender previously approving\\n    ///         the spender to withdraw from the caller multiple times, up to\\n    ///         the `amount` amount. If this function is called again, it\\n    ///         overwrites the current allowance with `amount`. Reverts if the\\n    ///         approval reverted or if `receiveApproval` call on the spender\\n    ///         reverted.\\n    /// @return True if both approval and `receiveApproval` calls succeeded.\\n    /// @dev If the `amount` is set to `type(uint256).max` then\\n    ///      `transferFrom` and `burnFrom` will not reduce an allowance.\\n    function approveAndCall(\\n        address spender,\\n        uint256 amount,\\n        bytes memory extraData\\n    ) external override returns (bool) {\\n        if (approve(spender, amount)) {\\n            IReceiveApproval(spender).receiveApproval(\\n                msg.sender,\\n                amount,\\n                address(this),\\n                extraData\\n            );\\n            return true;\\n        }\\n        return false;\\n    }\\n\\n    /// @notice Sets `amount` as the allowance of `spender` over the caller's\\n    ///         tokens.\\n    /// @return True if the operation succeeded.\\n    /// @dev If the `amount` is set to `type(uint256).max` then\\n    ///      `transferFrom` and `burnFrom` will not reduce an allowance.\\n    ///      Beware that changing an allowance with this method brings the risk\\n    ///      that someone may use both the old and the new allowance by\\n    ///      unfortunate transaction ordering. One possible solution to mitigate\\n    ///      this race condition is to first reduce the spender's allowance to 0\\n    ///      and set the desired value afterwards:\\n    ///      https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n    function approve(address spender, uint256 amount)\\n        public\\n        override\\n        returns (bool)\\n    {\\n        _approve(msg.sender, spender, amount);\\n        return true;\\n    }\\n\\n    /// @notice Returns hash of EIP712 Domain struct with the token name as\\n    ///         a signing domain and token contract as a verifying contract.\\n    ///         Used to construct EIP2612 signature provided to `permit`\\n    ///         function.\\n    /* solhint-disable-next-line func-name-mixedcase */\\n    function DOMAIN_SEPARATOR() public view override returns (bytes32) {\\n        // As explained in EIP-2612, if the DOMAIN_SEPARATOR contains the\\n        // chainId and is defined at contract deployment instead of\\n        // reconstructed for every signature, there is a risk of possible replay\\n        // attacks between chains in the event of a future chain split.\\n        // To address this issue, we check the cached chain ID against the\\n        // current one and in case they are different, we build domain separator\\n        // from scratch.\\n        if (block.chainid == cachedChainId) {\\n            return cachedDomainSeparator;\\n        } else {\\n            return buildDomainSeparator();\\n        }\\n    }\\n\\n    /// @dev Hook that is called before any transfer of tokens. This includes\\n    ///      minting and burning.\\n    ///\\n    /// Calling conditions:\\n    /// - when `from` and `to` are both non-zero, `amount` of `from`'s tokens\\n    ///   will be to transferred to `to`.\\n    /// - when `from` is zero, `amount` tokens will be minted for `to`.\\n    /// - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n    /// - `from` and `to` are never both zero.\\n    // slither-disable-next-line dead-code\\n    function beforeTokenTransfer(\\n        address from,\\n        address to,\\n        uint256 amount\\n    ) internal virtual {}\\n\\n    function _burn(address account, uint256 amount) internal {\\n        uint256 currentBalance = balanceOf[account];\\n        require(currentBalance >= amount, \\\"Burn amount exceeds balance\\\");\\n\\n        beforeTokenTransfer(account, address(0), amount);\\n\\n        balanceOf[account] = currentBalance - amount;\\n        totalSupply -= amount;\\n        emit Transfer(account, address(0), amount);\\n    }\\n\\n    function _transfer(\\n        address spender,\\n        address recipient,\\n        uint256 amount\\n    ) private {\\n        require(spender != address(0), \\\"Transfer from the zero address\\\");\\n        require(recipient != address(0), \\\"Transfer to the zero address\\\");\\n        require(recipient != address(this), \\\"Transfer to the token address\\\");\\n\\n        beforeTokenTransfer(spender, recipient, amount);\\n\\n        uint256 spenderBalance = balanceOf[spender];\\n        require(spenderBalance >= amount, \\\"Transfer amount exceeds balance\\\");\\n        balanceOf[spender] = spenderBalance - amount;\\n        balanceOf[recipient] += amount;\\n        emit Transfer(spender, recipient, amount);\\n    }\\n\\n    function _approve(\\n        address owner,\\n        address spender,\\n        uint256 amount\\n    ) private {\\n        require(owner != address(0), \\\"Approve from the zero address\\\");\\n        require(spender != address(0), \\\"Approve to the zero address\\\");\\n        allowance[owner][spender] = amount;\\n        emit Approval(owner, spender, amount);\\n    }\\n\\n    function buildDomainSeparator() private view returns (bytes32) {\\n        return\\n            keccak256(\\n                abi.encode(\\n                    keccak256(\\n                        \\\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\\\"\\n                    ),\\n                    keccak256(bytes(name)),\\n                    keccak256(bytes(\\\"1\\\")),\\n                    block.chainid,\\n                    address(this)\\n                )\\n            );\\n    }\\n}\\n\",\"keccak256\":\"0x1e1bf4ec5c9d6fe70f6f834316482aeff3f122ff4ffaa7178099e7ae71a0b16d\",\"license\":\"MIT\"},\"@thesis/solidity-contracts/contracts/token/IApproveAndCall.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.4;\\n\\n/// @notice An interface that should be implemented by tokens supporting\\n///         `approveAndCall`/`receiveApproval` pattern.\\ninterface IApproveAndCall {\\n    /// @notice Executes `receiveApproval` function on spender as specified in\\n    ///         `IReceiveApproval` interface. Approves spender to withdraw from\\n    ///         the caller multiple times, up to the `amount`. If this\\n    ///         function is called again, it overwrites the current allowance\\n    ///         with `amount`. Reverts if the approval reverted or if\\n    ///         `receiveApproval` call on the spender reverted.\\n    function approveAndCall(\\n        address spender,\\n        uint256 amount,\\n        bytes memory extraData\\n    ) external returns (bool);\\n}\\n\",\"keccak256\":\"0x393d18ef81a57dcc96fff4c340cc2945deaebb37b9796c322cf2bc96872c3df8\",\"license\":\"MIT\"},\"@thesis/solidity-contracts/contracts/token/IERC20WithPermit.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.4;\\n\\nimport \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\n\\nimport \\\"./IApproveAndCall.sol\\\";\\n\\n/// @title  IERC20WithPermit\\n/// @notice Burnable ERC20 token with EIP2612 permit functionality. User can\\n///         authorize a transfer of their token with a signature conforming\\n///         EIP712 standard instead of an on-chain transaction from their\\n///         address. Anyone can submit this signature on the user's behalf by\\n///         calling the permit function, as specified in EIP2612 standard,\\n///         paying gas fees, and possibly performing other actions in the same\\n///         transaction.\\ninterface IERC20WithPermit is IERC20, IERC20Metadata, IApproveAndCall {\\n    /// @notice EIP2612 approval made with secp256k1 signature.\\n    ///         Users can authorize a transfer of their tokens with a signature\\n    ///         conforming EIP712 standard, rather than an on-chain transaction\\n    ///         from their address. Anyone can submit this signature on the\\n    ///         user's behalf by calling the permit function, paying gas fees,\\n    ///         and possibly performing other actions in the same transaction.\\n    /// @dev    The deadline argument can be set to `type(uint256).max to create\\n    ///         permits that effectively never expire.\\n    function permit(\\n        address owner,\\n        address spender,\\n        uint256 amount,\\n        uint256 deadline,\\n        uint8 v,\\n        bytes32 r,\\n        bytes32 s\\n    ) external;\\n\\n    /// @notice Destroys `amount` tokens from the caller.\\n    function burn(uint256 amount) external;\\n\\n    /// @notice Destroys `amount` of tokens from `account`, deducting the amount\\n    ///         from caller's allowance.\\n    function burnFrom(address account, uint256 amount) external;\\n\\n    /// @notice Returns hash of EIP712 Domain struct with the token name as\\n    ///         a signing domain and token contract as a verifying contract.\\n    ///         Used to construct EIP2612 signature provided to `permit`\\n    ///         function.\\n    /* solhint-disable-next-line func-name-mixedcase */\\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\\n\\n    /// @notice Returns the current nonce for EIP2612 permission for the\\n    ///         provided token owner for a replay protection. Used to construct\\n    ///         EIP2612 signature provided to `permit` function.\\n    function nonce(address owner) external view returns (uint256);\\n\\n    /// @notice Returns EIP2612 Permit message hash. Used to construct EIP2612\\n    ///         signature provided to `permit` function.\\n    /* solhint-disable-next-line func-name-mixedcase */\\n    function PERMIT_TYPEHASH() external pure returns (bytes32);\\n}\\n\",\"keccak256\":\"0xdac9a5086c19a7128b505a7be1ab0ac1aa314f6989cb88d2417e9d7383f89fa9\",\"license\":\"MIT\"},\"@thesis/solidity-contracts/contracts/token/IReceiveApproval.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.4;\\n\\n/// @notice An interface that should be implemented by contracts supporting\\n///         `approveAndCall`/`receiveApproval` pattern.\\ninterface IReceiveApproval {\\n    /// @notice Receives approval to spend tokens. Called as a result of\\n    ///         `approveAndCall` call on the token.\\n    function receiveApproval(\\n        address from,\\n        uint256 amount,\\n        address token,\\n        bytes calldata extraData\\n    ) external;\\n}\\n\",\"keccak256\":\"0x6a30d83ad230548b1e7839737affc8489a035314209de14b89dbef7fb0f66395\",\"license\":\"MIT\"},\"contracts/l2/L2TBTC.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0-only\\n\\n// \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588     \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c     \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\n// \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588     \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c     \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n// \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588     \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c     \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\n// \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588     \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c     \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n\\npragma solidity ^0.8.17;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/draft-ERC20PermitUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20BurnableUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\\\";\\n\\n/// @title L2TBTC\\n/// @notice Canonical L2/sidechain token implementation. tBTC token is minted on\\n///         L1 and locked there to be moved to L2/sidechain. By deploying\\n///         a canonical token on each L2/sidechain, we can ensure the supply of\\n///         tBTC remains sacrosanct, while enabling quick, interoperable\\n///         cross-chain bridges and localizing ecosystem risk.\\n///\\n///         This contract is flexible enough to:\\n///         - Delegate minting authority to a native bridge on the chain, if\\n///           present.\\n///         - Delegate minting authority to a short list of ecosystem bridges.\\n///         - Have mints and burns paused by any one of n guardians, allowing\\n///           avoidance of contagion in case of a chain- or bridge-specific\\n///           incident.\\n///         - Be governed and upgradeable.\\n///\\n///         The token is burnable by the token holder and supports EIP2612\\n///         permits. Token holder can authorize a transfer of their token with\\n///         a signature conforming EIP712 standard instead of an on-chain\\n///         transaction from their address. Anyone can submit this signature on\\n///         the user's behalf by calling the permit function, paying gas fees,\\n///         and possibly performing other actions in the same transaction.\\n///         The governance can recover ERC20 and ERC721 tokens sent mistakenly\\n///         to L2TBTC token contract.\\ncontract L2TBTC is\\n    ERC20Upgradeable,\\n    ERC20BurnableUpgradeable,\\n    ERC20PermitUpgradeable,\\n    OwnableUpgradeable,\\n    PausableUpgradeable\\n{\\n    using SafeERC20Upgradeable for IERC20Upgradeable;\\n\\n    /// @notice Indicates if the given address is a minter. Only minters can\\n    ///         mint the token.\\n    mapping(address => bool) public isMinter;\\n\\n    /// @notice List of all minters.\\n    address[] public minters;\\n\\n    /// @notice Indicates if the given address is a guardian. Only guardians can\\n    ///         pause token mints and burns.\\n    mapping(address => bool) public isGuardian;\\n\\n    /// @notice List of all guardians.\\n    address[] public guardians;\\n\\n    event MinterAdded(address indexed minter);\\n    event MinterRemoved(address indexed minter);\\n\\n    event GuardianAdded(address indexed guardian);\\n    event GuardianRemoved(address indexed guardian);\\n\\n    modifier onlyMinter() {\\n        require(isMinter[msg.sender], \\\"Caller is not a minter\\\");\\n        _;\\n    }\\n\\n    modifier onlyGuardian() {\\n        require(isGuardian[msg.sender], \\\"Caller is not a guardian\\\");\\n        _;\\n    }\\n\\n    /// @notice Initializes the token contract.\\n    /// @param _name The name of the token.\\n    /// @param _symbol The symbol of the token, usually a shorter version of the\\n    ///        name.\\n    function initialize(string memory _name, string memory _symbol)\\n        external\\n        initializer\\n    {\\n        // OpenZeppelin upgradeable contracts documentation says:\\n        //\\n        // \\\"Use with multiple inheritance requires special care. Initializer\\n        // functions are not linearized by the compiler like constructors.\\n        // Because of this, each __{ContractName}_init function embeds the\\n        // linearized calls to all parent initializers. As a consequence,\\n        // calling two of these init functions can potentially initialize the\\n        // same contract twice.\\\"\\n        //\\n        // Note that ERC20 extensions do not linearize calls to ERC20Upgradeable\\n        // initializer so we call all extension initializers individually. At\\n        // the same time, ERC20PermitUpgradeable does linearize the call to\\n        // EIP712Upgradeable so we are not using the unchained initializer\\n        // versions.\\n        __ERC20_init(_name, _symbol);\\n        __ERC20Burnable_init();\\n        __ERC20Permit_init(_name);\\n        __Ownable_init();\\n        __Pausable_init();\\n    }\\n\\n    /// @notice Adds the address to the minters list.\\n    /// @dev Requirements:\\n    ///      - The caller must be the contract owner.\\n    ///      - `minter` must not be a minter address already.\\n    /// @param minter The address to be added as a minter.\\n    function addMinter(address minter) external onlyOwner {\\n        require(!isMinter[minter], \\\"This address is already a minter\\\");\\n        isMinter[minter] = true;\\n        minters.push(minter);\\n        emit MinterAdded(minter);\\n    }\\n\\n    /// @notice Removes the address from the minters list.\\n    /// @dev Requirements:\\n    ///      - The caller must be the contract owner.\\n    ///      - `minter` must be a minter address.\\n    /// @param minter The address to be removed from the minters list.\\n    function removeMinter(address minter) external onlyOwner {\\n        require(isMinter[minter], \\\"This address is not a minter\\\");\\n        delete isMinter[minter];\\n\\n        // We do not expect too many minters so a simple loop is safe.\\n        for (uint256 i = 0; i < minters.length; i++) {\\n            if (minters[i] == minter) {\\n                minters[i] = minters[minters.length - 1];\\n                // slither-disable-next-line costly-loop\\n                minters.pop();\\n                break;\\n            }\\n        }\\n\\n        emit MinterRemoved(minter);\\n    }\\n\\n    /// @notice Adds the address to the guardians list.\\n    /// @dev Requirements:\\n    ///      - The caller must be the contract owner.\\n    ///      - `guardian` must not be a guardian address already.\\n    /// @param guardian The address to be added as a guardian.\\n    function addGuardian(address guardian) external onlyOwner {\\n        require(!isGuardian[guardian], \\\"This address is already a guardian\\\");\\n        isGuardian[guardian] = true;\\n        guardians.push(guardian);\\n        emit GuardianAdded(guardian);\\n    }\\n\\n    /// @notice Removes the address from the guardians list.\\n    /// @dev Requirements:\\n    ///      - The caller must be the contract owner.\\n    ///      - `guardian` must be a guardian address.\\n    /// @param guardian The address to be removed from the guardians list.\\n    function removeGuardian(address guardian) external onlyOwner {\\n        require(isGuardian[guardian], \\\"This address is not a guardian\\\");\\n        delete isGuardian[guardian];\\n\\n        // We do not expect too many guardians so a simple loop is safe.\\n        for (uint256 i = 0; i < guardians.length; i++) {\\n            if (guardians[i] == guardian) {\\n                guardians[i] = guardians[guardians.length - 1];\\n                // slither-disable-next-line costly-loop\\n                guardians.pop();\\n                break;\\n            }\\n        }\\n\\n        emit GuardianRemoved(guardian);\\n    }\\n\\n    /// @notice Allows the governance of the token contract to recover any ERC20\\n    ///         sent mistakenly to the token contract address.\\n    /// @param token The address of the token to be recovered.\\n    /// @param recipient The token recipient address that will receive recovered\\n    ///        tokens.\\n    /// @param amount The amount to be recovered.\\n    function recoverERC20(\\n        IERC20Upgradeable token,\\n        address recipient,\\n        uint256 amount\\n    ) external onlyOwner {\\n        token.safeTransfer(recipient, amount);\\n    }\\n\\n    /// @notice Allows the governance of the token contract to recover any\\n    ///         ERC721 sent mistakenly to the token contract address.\\n    /// @param token The address of the token to be recovered.\\n    /// @param recipient The token recipient address that will receive the\\n    ///        recovered token.\\n    /// @param tokenId The ID of the ERC721 token to be recovered.\\n    function recoverERC721(\\n        IERC721Upgradeable token,\\n        address recipient,\\n        uint256 tokenId,\\n        bytes calldata data\\n    ) external onlyOwner {\\n        token.safeTransferFrom(address(this), recipient, tokenId, data);\\n    }\\n\\n    /// @notice Allows one of the guardians to pause mints and burns allowing\\n    ///         avoidance of contagion in case of a chain- or bridge-specific\\n    ///         incident.\\n    /// @dev Requirements:\\n    ///      - The caller must be a guardian.\\n    ///      - The contract must not be already paused.\\n    function pause() external onlyGuardian {\\n        _pause();\\n    }\\n\\n    /// @notice Allows the governance to unpause mints and burns previously\\n    ///         paused by one of the guardians.\\n    /// @dev Requirements:\\n    ///      - The caller must be the contract owner.\\n    ///      - The contract must be paused.\\n    function unpause() external onlyOwner {\\n        _unpause();\\n    }\\n\\n    /// @notice Allows one of the minters to mint `amount` tokens and assign\\n    ///         them to `account`, increasing the total supply. Emits\\n    ///         a `Transfer` event with `from` set to the zero address.\\n    /// @dev Requirements:\\n    ///      - The caller must be a minter.\\n    ///      - `account` must not be the zero address.\\n    /// @param account The address to receive tokens.\\n    /// @param amount The amount of token to be minted.\\n    function mint(address account, uint256 amount)\\n        external\\n        whenNotPaused\\n        onlyMinter\\n    {\\n        _mint(account, amount);\\n    }\\n\\n    /// @notice Destroys `amount` tokens from the caller. Emits a `Transfer`\\n    ///         event with `to` set to the zero address.\\n    /// @dev Requirements:\\n    ///      - The caller must have at least `amount` tokens.\\n    /// @param amount The amount of token to be burned.\\n    function burn(uint256 amount) public override whenNotPaused {\\n        super.burn(amount);\\n    }\\n\\n    /// @notice Destroys `amount` tokens from `account`, deducting from the\\n    ///         caller's allowance. Emits a `Transfer` event with `to` set to\\n    ///         the zero address.\\n    /// @dev Requirements:\\n    ///      - The che caller must have allowance for `accounts`'s tokens of at\\n    ///        least `amount`.\\n    ///      - `account` must not be the zero address.\\n    ///      - `account` must have at least `amount` tokens.\\n    /// @param account The address owning tokens to be burned.\\n    /// @param amount The amount of token to be burned.\\n    function burnFrom(address account, uint256 amount)\\n        public\\n        override\\n        whenNotPaused\\n    {\\n        super.burnFrom(account, amount);\\n    }\\n\\n    /// @notice Allows to fetch a list of all minters.\\n    function getMinters() external view returns (address[] memory) {\\n        return minters;\\n    }\\n\\n    /// @notice Allows to fetch a list of all guardians.\\n    function getGuardians() external view returns (address[] memory) {\\n        return guardians;\\n    }\\n}\\n\",\"keccak256\":\"0x0ad24408cfce03caefa5f9c95b664f75867670b39016c059a28618e0e822ac85\",\"license\":\"GPL-3.0-only\"},\"contracts/l2/L2WormholeGateway.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0-only\\n\\n// \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588     \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c     \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\n// \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588     \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c     \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n// \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588     \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c     \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\n// \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588     \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c     \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n\\npragma solidity ^0.8.17;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\\\";\\n\\nimport \\\"./L2TBTC.sol\\\";\\n\\n/// @title IWormholeTokenBridge\\n/// @notice Wormhole Token Bridge interface. Contains only selected functions\\n///         used by L2WormholeGateway.\\ninterface IWormholeTokenBridge {\\n    function completeTransferWithPayload(bytes memory encodedVm)\\n        external\\n        returns (bytes memory);\\n\\n    function parseTransferWithPayload(bytes memory encoded)\\n        external\\n        pure\\n        returns (TransferWithPayload memory transfer);\\n\\n    function transferTokens(\\n        address token,\\n        uint256 amount,\\n        uint16 recipientChain,\\n        bytes32 recipient,\\n        uint256 arbiterFee,\\n        uint32 nonce\\n    ) external payable returns (uint64 sequence);\\n\\n    function transferTokensWithPayload(\\n        address token,\\n        uint256 amount,\\n        uint16 recipientChain,\\n        bytes32 recipient,\\n        uint32 nonce,\\n        bytes memory payload\\n    ) external payable returns (uint64 sequence);\\n\\n    struct TransferWithPayload {\\n        uint8 payloadID;\\n        uint256 amount;\\n        bytes32 tokenAddress;\\n        uint16 tokenChain;\\n        bytes32 to;\\n        uint16 toChain;\\n        bytes32 fromAddress;\\n        bytes payload;\\n    }\\n}\\n\\n/// @title L2WormholeGateway\\n/// @notice Selected cross-ecosystem bridges are given the minting authority for\\n///         tBTC token on L2 and sidechains. This contract gives a minting\\n///         authority to the Wormhole Bridge.\\n///\\n///         The process of bridging from L1 to L2 (or sidechain) looks as\\n///         follows:\\n///         1. There is a tBTC holder on L1. The holder goes to the Wormhole\\n///            Portal and selects the chain they want to bridge to.\\n///         2. The holder submits one transaction to L1 locking their tBTC\\n///            tokens in the bridge\\u2019s smart contract. After the transaction is\\n///            mined, they wait about 15 minutes for the Ethereum block\\n///            finality.\\n///         3. The holder submits one transaction to L2 that is minting tokens.\\n///            After that transaction is mined, they have their tBTC on L2.\\n///\\n///         The process of bridging from L2 (or sidechain) to L1 looks as\\n///         follows:\\n///         1. There is a tBTC holder on L2. That holder goes to the Wormhole\\n///            Portal and selects one of the L2 chains they want to bridge from.\\n///         2. The holder submits one transaction to L2 that is burning the\\n///            token. After the transaction is mined, they wait about 15 minutes\\n///            for the L2 block finality.\\n///         3. The holder submits one transaction to L1 unlocking their tBTC\\n///            tokens from the bridge\\u2019s smart contract. After that transaction\\n///            is mined, they have their tBTC on L1.\\n///\\n///         This smart contract is integrated with step 3 of L1->L2 bridging and\\n///         step 1 of L2->L1 or L2->L2 bridging. When the user redeems token on\\n///         L2, this contract receives the Wormhole tBTC representation and\\n///         mints the canonical tBTC in an equal amount. When user sends their\\n///         token from L1, this contract burns the canonical tBTC and sends\\n///         Wormhole tBTC representation through the bridge in an equal amount.\\n/// @dev This contract is supposed to be deployed behind a transparent\\n///      upgradeable proxy.\\ncontract L2WormholeGateway is\\n    Initializable,\\n    OwnableUpgradeable,\\n    ReentrancyGuardUpgradeable\\n{\\n    using SafeERC20Upgradeable for IERC20Upgradeable;\\n\\n    /// @notice Reference to the Wormhole Token Bridge contract.\\n    IWormholeTokenBridge public bridge;\\n\\n    /// @notice Wormhole tBTC token representation.\\n    IERC20Upgradeable public bridgeToken;\\n\\n    /// @notice Canonical tBTC token.\\n    L2TBTC public tbtc;\\n\\n    /// @notice Maps Wormhole chain ID to the Wormhole tBTC gateway address on\\n    ///         that chain. For example, this chain's ID should be mapped to\\n    ///         this contract's address. If there is no Wormhole tBTC gateway\\n    ///         address on the given chain, there is no entry in this mapping.\\n    ///         The mapping holds addresses in a Wormhole-specific format, where\\n    ///         Ethereum address is left-padded with zeros.\\n    mapping(uint16 => bytes32) public gateways;\\n\\n    /// @notice Minting limit for this gateway. Useful for early days of testing\\n    ///         the system. The gateway can not mint more canonical tBTC than\\n    ///         this limit.\\n    uint256 public mintingLimit;\\n\\n    /// @notice The amount of tBTC minted by this contract. tBTC burned by this\\n    ///         contract decreases this amount.\\n    uint256 public mintedAmount;\\n\\n    event WormholeTbtcReceived(address receiver, uint256 amount);\\n\\n    event WormholeTbtcSent(\\n        uint256 amount,\\n        uint16 recipientChain,\\n        bytes32 gateway,\\n        bytes32 recipient,\\n        uint256 arbiterFee,\\n        uint32 nonce\\n    );\\n\\n    event WormholeTbtcDeposited(address depositor, uint256 amount);\\n\\n    event GatewayAddressUpdated(uint16 chainId, bytes32 gateway);\\n\\n    event MintingLimitUpdated(uint256 mintingLimit);\\n\\n    function initialize(\\n        IWormholeTokenBridge _bridge,\\n        IERC20Upgradeable _bridgeToken,\\n        L2TBTC _tbtc\\n    ) external initializer {\\n        __Ownable_init();\\n        __ReentrancyGuard_init();\\n\\n        require(\\n            address(_bridge) != address(0),\\n            \\\"Wormhole bridge address must not be 0x0\\\"\\n        );\\n        require(\\n            address(_bridgeToken) != address(0),\\n            \\\"Bridge token address must not be 0x0\\\"\\n        );\\n        require(\\n            address(_tbtc) != address(0),\\n            \\\"L2TBTC token address must not be 0x0\\\"\\n        );\\n\\n        bridge = _bridge;\\n        bridgeToken = _bridgeToken;\\n        tbtc = _tbtc;\\n        mintingLimit = type(uint256).max;\\n    }\\n\\n    /// @notice This function is called when the user sends their token from L2.\\n    ///         The contract burns the canonical tBTC from the user and sends\\n    ///         wormhole tBTC representation over the bridge.\\n    ///         Keep in mind that when multiple bridges receive a minting\\n    ///         authority on the canonical tBTC, this function may not be able\\n    ///         to send all amounts of tBTC through the Wormhole bridge. The\\n    ///         capability of Wormhole Bridge to send tBTC from the chain is\\n    ///         limited to the amount of tBTC bridged through Wormhole to that\\n    ///         chain.\\n    /// @dev Requirements:\\n    ///      - The sender must have at least `amount` of the canonical tBTC and\\n    ///        it has to be approved for L2WormholeGateway.\\n    ///      - The L2WormholeGateway must have at least `amount` of the wormhole\\n    ///        tBTC.\\n    ///      - The recipient must not be 0x0.\\n    ///      - The amount to transfer must not be 0,\\n    ///      - The amount to transfer must be >= 10^10 (1e18 precision).\\n    ///      Depending if Wormhole tBTC gateway is registered on the target\\n    ///      chain, this function uses transfer or transfer with payload over\\n    ///      the Wormhole bridge.\\n    /// @param amount The amount of tBTC to be sent.\\n    /// @param recipientChain The Wormhole recipient chain ID.\\n    /// @param recipient The address of the recipient in the Wormhole format.\\n    /// @param arbiterFee The Wormhole arbiter fee. Ignored if sending\\n    ///                   tBTC to chain with Wormhole tBTC gateway.\\n    /// @param nonce The Wormhole nonce used to batch messages together.\\n    /// @return The Wormhole sequence number.\\n    function sendTbtc(\\n        uint256 amount,\\n        uint16 recipientChain,\\n        bytes32 recipient,\\n        uint256 arbiterFee,\\n        uint32 nonce\\n    ) external payable nonReentrant returns (uint64) {\\n        require(recipient != bytes32(0), \\\"0x0 recipient not allowed\\\");\\n        require(amount != 0, \\\"Amount must not be 0\\\");\\n\\n        // Normalize the amount to bridge. The dust can not be bridged due to\\n        // the decimal shift in the Wormhole Bridge contract.\\n        amount = normalize(amount);\\n\\n        // Check again after dropping the dust.\\n        require(amount != 0, \\\"Amount too low to bridge\\\");\\n\\n        require(\\n            bridgeToken.balanceOf(address(this)) >= amount,\\n            \\\"Not enough wormhole tBTC in the gateway to bridge\\\"\\n        );\\n\\n        bytes32 gateway = gateways[recipientChain];\\n\\n        emit WormholeTbtcSent(\\n            amount,\\n            recipientChain,\\n            gateway,\\n            recipient,\\n            arbiterFee,\\n            nonce\\n        );\\n\\n        mintedAmount -= amount;\\n        tbtc.burnFrom(msg.sender, amount);\\n        bridgeToken.safeApprove(address(bridge), amount);\\n\\n        if (gateway == bytes32(0)) {\\n            // No Wormhole tBTC gateway on the target chain. The token minted\\n            // by Wormhole should be considered canonical.\\n            return\\n                bridge.transferTokens{value: msg.value}(\\n                    address(bridgeToken),\\n                    amount,\\n                    recipientChain,\\n                    recipient,\\n                    arbiterFee,\\n                    nonce\\n                );\\n        } else {\\n            // There is a Wormhole tBTC gateway on the target chain.\\n            // The gateway needs to mint canonical tBTC for the recipient\\n            // encoded in the payload.\\n            return\\n                bridge.transferTokensWithPayload{value: msg.value}(\\n                    address(bridgeToken),\\n                    amount,\\n                    recipientChain,\\n                    gateway,\\n                    nonce,\\n                    abi.encode(recipient)\\n                );\\n        }\\n    }\\n\\n    /// @notice This function is called when the user redeems their token on L2.\\n    ///         The contract receives Wormhole tBTC representation and mints the\\n    ///         canonical tBTC for the user.\\n    ///         If the tBTC minting limit has been reached by this contract,\\n    ///         instead of minting tBTC the receiver address receives Wormhole\\n    ///         tBTC representation.\\n    /// @dev Requirements:\\n    ///      - The receiver of Wormhole tBTC should be the L2WormholeGateway\\n    ///        contract.\\n    ///      - The receiver of the canonical tBTC should be abi-encoded in the\\n    ///        payload.\\n    ///      - The receiver of the canonical tBTC must not be the zero address.\\n    ///      The Wormhole Token Bridge contract has protection against redeeming\\n    ///      the same VAA again. When a Token Bridge VAA is redeemed, its\\n    ///      message body hash is stored in a map. This map is used to check\\n    ///      whether the hash has already been set in this map. For this reason,\\n    ///      this function does not have to be nonReentrant.\\n    /// @param encodedVm A byte array containing a Wormhole VAA signed by the\\n    ///        guardians.\\n    function receiveTbtc(bytes calldata encodedVm) external {\\n        // ITokenBridge.completeTransferWithPayload completes a contract-controlled\\n        // transfer of an ERC20 token. Calling this function is not enough to\\n        // ensure L2WormholeGateway received Wormhole tBTC representation.\\n        // Instead of going too deep into the ITokenBridge implementation,\\n        // asserting who is the receiver of the token, and which token it is,\\n        // we check the balance before the ITokenBridge call and the balance\\n        // after ITokenBridge call. This way, we are sure this contract received\\n        // Wormhole tBTC token in the given amount. This is transparent to\\n        // all potential upgrades of ITokenBridge implementation and no other\\n        // validations are needed.\\n        uint256 balanceBefore = bridgeToken.balanceOf(address(this));\\n        bytes memory encoded = bridge.completeTransferWithPayload(encodedVm);\\n        uint256 balanceAfter = bridgeToken.balanceOf(address(this));\\n\\n        uint256 amount = balanceAfter - balanceBefore;\\n        // Protect against the custody of irrelevant tokens.\\n        require(amount > 0, \\\"No tBTC transferred\\\");\\n\\n        address receiver = fromWormholeAddress(\\n            bytes32(bridge.parseTransferWithPayload(encoded).payload)\\n        );\\n        require(receiver != address(0), \\\"0x0 receiver not allowed\\\");\\n\\n        // We send wormhole tBTC OR mint canonical tBTC. We do not want to send\\n        // dust. Sending wormhole tBTC is an exceptional situation and we want\\n        // to keep it simple.\\n        if (mintedAmount + amount > mintingLimit) {\\n            bridgeToken.safeTransfer(receiver, amount);\\n        } else {\\n            // The function is non-reentrant given bridge.completeTransferWithPayload\\n            // call that does not allow to use the same VAA again.\\n            // slither-disable-next-line reentrancy-benign\\n            mintedAmount += amount;\\n            tbtc.mint(receiver, amount);\\n        }\\n\\n        // The function is non-reentrant given bridge.completeTransferWithPayload\\n        // call that does not allow to use the same VAA again.\\n        // slither-disable-next-line reentrancy-events\\n        emit WormholeTbtcReceived(receiver, amount);\\n    }\\n\\n    /// @notice Allows to deposit Wormhole tBTC token in exchange for canonical\\n    ///         tBTC. Useful in a situation when user received wormhole tBTC\\n    ///         instead of canonical tBTC. One example of such situation is\\n    ///         when the minting limit was exceeded but the user minted anyway.\\n    /// @dev Requirements:\\n    ///      - The sender must have at least `amount` of the Wormhole tBTC and\\n    ///        it has to be approved for L2WormholeGateway.\\n    ///      - The minting limit must allow for minting the given amount.\\n    /// @param amount The amount of Wormhole tBTC to deposit.\\n    function depositWormholeTbtc(uint256 amount) external {\\n        require(\\n            mintedAmount + amount <= mintingLimit,\\n            \\\"Minting limit exceeded\\\"\\n        );\\n\\n        emit WormholeTbtcDeposited(msg.sender, amount);\\n        mintedAmount += amount;\\n        bridgeToken.safeTransferFrom(msg.sender, address(this), amount);\\n        tbtc.mint(msg.sender, amount);\\n    }\\n\\n    /// @notice Lets the governance to update the tBTC gateway address on the\\n    ///         chain with the given Wormhole ID.\\n    /// @dev Use toWormholeAddress function to convert between Ethereum and\\n    ///      Wormhole address formats.\\n    /// @param chainId Wormhole ID of the chain.\\n    /// @param gateway Address of tBTC gateway on the given chain in a Wormhole\\n    ///                format.\\n    function updateGatewayAddress(uint16 chainId, bytes32 gateway)\\n        external\\n        onlyOwner\\n    {\\n        gateways[chainId] = gateway;\\n        emit GatewayAddressUpdated(chainId, gateway);\\n    }\\n\\n    /// @notice Lets the governance to update the tBTC minting limit for this\\n    ///         contract.\\n    /// @param _mintingLimit The new minting limit.\\n    function updateMintingLimit(uint256 _mintingLimit) external onlyOwner {\\n        mintingLimit = _mintingLimit;\\n        emit MintingLimitUpdated(_mintingLimit);\\n    }\\n\\n    /// @notice Converts Ethereum address into Wormhole format.\\n    /// @param _address The address to convert.\\n    function toWormholeAddress(address _address)\\n        external\\n        pure\\n        returns (bytes32)\\n    {\\n        return bytes32(uint256(uint160(_address)));\\n    }\\n\\n    /// @notice Converts Wormhole address into Ethereum format.\\n    /// @param _address The address to convert.\\n    function fromWormholeAddress(bytes32 _address)\\n        public\\n        pure\\n        returns (address)\\n    {\\n        return address(uint160(uint256(_address)));\\n    }\\n\\n    /// @dev Eliminates the dust that cannot be bridged with Wormhole\\n    ///      due to the decimal shift in the Wormhole Bridge contract.\\n    ///      See https://github.com/wormhole-foundation/wormhole/blob/96682bdbeb7c87bfa110eade0554b3d8cbf788d2/ethereum/contracts/bridge/Bridge.sol#L276-L288\\n    function normalize(uint256 amount) internal pure returns (uint256) {\\n        // slither-disable-next-line divide-before-multiply\\n        amount /= 10**10;\\n        amount *= 10**10;\\n        return amount;\\n    }\\n}\\n\",\"keccak256\":\"0xc7ce2f1c39eb11c3b03159884cb18a54f6eb6391da0f1aa59ae4668e52dda179\",\"license\":\"GPL-3.0-only\"},\"contracts/test/TestERC20.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0-only\\n\\npragma solidity 0.8.17;\\n\\nimport \\\"@thesis/solidity-contracts/contracts/token/ERC20WithPermit.sol\\\";\\n\\ncontract TestERC20 is ERC20WithPermit {\\n    string public constant NAME = \\\"Test ERC20 Token\\\";\\n    string public constant SYMBOL = \\\"TT\\\";\\n\\n    constructor() ERC20WithPermit(NAME, SYMBOL) {}\\n}\\n\",\"keccak256\":\"0x05d5b0a7d4ad010e9c29cfeaff77f727dc3d714e4915e0dae22497dd890051b4\",\"license\":\"GPL-3.0-only\"},\"contracts/test/WormholeBridgeStub.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0-only\\n\\npragma solidity 0.8.17;\\n\\nimport \\\"./TestERC20.sol\\\";\\nimport \\\"../l2/L2WormholeGateway.sol\\\";\\n\\n/// @dev Stub contract used in L2WormholeGateway unit tests.\\n///      Stub contract is used instead of a smock because of the token transfer\\n///      that needs to happen in completeTransferWithPayload function.\\ncontract WormholeBridgeStub is IWormholeTokenBridge {\\n    TestERC20 public wormholeToken;\\n\\n    uint256 public transferAmount;\\n    bytes32 public receiverAddress;\\n\\n    // Two simple events allowing to assert Wormhole bridge functions are\\n    // called.\\n    event WormholeBridgeStub_completeTransferWithPayload(bytes encodedVm);\\n    event WormholeBridgeStub_transferTokens(\\n        address token,\\n        uint256 amount,\\n        uint16 recipientChain,\\n        bytes32 recipient,\\n        uint256 arbiterFee,\\n        uint32 nonce\\n    );\\n    event WormholeBridgeStub_transferTokensWithPayload(\\n        address token,\\n        uint256 amount,\\n        uint16 recipientChain,\\n        bytes32 recipient,\\n        uint32 nonce,\\n        bytes payload\\n    );\\n\\n    constructor(TestERC20 _wormholeToken) {\\n        wormholeToken = _wormholeToken;\\n    }\\n\\n    function completeTransferWithPayload(bytes memory encodedVm)\\n        external\\n        returns (bytes memory)\\n    {\\n        emit WormholeBridgeStub_completeTransferWithPayload(encodedVm);\\n        wormholeToken.mint(msg.sender, transferAmount);\\n\\n        // In a real implementation, encodedVm is parsed. To avoid copy-pasting\\n        // Wormhole code to this contract and then encoding parmaters in unit\\n        // tests, we allow to set the receiver address on the stub contract and\\n        // we return it here. The rest of the parameters does not matter.\\n        IWormholeTokenBridge.TransferWithPayload memory transfer = IWormholeTokenBridge\\n            .TransferWithPayload(\\n                1, // payloadID\\n                2, // amount\\n                0x3000000000000000000000000000000000000000000000000000000000000000, // tokenAddress\\n                4, // tokenChain\\n                0x5000000000000000000000000000000000000000000000000000000000000000, // to\\n                6, // toChain\\n                0x7000000000000000000000000000000000000000000000000000000000000000, // fromAddress\\n                abi.encode(receiverAddress) // payload\\n            );\\n\\n        return abi.encode(transfer);\\n    }\\n\\n    function transferTokens(\\n        address token,\\n        uint256 amount,\\n        uint16 recipientChain,\\n        bytes32 recipient,\\n        uint256 arbiterFee,\\n        uint32 nonce\\n    ) external payable returns (uint64 sequence) {\\n        emit WormholeBridgeStub_transferTokens(\\n            token,\\n            amount,\\n            recipientChain,\\n            recipient,\\n            arbiterFee,\\n            nonce\\n        );\\n        return 777;\\n    }\\n\\n    function transferTokensWithPayload(\\n        address token,\\n        uint256 amount,\\n        uint16 recipientChain,\\n        bytes32 recipient,\\n        uint32 nonce,\\n        bytes memory payload\\n    ) external payable returns (uint64 sequence) {\\n        emit WormholeBridgeStub_transferTokensWithPayload(\\n            token,\\n            amount,\\n            recipientChain,\\n            recipient,\\n            nonce,\\n            payload\\n        );\\n        return 888;\\n    }\\n\\n    function parseTransferWithPayload(bytes memory encoded)\\n        external\\n        pure\\n        returns (IWormholeTokenBridge.TransferWithPayload memory transfer)\\n    {\\n        return abi.decode(encoded, (IWormholeTokenBridge.TransferWithPayload));\\n    }\\n\\n    function setTransferAmount(uint256 _transferAmount) external {\\n        transferAmount = _transferAmount;\\n    }\\n\\n    function setReceiverAddress(bytes32 _receiverAddress) external {\\n        receiverAddress = _receiverAddress;\\n    }\\n\\n    // Allows to mint Wormhole tBTC for depositWormholeTbtc unit tests.\\n    function mintWormholeToken(address to, uint256 amount) external {\\n        wormholeToken.mint(to, amount);\\n    }\\n}\\n\",\"keccak256\":\"0xa040fbc4b5f912f8fcc01b9ec467bac64753657875dea39dfd3fd147e3674b3a\",\"license\":\"GPL-3.0-only\"}},\"version\":1}",
+  "metadata": "{\"compiler\":{\"version\":\"0.8.17+commit.8df45f5f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"contract TestERC20\",\"name\":\"_wormholeToken\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"encodedVm\",\"type\":\"bytes\"}],\"name\":\"WormholeBridgeStub_completeTransferWithPayload\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint16\",\"name\":\"recipientChain\",\"type\":\"uint16\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"recipient\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"arbiterFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"nonce\",\"type\":\"uint32\"}],\"name\":\"WormholeBridgeStub_transferTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint16\",\"name\":\"recipientChain\",\"type\":\"uint16\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"recipient\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"nonce\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"WormholeBridgeStub_transferTokensWithPayload\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"encodedVm\",\"type\":\"bytes\"}],\"name\":\"completeTransferWithPayload\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"mintWormholeToken\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"encoded\",\"type\":\"bytes\"}],\"name\":\"parseTransferWithPayload\",\"outputs\":[{\"components\":[{\"internalType\":\"uint8\",\"name\":\"payloadID\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"tokenAddress\",\"type\":\"bytes32\"},{\"internalType\":\"uint16\",\"name\":\"tokenChain\",\"type\":\"uint16\"},{\"internalType\":\"bytes32\",\"name\":\"to\",\"type\":\"bytes32\"},{\"internalType\":\"uint16\",\"name\":\"toChain\",\"type\":\"uint16\"},{\"internalType\":\"bytes32\",\"name\":\"fromAddress\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"internalType\":\"struct IWormholeTokenBridge.TransferWithPayload\",\"name\":\"transfer\",\"type\":\"tuple\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"receiverAddress\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"_receiverAddress\",\"type\":\"bytes32\"}],\"name\":\"setReceiverAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_transferAmount\",\"type\":\"uint256\"}],\"name\":\"setTransferAmount\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"transferAmount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint16\",\"name\":\"recipientChain\",\"type\":\"uint16\"},{\"internalType\":\"bytes32\",\"name\":\"recipient\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"arbiterFee\",\"type\":\"uint256\"},{\"internalType\":\"uint32\",\"name\":\"nonce\",\"type\":\"uint32\"}],\"name\":\"transferTokens\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"sequence\",\"type\":\"uint64\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint16\",\"name\":\"recipientChain\",\"type\":\"uint16\"},{\"internalType\":\"bytes32\",\"name\":\"recipient\",\"type\":\"bytes32\"},{\"internalType\":\"uint32\",\"name\":\"nonce\",\"type\":\"uint32\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"transferTokensWithPayload\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"sequence\",\"type\":\"uint64\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"wormholeToken\",\"outputs\":[{\"internalType\":\"contract TestERC20\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"Stub contract used in L2WormholeGateway unit tests.      Stub contract is used instead of a smock because of the token transfer      that needs to happen in completeTransferWithPayload function.\",\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/test/WormholeBridgeStub.sol\":\"WormholeBridgeStub\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\\n    address private _owner;\\n\\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n    /**\\n     * @dev Initializes the contract setting the deployer as the initial owner.\\n     */\\n    function __Ownable_init() internal onlyInitializing {\\n        __Ownable_init_unchained();\\n    }\\n\\n    function __Ownable_init_unchained() internal onlyInitializing {\\n        _transferOwnership(_msgSender());\\n    }\\n\\n    /**\\n     * @dev Throws if called by any account other than the owner.\\n     */\\n    modifier onlyOwner() {\\n        _checkOwner();\\n        _;\\n    }\\n\\n    /**\\n     * @dev Returns the address of the current owner.\\n     */\\n    function owner() public view virtual returns (address) {\\n        return _owner;\\n    }\\n\\n    /**\\n     * @dev Throws if the sender is not the owner.\\n     */\\n    function _checkOwner() internal view virtual {\\n        require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n    }\\n\\n    /**\\n     * @dev Leaves the contract without owner. It will not be possible to call\\n     * `onlyOwner` functions anymore. Can only be called by the current owner.\\n     *\\n     * NOTE: Renouncing ownership will leave the contract without an owner,\\n     * thereby removing any functionality that is only available to the owner.\\n     */\\n    function renounceOwnership() public virtual onlyOwner {\\n        _transferOwnership(address(0));\\n    }\\n\\n    /**\\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n     * Can only be called by the current owner.\\n     */\\n    function transferOwnership(address newOwner) public virtual onlyOwner {\\n        require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n        _transferOwnership(newOwner);\\n    }\\n\\n    /**\\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n     * Internal function without access restriction.\\n     */\\n    function _transferOwnership(address newOwner) internal virtual {\\n        address oldOwner = _owner;\\n        _owner = newOwner;\\n        emit OwnershipTransferred(oldOwner, newOwner);\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x247c62047745915c0af6b955470a72d1696ebad4352d7d3011aef1a2463cd888\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.1) (proxy/utils/Initializable.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\\n * reused. This mechanism prevents re-execution of each \\\"step\\\" but allows the creation of new initialization steps in\\n * case an upgrade adds a module that needs to be initialized.\\n *\\n * For example:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * contract MyToken is ERC20Upgradeable {\\n *     function initialize() initializer public {\\n *         __ERC20_init(\\\"MyToken\\\", \\\"MTK\\\");\\n *     }\\n * }\\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\\n *     function initializeV2() reinitializer(2) public {\\n *         __ERC20Permit_init(\\\"MyToken\\\");\\n *     }\\n * }\\n * ```\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n *\\n * [CAUTION]\\n * ====\\n * Avoid leaving a contract uninitialized.\\n *\\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * /// @custom:oz-upgrades-unsafe-allow constructor\\n * constructor() {\\n *     _disableInitializers();\\n * }\\n * ```\\n * ====\\n */\\nabstract contract Initializable {\\n    /**\\n     * @dev Indicates that the contract has been initialized.\\n     * @custom:oz-retyped-from bool\\n     */\\n    uint8 private _initialized;\\n\\n    /**\\n     * @dev Indicates that the contract is in the process of being initialized.\\n     */\\n    bool private _initializing;\\n\\n    /**\\n     * @dev Triggered when the contract has been initialized or reinitialized.\\n     */\\n    event Initialized(uint8 version);\\n\\n    /**\\n     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\\n     * `onlyInitializing` functions can be used to initialize parent contracts.\\n     *\\n     * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a\\n     * constructor.\\n     *\\n     * Emits an {Initialized} event.\\n     */\\n    modifier initializer() {\\n        bool isTopLevelCall = !_initializing;\\n        require(\\n            (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\\n            \\\"Initializable: contract is already initialized\\\"\\n        );\\n        _initialized = 1;\\n        if (isTopLevelCall) {\\n            _initializing = true;\\n        }\\n        _;\\n        if (isTopLevelCall) {\\n            _initializing = false;\\n            emit Initialized(1);\\n        }\\n    }\\n\\n    /**\\n     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\\n     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\\n     * used to initialize parent contracts.\\n     *\\n     * A reinitializer may be used after the original initialization step. This is essential to configure modules that\\n     * are added through upgrades and that require initialization.\\n     *\\n     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\\n     * cannot be nested. If one is invoked in the context of another, execution will revert.\\n     *\\n     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\\n     * a contract, executing them in the right order is up to the developer or operator.\\n     *\\n     * WARNING: setting the version to 255 will prevent any future reinitialization.\\n     *\\n     * Emits an {Initialized} event.\\n     */\\n    modifier reinitializer(uint8 version) {\\n        require(!_initializing && _initialized < version, \\\"Initializable: contract is already initialized\\\");\\n        _initialized = version;\\n        _initializing = true;\\n        _;\\n        _initializing = false;\\n        emit Initialized(version);\\n    }\\n\\n    /**\\n     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\\n     * {initializer} and {reinitializer} modifiers, directly or indirectly.\\n     */\\n    modifier onlyInitializing() {\\n        require(_initializing, \\\"Initializable: contract is not initializing\\\");\\n        _;\\n    }\\n\\n    /**\\n     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\\n     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\\n     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\\n     * through proxies.\\n     *\\n     * Emits an {Initialized} event the first time it is successfully executed.\\n     */\\n    function _disableInitializers() internal virtual {\\n        require(!_initializing, \\\"Initializable: contract is initializing\\\");\\n        if (_initialized < type(uint8).max) {\\n            _initialized = type(uint8).max;\\n            emit Initialized(type(uint8).max);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the highest version that has been initialized. See {reinitializer}.\\n     */\\n    function _getInitializedVersion() internal view returns (uint8) {\\n        return _initialized;\\n    }\\n\\n    /**\\n     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\\n     */\\n    function _isInitializing() internal view returns (bool) {\\n        return _initializing;\\n    }\\n}\\n\",\"keccak256\":\"0x037c334add4b033ad3493038c25be1682d78c00992e1acb0e2795caff3925271\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which allows children to implement an emergency stop\\n * mechanism that can be triggered by an authorized account.\\n *\\n * This module is used through inheritance. It will make available the\\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\\n * the functions of your contract. Note that they will not be pausable by\\n * simply including this module, only once the modifiers are put in place.\\n */\\nabstract contract PausableUpgradeable is Initializable, ContextUpgradeable {\\n    /**\\n     * @dev Emitted when the pause is triggered by `account`.\\n     */\\n    event Paused(address account);\\n\\n    /**\\n     * @dev Emitted when the pause is lifted by `account`.\\n     */\\n    event Unpaused(address account);\\n\\n    bool private _paused;\\n\\n    /**\\n     * @dev Initializes the contract in unpaused state.\\n     */\\n    function __Pausable_init() internal onlyInitializing {\\n        __Pausable_init_unchained();\\n    }\\n\\n    function __Pausable_init_unchained() internal onlyInitializing {\\n        _paused = false;\\n    }\\n\\n    /**\\n     * @dev Modifier to make a function callable only when the contract is not paused.\\n     *\\n     * Requirements:\\n     *\\n     * - The contract must not be paused.\\n     */\\n    modifier whenNotPaused() {\\n        _requireNotPaused();\\n        _;\\n    }\\n\\n    /**\\n     * @dev Modifier to make a function callable only when the contract is paused.\\n     *\\n     * Requirements:\\n     *\\n     * - The contract must be paused.\\n     */\\n    modifier whenPaused() {\\n        _requirePaused();\\n        _;\\n    }\\n\\n    /**\\n     * @dev Returns true if the contract is paused, and false otherwise.\\n     */\\n    function paused() public view virtual returns (bool) {\\n        return _paused;\\n    }\\n\\n    /**\\n     * @dev Throws if the contract is paused.\\n     */\\n    function _requireNotPaused() internal view virtual {\\n        require(!paused(), \\\"Pausable: paused\\\");\\n    }\\n\\n    /**\\n     * @dev Throws if the contract is not paused.\\n     */\\n    function _requirePaused() internal view virtual {\\n        require(paused(), \\\"Pausable: not paused\\\");\\n    }\\n\\n    /**\\n     * @dev Triggers stopped state.\\n     *\\n     * Requirements:\\n     *\\n     * - The contract must not be paused.\\n     */\\n    function _pause() internal virtual whenNotPaused {\\n        _paused = true;\\n        emit Paused(_msgSender());\\n    }\\n\\n    /**\\n     * @dev Returns to normal state.\\n     *\\n     * Requirements:\\n     *\\n     * - The contract must be paused.\\n     */\\n    function _unpause() internal virtual whenPaused {\\n        _paused = false;\\n        emit Unpaused(_msgSender());\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x40c636b4572ff5f1dc50cf22097e93c0723ee14eff87e99ac2b02636eeca1250\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol)\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ReentrancyGuardUpgradeable is Initializable {\\n    // Booleans are more expensive than uint256 or any type that takes up a full\\n    // word because each write operation emits an extra SLOAD to first read the\\n    // slot's contents, replace the bits taken up by the boolean, and then write\\n    // back. This is the compiler's defense against contract upgrades and\\n    // pointer aliasing, and it cannot be disabled.\\n\\n    // The values being non-zero value makes deployment a bit more expensive,\\n    // but in exchange the refund on every call to nonReentrant will be lower in\\n    // amount. Since refunds are capped to a percentage of the total\\n    // transaction's gas, it is best to keep them low in cases like this one, to\\n    // increase the likelihood of the full refund coming into effect.\\n    uint256 private constant _NOT_ENTERED = 1;\\n    uint256 private constant _ENTERED = 2;\\n\\n    uint256 private _status;\\n\\n    function __ReentrancyGuard_init() internal onlyInitializing {\\n        __ReentrancyGuard_init_unchained();\\n    }\\n\\n    function __ReentrancyGuard_init_unchained() internal onlyInitializing {\\n        _status = _NOT_ENTERED;\\n    }\\n\\n    /**\\n     * @dev Prevents a contract from calling itself, directly or indirectly.\\n     * Calling a `nonReentrant` function from another `nonReentrant`\\n     * function is not supported. It is possible to prevent this from happening\\n     * by making the `nonReentrant` function external, and making it call a\\n     * `private` function that does the actual work.\\n     */\\n    modifier nonReentrant() {\\n        _nonReentrantBefore();\\n        _;\\n        _nonReentrantAfter();\\n    }\\n\\n    function _nonReentrantBefore() private {\\n        // On the first call to nonReentrant, _status will be _NOT_ENTERED\\n        require(_status != _ENTERED, \\\"ReentrancyGuard: reentrant call\\\");\\n\\n        // Any calls to nonReentrant after this point will fail\\n        _status = _ENTERED;\\n    }\\n\\n    function _nonReentrantAfter() private {\\n        // By storing the original value once again, a refund is triggered (see\\n        // https://eips.ethereum.org/EIPS/eip-2200)\\n        _status = _NOT_ENTERED;\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x2b3005a0064cfc558bdf64b2bae94b565f4574a536aadd61c13838d4f2157790\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/ERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\\n * instead returning `false` on failure. This behavior is nonetheless\\n * conventional and does not conflict with the expectations of ERC20\\n * applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n    mapping(address => uint256) private _balances;\\n\\n    mapping(address => mapping(address => uint256)) private _allowances;\\n\\n    uint256 private _totalSupply;\\n\\n    string private _name;\\n    string private _symbol;\\n\\n    /**\\n     * @dev Sets the values for {name} and {symbol}.\\n     *\\n     * The default value of {decimals} is 18. To select a different value for\\n     * {decimals} you should overload it.\\n     *\\n     * All two of these values are immutable: they can only be set once during\\n     * construction.\\n     */\\n    function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {\\n        __ERC20_init_unchained(name_, symbol_);\\n    }\\n\\n    function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {\\n        _name = name_;\\n        _symbol = symbol_;\\n    }\\n\\n    /**\\n     * @dev Returns the name of the token.\\n     */\\n    function name() public view virtual override returns (string memory) {\\n        return _name;\\n    }\\n\\n    /**\\n     * @dev Returns the symbol of the token, usually a shorter version of the\\n     * name.\\n     */\\n    function symbol() public view virtual override returns (string memory) {\\n        return _symbol;\\n    }\\n\\n    /**\\n     * @dev Returns the number of decimals used to get its user representation.\\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n     * be displayed to a user as `5.05` (`505 / 10 ** 2`).\\n     *\\n     * Tokens usually opt for a value of 18, imitating the relationship between\\n     * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n     * overridden;\\n     *\\n     * NOTE: This information is only used for _display_ purposes: it in\\n     * no way affects any of the arithmetic of the contract, including\\n     * {IERC20-balanceOf} and {IERC20-transfer}.\\n     */\\n    function decimals() public view virtual override returns (uint8) {\\n        return 18;\\n    }\\n\\n    /**\\n     * @dev See {IERC20-totalSupply}.\\n     */\\n    function totalSupply() public view virtual override returns (uint256) {\\n        return _totalSupply;\\n    }\\n\\n    /**\\n     * @dev See {IERC20-balanceOf}.\\n     */\\n    function balanceOf(address account) public view virtual override returns (uint256) {\\n        return _balances[account];\\n    }\\n\\n    /**\\n     * @dev See {IERC20-transfer}.\\n     *\\n     * Requirements:\\n     *\\n     * - `to` cannot be the zero address.\\n     * - the caller must have a balance of at least `amount`.\\n     */\\n    function transfer(address to, uint256 amount) public virtual override returns (bool) {\\n        address owner = _msgSender();\\n        _transfer(owner, to, amount);\\n        return true;\\n    }\\n\\n    /**\\n     * @dev See {IERC20-allowance}.\\n     */\\n    function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n        return _allowances[owner][spender];\\n    }\\n\\n    /**\\n     * @dev See {IERC20-approve}.\\n     *\\n     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\\n     * `transferFrom`. This is semantically equivalent to an infinite approval.\\n     *\\n     * Requirements:\\n     *\\n     * - `spender` cannot be the zero address.\\n     */\\n    function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n        address owner = _msgSender();\\n        _approve(owner, spender, amount);\\n        return true;\\n    }\\n\\n    /**\\n     * @dev See {IERC20-transferFrom}.\\n     *\\n     * Emits an {Approval} event indicating the updated allowance. This is not\\n     * required by the EIP. See the note at the beginning of {ERC20}.\\n     *\\n     * NOTE: Does not update the allowance if the current allowance\\n     * is the maximum `uint256`.\\n     *\\n     * Requirements:\\n     *\\n     * - `from` and `to` cannot be the zero address.\\n     * - `from` must have a balance of at least `amount`.\\n     * - the caller must have allowance for ``from``'s tokens of at least\\n     * `amount`.\\n     */\\n    function transferFrom(\\n        address from,\\n        address to,\\n        uint256 amount\\n    ) public virtual override returns (bool) {\\n        address spender = _msgSender();\\n        _spendAllowance(from, spender, amount);\\n        _transfer(from, to, amount);\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Atomically increases the allowance granted to `spender` by the caller.\\n     *\\n     * This is an alternative to {approve} that can be used as a mitigation for\\n     * problems described in {IERC20-approve}.\\n     *\\n     * Emits an {Approval} event indicating the updated allowance.\\n     *\\n     * Requirements:\\n     *\\n     * - `spender` cannot be the zero address.\\n     */\\n    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n        address owner = _msgSender();\\n        _approve(owner, spender, allowance(owner, spender) + addedValue);\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n     *\\n     * This is an alternative to {approve} that can be used as a mitigation for\\n     * problems described in {IERC20-approve}.\\n     *\\n     * Emits an {Approval} event indicating the updated allowance.\\n     *\\n     * Requirements:\\n     *\\n     * - `spender` cannot be the zero address.\\n     * - `spender` must have allowance for the caller of at least\\n     * `subtractedValue`.\\n     */\\n    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n        address owner = _msgSender();\\n        uint256 currentAllowance = allowance(owner, spender);\\n        require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n        unchecked {\\n            _approve(owner, spender, currentAllowance - subtractedValue);\\n        }\\n\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Moves `amount` of tokens from `from` to `to`.\\n     *\\n     * This internal function is equivalent to {transfer}, and can be used to\\n     * e.g. implement automatic token fees, slashing mechanisms, etc.\\n     *\\n     * Emits a {Transfer} event.\\n     *\\n     * Requirements:\\n     *\\n     * - `from` cannot be the zero address.\\n     * - `to` cannot be the zero address.\\n     * - `from` must have a balance of at least `amount`.\\n     */\\n    function _transfer(\\n        address from,\\n        address to,\\n        uint256 amount\\n    ) internal virtual {\\n        require(from != address(0), \\\"ERC20: transfer from the zero address\\\");\\n        require(to != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n        _beforeTokenTransfer(from, to, amount);\\n\\n        uint256 fromBalance = _balances[from];\\n        require(fromBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n        unchecked {\\n            _balances[from] = fromBalance - amount;\\n            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\\n            // decrementing then incrementing.\\n            _balances[to] += amount;\\n        }\\n\\n        emit Transfer(from, to, amount);\\n\\n        _afterTokenTransfer(from, to, amount);\\n    }\\n\\n    /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n     * the total supply.\\n     *\\n     * Emits a {Transfer} event with `from` set to the zero address.\\n     *\\n     * Requirements:\\n     *\\n     * - `account` cannot be the zero address.\\n     */\\n    function _mint(address account, uint256 amount) internal virtual {\\n        require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n        _beforeTokenTransfer(address(0), account, amount);\\n\\n        _totalSupply += amount;\\n        unchecked {\\n            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\\n            _balances[account] += amount;\\n        }\\n        emit Transfer(address(0), account, amount);\\n\\n        _afterTokenTransfer(address(0), account, amount);\\n    }\\n\\n    /**\\n     * @dev Destroys `amount` tokens from `account`, reducing the\\n     * total supply.\\n     *\\n     * Emits a {Transfer} event with `to` set to the zero address.\\n     *\\n     * Requirements:\\n     *\\n     * - `account` cannot be the zero address.\\n     * - `account` must have at least `amount` tokens.\\n     */\\n    function _burn(address account, uint256 amount) internal virtual {\\n        require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n        _beforeTokenTransfer(account, address(0), amount);\\n\\n        uint256 accountBalance = _balances[account];\\n        require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n        unchecked {\\n            _balances[account] = accountBalance - amount;\\n            // Overflow not possible: amount <= accountBalance <= totalSupply.\\n            _totalSupply -= amount;\\n        }\\n\\n        emit Transfer(account, address(0), amount);\\n\\n        _afterTokenTransfer(account, address(0), amount);\\n    }\\n\\n    /**\\n     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n     *\\n     * This internal function is equivalent to `approve`, and can be used to\\n     * e.g. set automatic allowances for certain subsystems, etc.\\n     *\\n     * Emits an {Approval} event.\\n     *\\n     * Requirements:\\n     *\\n     * - `owner` cannot be the zero address.\\n     * - `spender` cannot be the zero address.\\n     */\\n    function _approve(\\n        address owner,\\n        address spender,\\n        uint256 amount\\n    ) internal virtual {\\n        require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n        require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n        _allowances[owner][spender] = amount;\\n        emit Approval(owner, spender, amount);\\n    }\\n\\n    /**\\n     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.\\n     *\\n     * Does not update the allowance amount in case of infinite allowance.\\n     * Revert if not enough allowance is available.\\n     *\\n     * Might emit an {Approval} event.\\n     */\\n    function _spendAllowance(\\n        address owner,\\n        address spender,\\n        uint256 amount\\n    ) internal virtual {\\n        uint256 currentAllowance = allowance(owner, spender);\\n        if (currentAllowance != type(uint256).max) {\\n            require(currentAllowance >= amount, \\\"ERC20: insufficient allowance\\\");\\n            unchecked {\\n                _approve(owner, spender, currentAllowance - amount);\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Hook that is called before any transfer of tokens. This includes\\n     * minting and burning.\\n     *\\n     * Calling conditions:\\n     *\\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n     * will be transferred to `to`.\\n     * - when `from` is zero, `amount` tokens will be minted for `to`.\\n     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n     * - `from` and `to` are never both zero.\\n     *\\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n     */\\n    function _beforeTokenTransfer(\\n        address from,\\n        address to,\\n        uint256 amount\\n    ) internal virtual {}\\n\\n    /**\\n     * @dev Hook that is called after any transfer of tokens. This includes\\n     * minting and burning.\\n     *\\n     * Calling conditions:\\n     *\\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n     * has been transferred to `to`.\\n     * - when `from` is zero, `amount` tokens have been minted for `to`.\\n     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\\n     * - `from` and `to` are never both zero.\\n     *\\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n     */\\n    function _afterTokenTransfer(\\n        address from,\\n        address to,\\n        uint256 amount\\n    ) internal virtual {}\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0xb1d9e69cf8073efa574b31b1f840e20709139c19bfb27e60b16393d6073f3d42\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the amount of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the amount of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves `amount` tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 amount) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 amount) external returns (bool);\\n\\n    /**\\n     * @dev Moves `amount` tokens from `from` to `to` using the\\n     * allowance mechanism. `amount` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(\\n        address from,\\n        address to,\\n        uint256 amount\\n    ) external returns (bool);\\n}\\n\",\"keccak256\":\"0x4e733d3164f73f461eaf9d8087a7ad1ea180bdc8ba0d3d61b0e1ae16d8e63dff\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20BurnableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Burnable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../ERC20Upgradeable.sol\\\";\\nimport \\\"../../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Extension of {ERC20} that allows token holders to destroy both their own\\n * tokens and those that they have an allowance for, in a way that can be\\n * recognized off-chain (via event analysis).\\n */\\nabstract contract ERC20BurnableUpgradeable is Initializable, ContextUpgradeable, ERC20Upgradeable {\\n    function __ERC20Burnable_init() internal onlyInitializing {\\n    }\\n\\n    function __ERC20Burnable_init_unchained() internal onlyInitializing {\\n    }\\n    /**\\n     * @dev Destroys `amount` tokens from the caller.\\n     *\\n     * See {ERC20-_burn}.\\n     */\\n    function burn(uint256 amount) public virtual {\\n        _burn(_msgSender(), amount);\\n    }\\n\\n    /**\\n     * @dev Destroys `amount` tokens from `account`, deducting from the caller's\\n     * allowance.\\n     *\\n     * See {ERC20-_burn} and {ERC20-allowance}.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must have allowance for ``accounts``'s tokens of at least\\n     * `amount`.\\n     */\\n    function burnFrom(address account, uint256 amount) public virtual {\\n        _spendAllowance(account, _msgSender(), amount);\\n        _burn(account, amount);\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0xea2c6f9d434127bf36b1e3e5ebaaf6d28a64dbaeea560508e570014e905a5ad2\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\n    /**\\n     * @dev Returns the name of the token.\\n     */\\n    function name() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the symbol of the token.\\n     */\\n    function symbol() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the decimals places of the token.\\n     */\\n    function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x605434219ebbe4653f703640f06969faa5a1d78f0bfef878e5ddbb1ca369ceeb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/draft-ERC20PermitUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/extensions/draft-ERC20Permit.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./draft-IERC20PermitUpgradeable.sol\\\";\\nimport \\\"../ERC20Upgradeable.sol\\\";\\nimport \\\"../../../utils/cryptography/ECDSAUpgradeable.sol\\\";\\nimport \\\"../../../utils/cryptography/EIP712Upgradeable.sol\\\";\\nimport \\\"../../../utils/CountersUpgradeable.sol\\\";\\nimport \\\"../../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't\\n * need to send a transaction, and thus is not required to hold Ether at all.\\n *\\n * _Available since v3.4._\\n *\\n * @custom:storage-size 51\\n */\\nabstract contract ERC20PermitUpgradeable is Initializable, ERC20Upgradeable, IERC20PermitUpgradeable, EIP712Upgradeable {\\n    using CountersUpgradeable for CountersUpgradeable.Counter;\\n\\n    mapping(address => CountersUpgradeable.Counter) private _nonces;\\n\\n    // solhint-disable-next-line var-name-mixedcase\\n    bytes32 private constant _PERMIT_TYPEHASH =\\n        keccak256(\\\"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\\\");\\n    /**\\n     * @dev In previous versions `_PERMIT_TYPEHASH` was declared as `immutable`.\\n     * However, to ensure consistency with the upgradeable transpiler, we will continue\\n     * to reserve a slot.\\n     * @custom:oz-renamed-from _PERMIT_TYPEHASH\\n     */\\n    // solhint-disable-next-line var-name-mixedcase\\n    bytes32 private _PERMIT_TYPEHASH_DEPRECATED_SLOT;\\n\\n    /**\\n     * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `\\\"1\\\"`.\\n     *\\n     * It's a good idea to use the same `name` that is defined as the ERC20 token name.\\n     */\\n    function __ERC20Permit_init(string memory name) internal onlyInitializing {\\n        __EIP712_init_unchained(name, \\\"1\\\");\\n    }\\n\\n    function __ERC20Permit_init_unchained(string memory) internal onlyInitializing {}\\n\\n    /**\\n     * @dev See {IERC20Permit-permit}.\\n     */\\n    function permit(\\n        address owner,\\n        address spender,\\n        uint256 value,\\n        uint256 deadline,\\n        uint8 v,\\n        bytes32 r,\\n        bytes32 s\\n    ) public virtual override {\\n        require(block.timestamp <= deadline, \\\"ERC20Permit: expired deadline\\\");\\n\\n        bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));\\n\\n        bytes32 hash = _hashTypedDataV4(structHash);\\n\\n        address signer = ECDSAUpgradeable.recover(hash, v, r, s);\\n        require(signer == owner, \\\"ERC20Permit: invalid signature\\\");\\n\\n        _approve(owner, spender, value);\\n    }\\n\\n    /**\\n     * @dev See {IERC20Permit-nonces}.\\n     */\\n    function nonces(address owner) public view virtual override returns (uint256) {\\n        return _nonces[owner].current();\\n    }\\n\\n    /**\\n     * @dev See {IERC20Permit-DOMAIN_SEPARATOR}.\\n     */\\n    // solhint-disable-next-line func-name-mixedcase\\n    function DOMAIN_SEPARATOR() external view override returns (bytes32) {\\n        return _domainSeparatorV4();\\n    }\\n\\n    /**\\n     * @dev \\\"Consume a nonce\\\": return the current value and increment.\\n     *\\n     * _Available since v4.1._\\n     */\\n    function _useNonce(address owner) internal virtual returns (uint256 current) {\\n        CountersUpgradeable.Counter storage nonce = _nonces[owner];\\n        current = nonce.current();\\n        nonce.increment();\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0xfe1053f3a6ee4527cde96c8152b8b1dbb98774639a64e819087bc80e618d7f7f\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/draft-IERC20PermitUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\\n * need to send a transaction, and thus is not required to hold Ether at all.\\n */\\ninterface IERC20PermitUpgradeable {\\n    /**\\n     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\\n     * given ``owner``'s signed approval.\\n     *\\n     * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n     * ordering also apply here.\\n     *\\n     * Emits an {Approval} event.\\n     *\\n     * Requirements:\\n     *\\n     * - `spender` cannot be the zero address.\\n     * - `deadline` must be a timestamp in the future.\\n     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n     * over the EIP712-formatted function arguments.\\n     * - the signature must use ``owner``'s current nonce (see {nonces}).\\n     *\\n     * For more information on the signature format, see the\\n     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n     * section].\\n     */\\n    function permit(\\n        address owner,\\n        address spender,\\n        uint256 value,\\n        uint256 deadline,\\n        uint8 v,\\n        bytes32 r,\\n        bytes32 s\\n    ) external;\\n\\n    /**\\n     * @dev Returns the current nonce for `owner`. This value must be\\n     * included whenever a signature is generated for {permit}.\\n     *\\n     * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n     * prevents a signature from being used multiple times.\\n     */\\n    function nonces(address owner) external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\\n     */\\n    // solhint-disable-next-line func-name-mixedcase\\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0xcc70d8e2281fb3ff69e8ab242500f10142cd0a7fa8dd9e45882be270d4d09024\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\nimport \\\"../extensions/draft-IERC20PermitUpgradeable.sol\\\";\\nimport \\\"../../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20Upgradeable {\\n    using AddressUpgradeable for address;\\n\\n    function safeTransfer(\\n        IERC20Upgradeable token,\\n        address to,\\n        uint256 value\\n    ) internal {\\n        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n    }\\n\\n    function safeTransferFrom(\\n        IERC20Upgradeable token,\\n        address from,\\n        address to,\\n        uint256 value\\n    ) internal {\\n        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n    }\\n\\n    /**\\n     * @dev Deprecated. This function has issues similar to the ones found in\\n     * {IERC20-approve}, and its usage is discouraged.\\n     *\\n     * Whenever possible, use {safeIncreaseAllowance} and\\n     * {safeDecreaseAllowance} instead.\\n     */\\n    function safeApprove(\\n        IERC20Upgradeable token,\\n        address spender,\\n        uint256 value\\n    ) internal {\\n        // safeApprove should only be called when setting an initial allowance,\\n        // or when resetting it to zero. To increase and decrease it, use\\n        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n        require(\\n            (value == 0) || (token.allowance(address(this), spender) == 0),\\n            \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n        );\\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n    }\\n\\n    function safeIncreaseAllowance(\\n        IERC20Upgradeable token,\\n        address spender,\\n        uint256 value\\n    ) internal {\\n        uint256 newAllowance = token.allowance(address(this), spender) + value;\\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n    }\\n\\n    function safeDecreaseAllowance(\\n        IERC20Upgradeable token,\\n        address spender,\\n        uint256 value\\n    ) internal {\\n        unchecked {\\n            uint256 oldAllowance = token.allowance(address(this), spender);\\n            require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n            uint256 newAllowance = oldAllowance - value;\\n            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n        }\\n    }\\n\\n    function safePermit(\\n        IERC20PermitUpgradeable token,\\n        address owner,\\n        address spender,\\n        uint256 value,\\n        uint256 deadline,\\n        uint8 v,\\n        bytes32 r,\\n        bytes32 s\\n    ) internal {\\n        uint256 nonceBefore = token.nonces(owner);\\n        token.permit(owner, spender, value, deadline, v, r, s);\\n        uint256 nonceAfter = token.nonces(owner);\\n        require(nonceAfter == nonceBefore + 1, \\\"SafeERC20: permit did not succeed\\\");\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     */\\n    function _callOptionalReturn(IERC20Upgradeable token, bytes memory data) private {\\n        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\\n        // the target address contains contract code and also asserts for success in the low-level call.\\n\\n        bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n        if (returndata.length > 0) {\\n            // Return data is optional\\n            require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x220c4a5af915e656be2aaa85ca57505d102418e476b1e2ef6c62e0c6ac143871\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n    /**\\n     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n    /**\\n     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n     */\\n    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n    /**\\n     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n     */\\n    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n    /**\\n     * @dev Returns the number of tokens in ``owner``'s account.\\n     */\\n    function balanceOf(address owner) external view returns (uint256 balance);\\n\\n    /**\\n     * @dev Returns the owner of the `tokenId` token.\\n     *\\n     * Requirements:\\n     *\\n     * - `tokenId` must exist.\\n     */\\n    function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n    /**\\n     * @dev Safely transfers `tokenId` token from `from` to `to`.\\n     *\\n     * Requirements:\\n     *\\n     * - `from` cannot be the zero address.\\n     * - `to` cannot be the zero address.\\n     * - `tokenId` token must exist and be owned by `from`.\\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function safeTransferFrom(\\n        address from,\\n        address to,\\n        uint256 tokenId,\\n        bytes calldata data\\n    ) external;\\n\\n    /**\\n     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n     * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n     *\\n     * Requirements:\\n     *\\n     * - `from` cannot be the zero address.\\n     * - `to` cannot be the zero address.\\n     * - `tokenId` token must exist and be owned by `from`.\\n     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function safeTransferFrom(\\n        address from,\\n        address to,\\n        uint256 tokenId\\n    ) external;\\n\\n    /**\\n     * @dev Transfers `tokenId` token from `from` to `to`.\\n     *\\n     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721\\n     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must\\n     * understand this adds an external call which potentially creates a reentrancy vulnerability.\\n     *\\n     * Requirements:\\n     *\\n     * - `from` cannot be the zero address.\\n     * - `to` cannot be the zero address.\\n     * - `tokenId` token must be owned by `from`.\\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(\\n        address from,\\n        address to,\\n        uint256 tokenId\\n    ) external;\\n\\n    /**\\n     * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n     * The approval is cleared when the token is transferred.\\n     *\\n     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n     *\\n     * Requirements:\\n     *\\n     * - The caller must own the token or be an approved operator.\\n     * - `tokenId` must exist.\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address to, uint256 tokenId) external;\\n\\n    /**\\n     * @dev Approve or remove `operator` as an operator for the caller.\\n     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n     *\\n     * Requirements:\\n     *\\n     * - The `operator` cannot be the caller.\\n     *\\n     * Emits an {ApprovalForAll} event.\\n     */\\n    function setApprovalForAll(address operator, bool _approved) external;\\n\\n    /**\\n     * @dev Returns the account approved for `tokenId` token.\\n     *\\n     * Requirements:\\n     *\\n     * - `tokenId` must exist.\\n     */\\n    function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n    /**\\n     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n     *\\n     * See {setApprovalForAll}\\n     */\\n    function isApprovedForAll(address owner, address operator) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x2c0b89cef83f353c6f9488c013d8a5968587ffdd6dfc26aad53774214b97e229\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n    /**\\n     * @dev Returns true if `account` is a contract.\\n     *\\n     * [IMPORTANT]\\n     * ====\\n     * It is unsafe to assume that an address for which this function returns\\n     * false is an externally-owned account (EOA) and not a contract.\\n     *\\n     * Among others, `isContract` will return false for the following\\n     * types of addresses:\\n     *\\n     *  - an externally-owned account\\n     *  - a contract in construction\\n     *  - an address where a contract will be created\\n     *  - an address where a contract lived, but was destroyed\\n     * ====\\n     *\\n     * [IMPORTANT]\\n     * ====\\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n     *\\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n     * constructor.\\n     * ====\\n     */\\n    function isContract(address account) internal view returns (bool) {\\n        // This method relies on extcodesize/address.code.length, which returns 0\\n        // for contracts in construction, since the code is only stored at the end\\n        // of the constructor execution.\\n\\n        return account.code.length > 0;\\n    }\\n\\n    /**\\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n     * `recipient`, forwarding all available gas and reverting on errors.\\n     *\\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n     * imposed by `transfer`, making them unable to receive funds via\\n     * `transfer`. {sendValue} removes this limitation.\\n     *\\n     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n     *\\n     * IMPORTANT: because control is transferred to `recipient`, care must be\\n     * taken to not create reentrancy vulnerabilities. Consider using\\n     * {ReentrancyGuard} or the\\n     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n     */\\n    function sendValue(address payable recipient, uint256 amount) internal {\\n        require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n        (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n        require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n    }\\n\\n    /**\\n     * @dev Performs a Solidity function call using a low level `call`. A\\n     * plain `call` is an unsafe replacement for a function call: use this\\n     * function instead.\\n     *\\n     * If `target` reverts with a revert reason, it is bubbled up by this\\n     * function (like regular Solidity function calls).\\n     *\\n     * Returns the raw returned data. To convert to the expected return value,\\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n     *\\n     * Requirements:\\n     *\\n     * - `target` must be a contract.\\n     * - calling `target` with `data` must not revert.\\n     *\\n     * _Available since v3.1._\\n     */\\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n        return functionCallWithValue(target, data, 0, \\\"Address: low-level call failed\\\");\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n     * `errorMessage` as a fallback revert reason when `target` reverts.\\n     *\\n     * _Available since v3.1._\\n     */\\n    function functionCall(\\n        address target,\\n        bytes memory data,\\n        string memory errorMessage\\n    ) internal returns (bytes memory) {\\n        return functionCallWithValue(target, data, 0, errorMessage);\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n     * but also transferring `value` wei to `target`.\\n     *\\n     * Requirements:\\n     *\\n     * - the calling contract must have an ETH balance of at least `value`.\\n     * - the called Solidity function must be `payable`.\\n     *\\n     * _Available since v3.1._\\n     */\\n    function functionCallWithValue(\\n        address target,\\n        bytes memory data,\\n        uint256 value\\n    ) internal returns (bytes memory) {\\n        return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\\n     *\\n     * _Available since v3.1._\\n     */\\n    function functionCallWithValue(\\n        address target,\\n        bytes memory data,\\n        uint256 value,\\n        string memory errorMessage\\n    ) internal returns (bytes memory) {\\n        require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n     * but performing a static call.\\n     *\\n     * _Available since v3.3._\\n     */\\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n        return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n     * but performing a static call.\\n     *\\n     * _Available since v3.3._\\n     */\\n    function functionStaticCall(\\n        address target,\\n        bytes memory data,\\n        string memory errorMessage\\n    ) internal view returns (bytes memory) {\\n        (bool success, bytes memory returndata) = target.staticcall(data);\\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n    }\\n\\n    /**\\n     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\\n     *\\n     * _Available since v4.8._\\n     */\\n    function verifyCallResultFromTarget(\\n        address target,\\n        bool success,\\n        bytes memory returndata,\\n        string memory errorMessage\\n    ) internal view returns (bytes memory) {\\n        if (success) {\\n            if (returndata.length == 0) {\\n                // only check isContract if the call was successful and the return data is empty\\n                // otherwise we already know that it was a contract\\n                require(isContract(target), \\\"Address: call to non-contract\\\");\\n            }\\n            return returndata;\\n        } else {\\n            _revert(returndata, errorMessage);\\n        }\\n    }\\n\\n    /**\\n     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\\n     * revert reason or using the provided one.\\n     *\\n     * _Available since v4.3._\\n     */\\n    function verifyCallResult(\\n        bool success,\\n        bytes memory returndata,\\n        string memory errorMessage\\n    ) internal pure returns (bytes memory) {\\n        if (success) {\\n            return returndata;\\n        } else {\\n            _revert(returndata, errorMessage);\\n        }\\n    }\\n\\n    function _revert(bytes memory returndata, string memory errorMessage) private pure {\\n        // Look for revert reason and bubble it up if present\\n        if (returndata.length > 0) {\\n            // The easiest way to bubble the revert reason is using memory via assembly\\n            /// @solidity memory-safe-assembly\\n            assembly {\\n                let returndata_size := mload(returndata)\\n                revert(add(32, returndata), returndata_size)\\n            }\\n        } else {\\n            revert(errorMessage);\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x2edcb41c121abc510932e8d83ff8b82cf9cdde35e7c297622f5c29ef0af25183\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n    function __Context_init() internal onlyInitializing {\\n    }\\n\\n    function __Context_init_unchained() internal onlyInitializing {\\n    }\\n    function _msgSender() internal view virtual returns (address) {\\n        return msg.sender;\\n    }\\n\\n    function _msgData() internal view virtual returns (bytes calldata) {\\n        return msg.data;\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x963ea7f0b48b032eef72fe3a7582edf78408d6f834115b9feadd673a4d5bd149\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/Counters.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary CountersUpgradeable {\\n    struct Counter {\\n        // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n        // this feature: see https://github.com/ethereum/solidity/issues/4637\\n        uint256 _value; // default: 0\\n    }\\n\\n    function current(Counter storage counter) internal view returns (uint256) {\\n        return counter._value;\\n    }\\n\\n    function increment(Counter storage counter) internal {\\n        unchecked {\\n            counter._value += 1;\\n        }\\n    }\\n\\n    function decrement(Counter storage counter) internal {\\n        uint256 value = counter._value;\\n        require(value > 0, \\\"Counter: decrement overflow\\\");\\n        unchecked {\\n            counter._value = value - 1;\\n        }\\n    }\\n\\n    function reset(Counter storage counter) internal {\\n        counter._value = 0;\\n    }\\n}\\n\",\"keccak256\":\"0x798741e231b22b81e2dd2eddaaf8832dee4baf5cd8e2dbaa5c1dd12a1c053c4d\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./math/MathUpgradeable.sol\\\";\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n    bytes16 private constant _SYMBOLS = \\\"0123456789abcdef\\\";\\n    uint8 private constant _ADDRESS_LENGTH = 20;\\n\\n    /**\\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n     */\\n    function toString(uint256 value) internal pure returns (string memory) {\\n        unchecked {\\n            uint256 length = MathUpgradeable.log10(value) + 1;\\n            string memory buffer = new string(length);\\n            uint256 ptr;\\n            /// @solidity memory-safe-assembly\\n            assembly {\\n                ptr := add(buffer, add(32, length))\\n            }\\n            while (true) {\\n                ptr--;\\n                /// @solidity memory-safe-assembly\\n                assembly {\\n                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\\n                }\\n                value /= 10;\\n                if (value == 0) break;\\n            }\\n            return buffer;\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n     */\\n    function toHexString(uint256 value) internal pure returns (string memory) {\\n        unchecked {\\n            return toHexString(value, MathUpgradeable.log256(value) + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n     */\\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n        bytes memory buffer = new bytes(2 * length + 2);\\n        buffer[0] = \\\"0\\\";\\n        buffer[1] = \\\"x\\\";\\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\\n            buffer[i] = _SYMBOLS[value & 0xf];\\n            value >>= 4;\\n        }\\n        require(value == 0, \\\"Strings: hex length insufficient\\\");\\n        return string(buffer);\\n    }\\n\\n    /**\\n     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.\\n     */\\n    function toHexString(address addr) internal pure returns (string memory) {\\n        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);\\n    }\\n}\\n\",\"keccak256\":\"0x6b9a5d35b744b25529a2856a8093e7c03fb35a34b1c4fb5499e560f8ade140da\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/cryptography/ECDSAUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/ECDSA.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../StringsUpgradeable.sol\\\";\\n\\n/**\\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\\n *\\n * These functions can be used to verify that a message was signed by the holder\\n * of the private keys of a given address.\\n */\\nlibrary ECDSAUpgradeable {\\n    enum RecoverError {\\n        NoError,\\n        InvalidSignature,\\n        InvalidSignatureLength,\\n        InvalidSignatureS,\\n        InvalidSignatureV // Deprecated in v4.8\\n    }\\n\\n    function _throwError(RecoverError error) private pure {\\n        if (error == RecoverError.NoError) {\\n            return; // no error: do nothing\\n        } else if (error == RecoverError.InvalidSignature) {\\n            revert(\\\"ECDSA: invalid signature\\\");\\n        } else if (error == RecoverError.InvalidSignatureLength) {\\n            revert(\\\"ECDSA: invalid signature length\\\");\\n        } else if (error == RecoverError.InvalidSignatureS) {\\n            revert(\\\"ECDSA: invalid signature 's' value\\\");\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the address that signed a hashed message (`hash`) with\\n     * `signature` or error string. This address can then be used for verification purposes.\\n     *\\n     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n     * this function rejects them by requiring the `s` value to be in the lower\\n     * half order, and the `v` value to be either 27 or 28.\\n     *\\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n     * verification to be secure: it is possible to craft signatures that\\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n     * this is by receiving a hash of the original message (which may otherwise\\n     * be too long), and then calling {toEthSignedMessageHash} on it.\\n     *\\n     * Documentation for signature generation:\\n     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\\n     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]\\n     *\\n     * _Available since v4.3._\\n     */\\n    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {\\n        if (signature.length == 65) {\\n            bytes32 r;\\n            bytes32 s;\\n            uint8 v;\\n            // ecrecover takes the signature parameters, and the only way to get them\\n            // currently is to use assembly.\\n            /// @solidity memory-safe-assembly\\n            assembly {\\n                r := mload(add(signature, 0x20))\\n                s := mload(add(signature, 0x40))\\n                v := byte(0, mload(add(signature, 0x60)))\\n            }\\n            return tryRecover(hash, v, r, s);\\n        } else {\\n            return (address(0), RecoverError.InvalidSignatureLength);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the address that signed a hashed message (`hash`) with\\n     * `signature`. This address can then be used for verification purposes.\\n     *\\n     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n     * this function rejects them by requiring the `s` value to be in the lower\\n     * half order, and the `v` value to be either 27 or 28.\\n     *\\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n     * verification to be secure: it is possible to craft signatures that\\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n     * this is by receiving a hash of the original message (which may otherwise\\n     * be too long), and then calling {toEthSignedMessageHash} on it.\\n     */\\n    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\\n        (address recovered, RecoverError error) = tryRecover(hash, signature);\\n        _throwError(error);\\n        return recovered;\\n    }\\n\\n    /**\\n     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.\\n     *\\n     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]\\n     *\\n     * _Available since v4.3._\\n     */\\n    function tryRecover(\\n        bytes32 hash,\\n        bytes32 r,\\n        bytes32 vs\\n    ) internal pure returns (address, RecoverError) {\\n        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);\\n        uint8 v = uint8((uint256(vs) >> 255) + 27);\\n        return tryRecover(hash, v, r, s);\\n    }\\n\\n    /**\\n     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.\\n     *\\n     * _Available since v4.2._\\n     */\\n    function recover(\\n        bytes32 hash,\\n        bytes32 r,\\n        bytes32 vs\\n    ) internal pure returns (address) {\\n        (address recovered, RecoverError error) = tryRecover(hash, r, vs);\\n        _throwError(error);\\n        return recovered;\\n    }\\n\\n    /**\\n     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\\n     * `r` and `s` signature fields separately.\\n     *\\n     * _Available since v4.3._\\n     */\\n    function tryRecover(\\n        bytes32 hash,\\n        uint8 v,\\n        bytes32 r,\\n        bytes32 s\\n    ) internal pure returns (address, RecoverError) {\\n        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\\n        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\\n        // the valid range for s in (301): 0 < s < secp256k1n \\u00f7 2 + 1, and for v in (302): v \\u2208 {27, 28}. Most\\n        // signatures from current libraries generate a unique signature with an s-value in the lower half order.\\n        //\\n        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\\n        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\\n        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\\n        // these malleable signatures as well.\\n        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\\n            return (address(0), RecoverError.InvalidSignatureS);\\n        }\\n\\n        // If the signature is valid (and not malleable), return the signer address\\n        address signer = ecrecover(hash, v, r, s);\\n        if (signer == address(0)) {\\n            return (address(0), RecoverError.InvalidSignature);\\n        }\\n\\n        return (signer, RecoverError.NoError);\\n    }\\n\\n    /**\\n     * @dev Overload of {ECDSA-recover} that receives the `v`,\\n     * `r` and `s` signature fields separately.\\n     */\\n    function recover(\\n        bytes32 hash,\\n        uint8 v,\\n        bytes32 r,\\n        bytes32 s\\n    ) internal pure returns (address) {\\n        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);\\n        _throwError(error);\\n        return recovered;\\n    }\\n\\n    /**\\n     * @dev Returns an Ethereum Signed Message, created from a `hash`. This\\n     * produces hash corresponding to the one signed with the\\n     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n     * JSON-RPC method as part of EIP-191.\\n     *\\n     * See {recover}.\\n     */\\n    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {\\n        // 32 is the length in bytes of hash,\\n        // enforced by the type signature above\\n        return keccak256(abi.encodePacked(\\\"\\\\x19Ethereum Signed Message:\\\\n32\\\", hash));\\n    }\\n\\n    /**\\n     * @dev Returns an Ethereum Signed Message, created from `s`. This\\n     * produces hash corresponding to the one signed with the\\n     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n     * JSON-RPC method as part of EIP-191.\\n     *\\n     * See {recover}.\\n     */\\n    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {\\n        return keccak256(abi.encodePacked(\\\"\\\\x19Ethereum Signed Message:\\\\n\\\", StringsUpgradeable.toString(s.length), s));\\n    }\\n\\n    /**\\n     * @dev Returns an Ethereum Signed Typed Data, created from a\\n     * `domainSeparator` and a `structHash`. This produces hash corresponding\\n     * to the one signed with the\\n     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]\\n     * JSON-RPC method as part of EIP-712.\\n     *\\n     * See {recover}.\\n     */\\n    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {\\n        return keccak256(abi.encodePacked(\\\"\\\\x19\\\\x01\\\", domainSeparator, structHash));\\n    }\\n}\\n\",\"keccak256\":\"0x12f297cafe6e2847ae0378502f155654d0764b532a9873c8afe4350950fa7971\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/cryptography/EIP712Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/EIP712.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./ECDSAUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.\\n *\\n * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,\\n * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding\\n * they need in their contracts using a combination of `abi.encode` and `keccak256`.\\n *\\n * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding\\n * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA\\n * ({_hashTypedDataV4}).\\n *\\n * The implementation of the domain separator was designed to be as efficient as possible while still properly updating\\n * the chain id to protect against replay attacks on an eventual fork of the chain.\\n *\\n * NOTE: This contract implements the version of the encoding known as \\\"v4\\\", as implemented by the JSON RPC method\\n * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].\\n *\\n * _Available since v3.4._\\n *\\n * @custom:storage-size 52\\n */\\nabstract contract EIP712Upgradeable is Initializable {\\n    /* solhint-disable var-name-mixedcase */\\n    bytes32 private _HASHED_NAME;\\n    bytes32 private _HASHED_VERSION;\\n    bytes32 private constant _TYPE_HASH = keccak256(\\\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\\\");\\n\\n    /* solhint-enable var-name-mixedcase */\\n\\n    /**\\n     * @dev Initializes the domain separator and parameter caches.\\n     *\\n     * The meaning of `name` and `version` is specified in\\n     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:\\n     *\\n     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.\\n     * - `version`: the current major version of the signing domain.\\n     *\\n     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart\\n     * contract upgrade].\\n     */\\n    function __EIP712_init(string memory name, string memory version) internal onlyInitializing {\\n        __EIP712_init_unchained(name, version);\\n    }\\n\\n    function __EIP712_init_unchained(string memory name, string memory version) internal onlyInitializing {\\n        bytes32 hashedName = keccak256(bytes(name));\\n        bytes32 hashedVersion = keccak256(bytes(version));\\n        _HASHED_NAME = hashedName;\\n        _HASHED_VERSION = hashedVersion;\\n    }\\n\\n    /**\\n     * @dev Returns the domain separator for the current chain.\\n     */\\n    function _domainSeparatorV4() internal view returns (bytes32) {\\n        return _buildDomainSeparator(_TYPE_HASH, _EIP712NameHash(), _EIP712VersionHash());\\n    }\\n\\n    function _buildDomainSeparator(\\n        bytes32 typeHash,\\n        bytes32 nameHash,\\n        bytes32 versionHash\\n    ) private view returns (bytes32) {\\n        return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));\\n    }\\n\\n    /**\\n     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this\\n     * function returns the hash of the fully encoded EIP712 message for this domain.\\n     *\\n     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:\\n     *\\n     * ```solidity\\n     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(\\n     *     keccak256(\\\"Mail(address to,string contents)\\\"),\\n     *     mailTo,\\n     *     keccak256(bytes(mailContents))\\n     * )));\\n     * address signer = ECDSA.recover(digest, signature);\\n     * ```\\n     */\\n    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {\\n        return ECDSAUpgradeable.toTypedDataHash(_domainSeparatorV4(), structHash);\\n    }\\n\\n    /**\\n     * @dev The hash of the name parameter for the EIP712 domain.\\n     *\\n     * NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs\\n     * are a concern.\\n     */\\n    function _EIP712NameHash() internal virtual view returns (bytes32) {\\n        return _HASHED_NAME;\\n    }\\n\\n    /**\\n     * @dev The hash of the version parameter for the EIP712 domain.\\n     *\\n     * NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs\\n     * are a concern.\\n     */\\n    function _EIP712VersionHash() internal virtual view returns (bytes32) {\\n        return _HASHED_VERSION;\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x3017aded62c4a2b9707f5f06f92934e592c1c9b6f384b91b51340a6d5f841931\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xc6cef87559d0aeffdf0a99803de655938a7779ec0a3cd5d4383483ad85565a09\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/math/MathUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary MathUpgradeable {\\n    enum Rounding {\\n        Down, // Toward negative infinity\\n        Up, // Toward infinity\\n        Zero // Toward zero\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return a > b ? a : b;\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return a < b ? a : b;\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds up instead\\n     * of rounding down.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b - 1) / b can overflow on addition, so we distribute.\\n        return a == 0 ? 0 : (a - 1) / b + 1;\\n    }\\n\\n    /**\\n     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\\n     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\\n     * with further edits by Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(\\n        uint256 x,\\n        uint256 y,\\n        uint256 denominator\\n    ) internal pure returns (uint256 result) {\\n        unchecked {\\n            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\\n            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n            // variables such that product = prod1 * 2^256 + prod0.\\n            uint256 prod0; // Least significant 256 bits of the product\\n            uint256 prod1; // Most significant 256 bits of the product\\n            assembly {\\n                let mm := mulmod(x, y, not(0))\\n                prod0 := mul(x, y)\\n                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n            }\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (prod1 == 0) {\\n                return prod0 / denominator;\\n            }\\n\\n            // Make sure the result is less than 2^256. Also prevents denominator == 0.\\n            require(denominator > prod1);\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [prod1 prod0].\\n            uint256 remainder;\\n            assembly {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                prod1 := sub(prod1, gt(remainder, prod0))\\n                prod0 := sub(prod0, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\\n            // See https://cs.stackexchange.com/q/138556/92363.\\n\\n            // Does not overflow because the denominator cannot be zero at this stage in the function.\\n            uint256 twos = denominator & (~denominator + 1);\\n            assembly {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [prod1 prod0] by twos.\\n                prod0 := div(prod0, twos)\\n\\n                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from prod1 into prod0.\\n            prod0 |= prod1 * twos;\\n\\n            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\\n            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv = 1 mod 2^4.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\\n            // in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n            inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n            inverse *= 2 - denominator * inverse; // inverse mod 2^32\\n            inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n            inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n            inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n            // is no longer required.\\n            result = prod0 * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(\\n        uint256 x,\\n        uint256 y,\\n        uint256 denominator,\\n        Rounding rounding\\n    ) internal pure returns (uint256) {\\n        uint256 result = mulDiv(x, y, denominator);\\n        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n            result += 1;\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\\n     *\\n     * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        if (a == 0) {\\n            return 0;\\n        }\\n\\n        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\\n        //\\n        // We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\\n        //\\n        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\\n        // \\u2192 `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\\n        // \\u2192 `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\\n        //\\n        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n        uint256 result = 1 << (log2(a) >> 1);\\n\\n        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n        // into the expected uint128 result.\\n        unchecked {\\n            result = (result + a / result) >> 1;\\n            result = (result + a / result) >> 1;\\n            result = (result + a / result) >> 1;\\n            result = (result + a / result) >> 1;\\n            result = (result + a / result) >> 1;\\n            result = (result + a / result) >> 1;\\n            result = (result + a / result) >> 1;\\n            return min(result, a / result);\\n        }\\n    }\\n\\n    /**\\n     * @notice Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, rounded down, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >> 128 > 0) {\\n                value >>= 128;\\n                result += 128;\\n            }\\n            if (value >> 64 > 0) {\\n                value >>= 64;\\n                result += 64;\\n            }\\n            if (value >> 32 > 0) {\\n                value >>= 32;\\n                result += 32;\\n            }\\n            if (value >> 16 > 0) {\\n                value >>= 16;\\n                result += 16;\\n            }\\n            if (value >> 8 > 0) {\\n                value >>= 8;\\n                result += 8;\\n            }\\n            if (value >> 4 > 0) {\\n                value >>= 4;\\n                result += 4;\\n            }\\n            if (value >> 2 > 0) {\\n                value >>= 2;\\n                result += 2;\\n            }\\n            if (value >> 1 > 0) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, rounded down, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10**64) {\\n                value /= 10**64;\\n                result += 64;\\n            }\\n            if (value >= 10**32) {\\n                value /= 10**32;\\n                result += 32;\\n            }\\n            if (value >= 10**16) {\\n                value /= 10**16;\\n                result += 16;\\n            }\\n            if (value >= 10**8) {\\n                value /= 10**8;\\n                result += 8;\\n            }\\n            if (value >= 10**4) {\\n                value /= 10**4;\\n                result += 4;\\n            }\\n            if (value >= 10**2) {\\n                value /= 10**2;\\n                result += 2;\\n            }\\n            if (value >= 10**1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, rounded down, of a positive value.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >> 128 > 0) {\\n                value >>= 128;\\n                result += 16;\\n            }\\n            if (value >> 64 > 0) {\\n                value >>= 64;\\n                result += 8;\\n            }\\n            if (value >> 32 > 0) {\\n                value >>= 32;\\n                result += 4;\\n            }\\n            if (value >> 16 > 0) {\\n                value >>= 16;\\n                result += 2;\\n            }\\n            if (value >> 8 > 0) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xc1bd5b53319c68f84e3becd75694d941e8f4be94049903232cd8bc7c535aaa5a\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n    address private _owner;\\n\\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n    /**\\n     * @dev Initializes the contract setting the deployer as the initial owner.\\n     */\\n    constructor() {\\n        _transferOwnership(_msgSender());\\n    }\\n\\n    /**\\n     * @dev Throws if called by any account other than the owner.\\n     */\\n    modifier onlyOwner() {\\n        _checkOwner();\\n        _;\\n    }\\n\\n    /**\\n     * @dev Returns the address of the current owner.\\n     */\\n    function owner() public view virtual returns (address) {\\n        return _owner;\\n    }\\n\\n    /**\\n     * @dev Throws if the sender is not the owner.\\n     */\\n    function _checkOwner() internal view virtual {\\n        require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n    }\\n\\n    /**\\n     * @dev Leaves the contract without owner. It will not be possible to call\\n     * `onlyOwner` functions anymore. Can only be called by the current owner.\\n     *\\n     * NOTE: Renouncing ownership will leave the contract without an owner,\\n     * thereby removing any functionality that is only available to the owner.\\n     */\\n    function renounceOwnership() public virtual onlyOwner {\\n        _transferOwnership(address(0));\\n    }\\n\\n    /**\\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n     * Can only be called by the current owner.\\n     */\\n    function transferOwnership(address newOwner) public virtual onlyOwner {\\n        require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n        _transferOwnership(newOwner);\\n    }\\n\\n    /**\\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n     * Internal function without access restriction.\\n     */\\n    function _transferOwnership(address newOwner) internal virtual {\\n        address oldOwner = _owner;\\n        _owner = newOwner;\\n        emit OwnershipTransferred(oldOwner, newOwner);\\n    }\\n}\\n\",\"keccak256\":\"0xa94b34880e3c1b0b931662cb1c09e5dfa6662f31cba80e07c5ee71cd135c9673\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the amount of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the amount of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves `amount` tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 amount) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 amount) external returns (bool);\\n\\n    /**\\n     * @dev Moves `amount` tokens from `from` to `to` using the\\n     * allowance mechanism. `amount` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(\\n        address from,\\n        address to,\\n        uint256 amount\\n    ) external returns (bool);\\n}\\n\",\"keccak256\":\"0x9750c6b834f7b43000631af5cc30001c5f547b3ceb3635488f140f60e897ea6b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n    /**\\n     * @dev Returns the name of the token.\\n     */\\n    function name() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the symbol of the token.\\n     */\\n    function symbol() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the decimals places of the token.\\n     */\\n    function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x8de418a5503946cabe331f35fe242d3201a73f67f77aaeb7110acb1f30423aca\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n    function _msgSender() internal view virtual returns (address) {\\n        return msg.sender;\\n    }\\n\\n    function _msgData() internal view virtual returns (bytes calldata) {\\n        return msg.data;\\n    }\\n}\\n\",\"keccak256\":\"0xe2e337e6dde9ef6b680e07338c493ebea1b5fd09b43424112868e9cc1706bca7\",\"license\":\"MIT\"},\"@thesis/solidity-contracts/contracts/token/ERC20WithPermit.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.4;\\n\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\n\\nimport \\\"./IERC20WithPermit.sol\\\";\\nimport \\\"./IReceiveApproval.sol\\\";\\n\\n/// @title  ERC20WithPermit\\n/// @notice Burnable ERC20 token with EIP2612 permit functionality. User can\\n///         authorize a transfer of their token with a signature conforming\\n///         EIP712 standard instead of an on-chain transaction from their\\n///         address. Anyone can submit this signature on the user's behalf by\\n///         calling the permit function, as specified in EIP2612 standard,\\n///         paying gas fees, and possibly performing other actions in the same\\n///         transaction.\\ncontract ERC20WithPermit is IERC20WithPermit, Ownable {\\n    /// @notice The amount of tokens owned by the given account.\\n    mapping(address => uint256) public override balanceOf;\\n\\n    /// @notice The remaining number of tokens that spender will be\\n    ///         allowed to spend on behalf of owner through `transferFrom` and\\n    ///         `burnFrom`. This is zero by default.\\n    mapping(address => mapping(address => uint256)) public override allowance;\\n\\n    /// @notice Returns the current nonce for EIP2612 permission for the\\n    ///         provided token owner for a replay protection. Used to construct\\n    ///         EIP2612 signature provided to `permit` function.\\n    mapping(address => uint256) public override nonce;\\n\\n    uint256 public immutable cachedChainId;\\n    bytes32 public immutable cachedDomainSeparator;\\n\\n    /// @notice Returns EIP2612 Permit message hash. Used to construct EIP2612\\n    ///         signature provided to `permit` function.\\n    bytes32 public constant override PERMIT_TYPEHASH =\\n        keccak256(\\n            \\\"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\\\"\\n        );\\n\\n    /// @notice The amount of tokens in existence.\\n    uint256 public override totalSupply;\\n\\n    /// @notice The name of the token.\\n    string public override name;\\n\\n    /// @notice The symbol of the token.\\n    string public override symbol;\\n\\n    /// @notice The decimals places of the token.\\n    uint8 public constant override decimals = 18;\\n\\n    constructor(string memory _name, string memory _symbol) {\\n        name = _name;\\n        symbol = _symbol;\\n\\n        cachedChainId = block.chainid;\\n        cachedDomainSeparator = buildDomainSeparator();\\n    }\\n\\n    /// @notice Moves `amount` tokens from the caller's account to `recipient`.\\n    /// @return True if the operation succeeded, reverts otherwise.\\n    /// @dev Requirements:\\n    ///       - `recipient` cannot be the zero address,\\n    ///       - the caller must have a balance of at least `amount`.\\n    function transfer(address recipient, uint256 amount)\\n        external\\n        override\\n        returns (bool)\\n    {\\n        _transfer(msg.sender, recipient, amount);\\n        return true;\\n    }\\n\\n    /// @notice Moves `amount` tokens from `spender` to `recipient` using the\\n    ///         allowance mechanism. `amount` is then deducted from the caller's\\n    ///         allowance unless the allowance was made for `type(uint256).max`.\\n    /// @return True if the operation succeeded, reverts otherwise.\\n    /// @dev Requirements:\\n    ///      - `spender` and `recipient` cannot be the zero address,\\n    ///      - `spender` must have a balance of at least `amount`,\\n    ///      - the caller must have allowance for `spender`'s tokens of at least\\n    ///        `amount`.\\n    function transferFrom(\\n        address spender,\\n        address recipient,\\n        uint256 amount\\n    ) external override returns (bool) {\\n        uint256 currentAllowance = allowance[spender][msg.sender];\\n        if (currentAllowance != type(uint256).max) {\\n            require(\\n                currentAllowance >= amount,\\n                \\\"Transfer amount exceeds allowance\\\"\\n            );\\n            _approve(spender, msg.sender, currentAllowance - amount);\\n        }\\n        _transfer(spender, recipient, amount);\\n        return true;\\n    }\\n\\n    /// @notice EIP2612 approval made with secp256k1 signature.\\n    ///         Users can authorize a transfer of their tokens with a signature\\n    ///         conforming EIP712 standard, rather than an on-chain transaction\\n    ///         from their address. Anyone can submit this signature on the\\n    ///         user's behalf by calling the permit function, paying gas fees,\\n    ///         and possibly performing other actions in the same transaction.\\n    /// @dev    The deadline argument can be set to `type(uint256).max to create\\n    ///         permits that effectively never expire.  If the `amount` is set\\n    ///         to `type(uint256).max` then `transferFrom` and `burnFrom` will\\n    ///         not reduce an allowance.\\n    function permit(\\n        address owner,\\n        address spender,\\n        uint256 amount,\\n        uint256 deadline,\\n        uint8 v,\\n        bytes32 r,\\n        bytes32 s\\n    ) external override {\\n        /* solhint-disable-next-line not-rely-on-time */\\n        require(deadline >= block.timestamp, \\\"Permission expired\\\");\\n\\n        // Validate `s` and `v` values for a malleability concern described in EIP2.\\n        // Only signatures with `s` value in the lower half of the secp256k1\\n        // curve's order and `v` value of 27 or 28 are considered valid.\\n        require(\\n            uint256(s) <=\\n                0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0,\\n            \\\"Invalid signature 's' value\\\"\\n        );\\n        require(v == 27 || v == 28, \\\"Invalid signature 'v' value\\\");\\n\\n        bytes32 digest = keccak256(\\n            abi.encodePacked(\\n                \\\"\\\\x19\\\\x01\\\",\\n                DOMAIN_SEPARATOR(),\\n                keccak256(\\n                    abi.encode(\\n                        PERMIT_TYPEHASH,\\n                        owner,\\n                        spender,\\n                        amount,\\n                        nonce[owner]++,\\n                        deadline\\n                    )\\n                )\\n            )\\n        );\\n        address recoveredAddress = ecrecover(digest, v, r, s);\\n        require(\\n            recoveredAddress != address(0) && recoveredAddress == owner,\\n            \\\"Invalid signature\\\"\\n        );\\n        _approve(owner, spender, amount);\\n    }\\n\\n    /// @notice Creates `amount` tokens and assigns them to `account`,\\n    ///         increasing the total supply.\\n    /// @dev Requirements:\\n    ///      - `recipient` cannot be the zero address.\\n    function mint(address recipient, uint256 amount) external onlyOwner {\\n        require(recipient != address(0), \\\"Mint to the zero address\\\");\\n\\n        beforeTokenTransfer(address(0), recipient, amount);\\n\\n        totalSupply += amount;\\n        balanceOf[recipient] += amount;\\n        emit Transfer(address(0), recipient, amount);\\n    }\\n\\n    /// @notice Destroys `amount` tokens from the caller.\\n    /// @dev Requirements:\\n    ///       - the caller must have a balance of at least `amount`.\\n    function burn(uint256 amount) external override {\\n        _burn(msg.sender, amount);\\n    }\\n\\n    /// @notice Destroys `amount` of tokens from `account` using the allowance\\n    ///         mechanism. `amount` is then deducted from the caller's allowance\\n    ///         unless the allowance was made for `type(uint256).max`.\\n    /// @dev Requirements:\\n    ///      - `account` must have a balance of at least `amount`,\\n    ///      - the caller must have allowance for `account`'s tokens of at least\\n    ///        `amount`.\\n    function burnFrom(address account, uint256 amount) external override {\\n        uint256 currentAllowance = allowance[account][msg.sender];\\n        if (currentAllowance != type(uint256).max) {\\n            require(\\n                currentAllowance >= amount,\\n                \\\"Burn amount exceeds allowance\\\"\\n            );\\n            _approve(account, msg.sender, currentAllowance - amount);\\n        }\\n        _burn(account, amount);\\n    }\\n\\n    /// @notice Calls `receiveApproval` function on spender previously approving\\n    ///         the spender to withdraw from the caller multiple times, up to\\n    ///         the `amount` amount. If this function is called again, it\\n    ///         overwrites the current allowance with `amount`. Reverts if the\\n    ///         approval reverted or if `receiveApproval` call on the spender\\n    ///         reverted.\\n    /// @return True if both approval and `receiveApproval` calls succeeded.\\n    /// @dev If the `amount` is set to `type(uint256).max` then\\n    ///      `transferFrom` and `burnFrom` will not reduce an allowance.\\n    function approveAndCall(\\n        address spender,\\n        uint256 amount,\\n        bytes memory extraData\\n    ) external override returns (bool) {\\n        if (approve(spender, amount)) {\\n            IReceiveApproval(spender).receiveApproval(\\n                msg.sender,\\n                amount,\\n                address(this),\\n                extraData\\n            );\\n            return true;\\n        }\\n        return false;\\n    }\\n\\n    /// @notice Sets `amount` as the allowance of `spender` over the caller's\\n    ///         tokens.\\n    /// @return True if the operation succeeded.\\n    /// @dev If the `amount` is set to `type(uint256).max` then\\n    ///      `transferFrom` and `burnFrom` will not reduce an allowance.\\n    ///      Beware that changing an allowance with this method brings the risk\\n    ///      that someone may use both the old and the new allowance by\\n    ///      unfortunate transaction ordering. One possible solution to mitigate\\n    ///      this race condition is to first reduce the spender's allowance to 0\\n    ///      and set the desired value afterwards:\\n    ///      https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n    function approve(address spender, uint256 amount)\\n        public\\n        override\\n        returns (bool)\\n    {\\n        _approve(msg.sender, spender, amount);\\n        return true;\\n    }\\n\\n    /// @notice Returns hash of EIP712 Domain struct with the token name as\\n    ///         a signing domain and token contract as a verifying contract.\\n    ///         Used to construct EIP2612 signature provided to `permit`\\n    ///         function.\\n    /* solhint-disable-next-line func-name-mixedcase */\\n    function DOMAIN_SEPARATOR() public view override returns (bytes32) {\\n        // As explained in EIP-2612, if the DOMAIN_SEPARATOR contains the\\n        // chainId and is defined at contract deployment instead of\\n        // reconstructed for every signature, there is a risk of possible replay\\n        // attacks between chains in the event of a future chain split.\\n        // To address this issue, we check the cached chain ID against the\\n        // current one and in case they are different, we build domain separator\\n        // from scratch.\\n        if (block.chainid == cachedChainId) {\\n            return cachedDomainSeparator;\\n        } else {\\n            return buildDomainSeparator();\\n        }\\n    }\\n\\n    /// @dev Hook that is called before any transfer of tokens. This includes\\n    ///      minting and burning.\\n    ///\\n    /// Calling conditions:\\n    /// - when `from` and `to` are both non-zero, `amount` of `from`'s tokens\\n    ///   will be to transferred to `to`.\\n    /// - when `from` is zero, `amount` tokens will be minted for `to`.\\n    /// - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n    /// - `from` and `to` are never both zero.\\n    // slither-disable-next-line dead-code\\n    function beforeTokenTransfer(\\n        address from,\\n        address to,\\n        uint256 amount\\n    ) internal virtual {}\\n\\n    function _burn(address account, uint256 amount) internal {\\n        uint256 currentBalance = balanceOf[account];\\n        require(currentBalance >= amount, \\\"Burn amount exceeds balance\\\");\\n\\n        beforeTokenTransfer(account, address(0), amount);\\n\\n        balanceOf[account] = currentBalance - amount;\\n        totalSupply -= amount;\\n        emit Transfer(account, address(0), amount);\\n    }\\n\\n    function _transfer(\\n        address spender,\\n        address recipient,\\n        uint256 amount\\n    ) private {\\n        require(spender != address(0), \\\"Transfer from the zero address\\\");\\n        require(recipient != address(0), \\\"Transfer to the zero address\\\");\\n        require(recipient != address(this), \\\"Transfer to the token address\\\");\\n\\n        beforeTokenTransfer(spender, recipient, amount);\\n\\n        uint256 spenderBalance = balanceOf[spender];\\n        require(spenderBalance >= amount, \\\"Transfer amount exceeds balance\\\");\\n        balanceOf[spender] = spenderBalance - amount;\\n        balanceOf[recipient] += amount;\\n        emit Transfer(spender, recipient, amount);\\n    }\\n\\n    function _approve(\\n        address owner,\\n        address spender,\\n        uint256 amount\\n    ) private {\\n        require(owner != address(0), \\\"Approve from the zero address\\\");\\n        require(spender != address(0), \\\"Approve to the zero address\\\");\\n        allowance[owner][spender] = amount;\\n        emit Approval(owner, spender, amount);\\n    }\\n\\n    function buildDomainSeparator() private view returns (bytes32) {\\n        return\\n            keccak256(\\n                abi.encode(\\n                    keccak256(\\n                        \\\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\\\"\\n                    ),\\n                    keccak256(bytes(name)),\\n                    keccak256(bytes(\\\"1\\\")),\\n                    block.chainid,\\n                    address(this)\\n                )\\n            );\\n    }\\n}\\n\",\"keccak256\":\"0x1e1bf4ec5c9d6fe70f6f834316482aeff3f122ff4ffaa7178099e7ae71a0b16d\",\"license\":\"MIT\"},\"@thesis/solidity-contracts/contracts/token/IApproveAndCall.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.4;\\n\\n/// @notice An interface that should be implemented by tokens supporting\\n///         `approveAndCall`/`receiveApproval` pattern.\\ninterface IApproveAndCall {\\n    /// @notice Executes `receiveApproval` function on spender as specified in\\n    ///         `IReceiveApproval` interface. Approves spender to withdraw from\\n    ///         the caller multiple times, up to the `amount`. If this\\n    ///         function is called again, it overwrites the current allowance\\n    ///         with `amount`. Reverts if the approval reverted or if\\n    ///         `receiveApproval` call on the spender reverted.\\n    function approveAndCall(\\n        address spender,\\n        uint256 amount,\\n        bytes memory extraData\\n    ) external returns (bool);\\n}\\n\",\"keccak256\":\"0x393d18ef81a57dcc96fff4c340cc2945deaebb37b9796c322cf2bc96872c3df8\",\"license\":\"MIT\"},\"@thesis/solidity-contracts/contracts/token/IERC20WithPermit.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.4;\\n\\nimport \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\n\\nimport \\\"./IApproveAndCall.sol\\\";\\n\\n/// @title  IERC20WithPermit\\n/// @notice Burnable ERC20 token with EIP2612 permit functionality. User can\\n///         authorize a transfer of their token with a signature conforming\\n///         EIP712 standard instead of an on-chain transaction from their\\n///         address. Anyone can submit this signature on the user's behalf by\\n///         calling the permit function, as specified in EIP2612 standard,\\n///         paying gas fees, and possibly performing other actions in the same\\n///         transaction.\\ninterface IERC20WithPermit is IERC20, IERC20Metadata, IApproveAndCall {\\n    /// @notice EIP2612 approval made with secp256k1 signature.\\n    ///         Users can authorize a transfer of their tokens with a signature\\n    ///         conforming EIP712 standard, rather than an on-chain transaction\\n    ///         from their address. Anyone can submit this signature on the\\n    ///         user's behalf by calling the permit function, paying gas fees,\\n    ///         and possibly performing other actions in the same transaction.\\n    /// @dev    The deadline argument can be set to `type(uint256).max to create\\n    ///         permits that effectively never expire.\\n    function permit(\\n        address owner,\\n        address spender,\\n        uint256 amount,\\n        uint256 deadline,\\n        uint8 v,\\n        bytes32 r,\\n        bytes32 s\\n    ) external;\\n\\n    /// @notice Destroys `amount` tokens from the caller.\\n    function burn(uint256 amount) external;\\n\\n    /// @notice Destroys `amount` of tokens from `account`, deducting the amount\\n    ///         from caller's allowance.\\n    function burnFrom(address account, uint256 amount) external;\\n\\n    /// @notice Returns hash of EIP712 Domain struct with the token name as\\n    ///         a signing domain and token contract as a verifying contract.\\n    ///         Used to construct EIP2612 signature provided to `permit`\\n    ///         function.\\n    /* solhint-disable-next-line func-name-mixedcase */\\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\\n\\n    /// @notice Returns the current nonce for EIP2612 permission for the\\n    ///         provided token owner for a replay protection. Used to construct\\n    ///         EIP2612 signature provided to `permit` function.\\n    function nonce(address owner) external view returns (uint256);\\n\\n    /// @notice Returns EIP2612 Permit message hash. Used to construct EIP2612\\n    ///         signature provided to `permit` function.\\n    /* solhint-disable-next-line func-name-mixedcase */\\n    function PERMIT_TYPEHASH() external pure returns (bytes32);\\n}\\n\",\"keccak256\":\"0xdac9a5086c19a7128b505a7be1ab0ac1aa314f6989cb88d2417e9d7383f89fa9\",\"license\":\"MIT\"},\"@thesis/solidity-contracts/contracts/token/IReceiveApproval.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.4;\\n\\n/// @notice An interface that should be implemented by contracts supporting\\n///         `approveAndCall`/`receiveApproval` pattern.\\ninterface IReceiveApproval {\\n    /// @notice Receives approval to spend tokens. Called as a result of\\n    ///         `approveAndCall` call on the token.\\n    function receiveApproval(\\n        address from,\\n        uint256 amount,\\n        address token,\\n        bytes calldata extraData\\n    ) external;\\n}\\n\",\"keccak256\":\"0x6a30d83ad230548b1e7839737affc8489a035314209de14b89dbef7fb0f66395\",\"license\":\"MIT\"},\"contracts/l2/L2TBTC.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0-only\\n\\n// \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588     \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c     \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\n// \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588     \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c     \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n// \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588     \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c     \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\n// \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588     \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c     \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n\\npragma solidity ^0.8.17;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/draft-ERC20PermitUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20BurnableUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\\\";\\n\\n/// @title L2TBTC\\n/// @notice Canonical L2/sidechain token implementation. tBTC token is minted on\\n///         L1 and locked there to be moved to L2/sidechain. By deploying\\n///         a canonical token on each L2/sidechain, we can ensure the supply of\\n///         tBTC remains sacrosanct, while enabling quick, interoperable\\n///         cross-chain bridges and localizing ecosystem risk.\\n///\\n///         This contract is flexible enough to:\\n///         - Delegate minting authority to a native bridge on the chain, if\\n///           present.\\n///         - Delegate minting authority to a short list of ecosystem bridges.\\n///         - Have mints and burns paused by any one of n guardians, allowing\\n///           avoidance of contagion in case of a chain- or bridge-specific\\n///           incident.\\n///         - Be governed and upgradeable.\\n///\\n///         The token is burnable by the token holder and supports EIP2612\\n///         permits. Token holder can authorize a transfer of their token with\\n///         a signature conforming EIP712 standard instead of an on-chain\\n///         transaction from their address. Anyone can submit this signature on\\n///         the user's behalf by calling the permit function, paying gas fees,\\n///         and possibly performing other actions in the same transaction.\\n///         The governance can recover ERC20 and ERC721 tokens sent mistakenly\\n///         to L2TBTC token contract.\\ncontract L2TBTC is\\n    ERC20Upgradeable,\\n    ERC20BurnableUpgradeable,\\n    ERC20PermitUpgradeable,\\n    OwnableUpgradeable,\\n    PausableUpgradeable\\n{\\n    using SafeERC20Upgradeable for IERC20Upgradeable;\\n\\n    /// @notice Indicates if the given address is a minter. Only minters can\\n    ///         mint the token.\\n    mapping(address => bool) public isMinter;\\n\\n    /// @notice List of all minters.\\n    address[] public minters;\\n\\n    /// @notice Indicates if the given address is a guardian. Only guardians can\\n    ///         pause token mints and burns.\\n    mapping(address => bool) public isGuardian;\\n\\n    /// @notice List of all guardians.\\n    address[] public guardians;\\n\\n    event MinterAdded(address indexed minter);\\n    event MinterRemoved(address indexed minter);\\n\\n    event GuardianAdded(address indexed guardian);\\n    event GuardianRemoved(address indexed guardian);\\n\\n    modifier onlyMinter() {\\n        require(isMinter[msg.sender], \\\"Caller is not a minter\\\");\\n        _;\\n    }\\n\\n    modifier onlyGuardian() {\\n        require(isGuardian[msg.sender], \\\"Caller is not a guardian\\\");\\n        _;\\n    }\\n\\n    /// @notice Initializes the token contract.\\n    /// @param _name The name of the token.\\n    /// @param _symbol The symbol of the token, usually a shorter version of the\\n    ///        name.\\n    function initialize(string memory _name, string memory _symbol)\\n        external\\n        initializer\\n    {\\n        // OpenZeppelin upgradeable contracts documentation says:\\n        //\\n        // \\\"Use with multiple inheritance requires special care. Initializer\\n        // functions are not linearized by the compiler like constructors.\\n        // Because of this, each __{ContractName}_init function embeds the\\n        // linearized calls to all parent initializers. As a consequence,\\n        // calling two of these init functions can potentially initialize the\\n        // same contract twice.\\\"\\n        //\\n        // Note that ERC20 extensions do not linearize calls to ERC20Upgradeable\\n        // initializer so we call all extension initializers individually. At\\n        // the same time, ERC20PermitUpgradeable does linearize the call to\\n        // EIP712Upgradeable so we are not using the unchained initializer\\n        // versions.\\n        __ERC20_init(_name, _symbol);\\n        __ERC20Burnable_init();\\n        __ERC20Permit_init(_name);\\n        __Ownable_init();\\n        __Pausable_init();\\n    }\\n\\n    /// @notice Adds the address to the minters list.\\n    /// @dev Requirements:\\n    ///      - The caller must be the contract owner.\\n    ///      - `minter` must not be a minter address already.\\n    /// @param minter The address to be added as a minter.\\n    function addMinter(address minter) external onlyOwner {\\n        require(!isMinter[minter], \\\"This address is already a minter\\\");\\n        isMinter[minter] = true;\\n        minters.push(minter);\\n        emit MinterAdded(minter);\\n    }\\n\\n    /// @notice Removes the address from the minters list.\\n    /// @dev Requirements:\\n    ///      - The caller must be the contract owner.\\n    ///      - `minter` must be a minter address.\\n    /// @param minter The address to be removed from the minters list.\\n    function removeMinter(address minter) external onlyOwner {\\n        require(isMinter[minter], \\\"This address is not a minter\\\");\\n        delete isMinter[minter];\\n\\n        // We do not expect too many minters so a simple loop is safe.\\n        for (uint256 i = 0; i < minters.length; i++) {\\n            if (minters[i] == minter) {\\n                minters[i] = minters[minters.length - 1];\\n                // slither-disable-next-line costly-loop\\n                minters.pop();\\n                break;\\n            }\\n        }\\n\\n        emit MinterRemoved(minter);\\n    }\\n\\n    /// @notice Adds the address to the guardians list.\\n    /// @dev Requirements:\\n    ///      - The caller must be the contract owner.\\n    ///      - `guardian` must not be a guardian address already.\\n    /// @param guardian The address to be added as a guardian.\\n    function addGuardian(address guardian) external onlyOwner {\\n        require(!isGuardian[guardian], \\\"This address is already a guardian\\\");\\n        isGuardian[guardian] = true;\\n        guardians.push(guardian);\\n        emit GuardianAdded(guardian);\\n    }\\n\\n    /// @notice Removes the address from the guardians list.\\n    /// @dev Requirements:\\n    ///      - The caller must be the contract owner.\\n    ///      - `guardian` must be a guardian address.\\n    /// @param guardian The address to be removed from the guardians list.\\n    function removeGuardian(address guardian) external onlyOwner {\\n        require(isGuardian[guardian], \\\"This address is not a guardian\\\");\\n        delete isGuardian[guardian];\\n\\n        // We do not expect too many guardians so a simple loop is safe.\\n        for (uint256 i = 0; i < guardians.length; i++) {\\n            if (guardians[i] == guardian) {\\n                guardians[i] = guardians[guardians.length - 1];\\n                // slither-disable-next-line costly-loop\\n                guardians.pop();\\n                break;\\n            }\\n        }\\n\\n        emit GuardianRemoved(guardian);\\n    }\\n\\n    /// @notice Allows the governance of the token contract to recover any ERC20\\n    ///         sent mistakenly to the token contract address.\\n    /// @param token The address of the token to be recovered.\\n    /// @param recipient The token recipient address that will receive recovered\\n    ///        tokens.\\n    /// @param amount The amount to be recovered.\\n    function recoverERC20(\\n        IERC20Upgradeable token,\\n        address recipient,\\n        uint256 amount\\n    ) external onlyOwner {\\n        token.safeTransfer(recipient, amount);\\n    }\\n\\n    /// @notice Allows the governance of the token contract to recover any\\n    ///         ERC721 sent mistakenly to the token contract address.\\n    /// @param token The address of the token to be recovered.\\n    /// @param recipient The token recipient address that will receive the\\n    ///        recovered token.\\n    /// @param tokenId The ID of the ERC721 token to be recovered.\\n    function recoverERC721(\\n        IERC721Upgradeable token,\\n        address recipient,\\n        uint256 tokenId,\\n        bytes calldata data\\n    ) external onlyOwner {\\n        token.safeTransferFrom(address(this), recipient, tokenId, data);\\n    }\\n\\n    /// @notice Allows one of the guardians to pause mints and burns allowing\\n    ///         avoidance of contagion in case of a chain- or bridge-specific\\n    ///         incident.\\n    /// @dev Requirements:\\n    ///      - The caller must be a guardian.\\n    ///      - The contract must not be already paused.\\n    function pause() external onlyGuardian {\\n        _pause();\\n    }\\n\\n    /// @notice Allows the governance to unpause mints and burns previously\\n    ///         paused by one of the guardians.\\n    /// @dev Requirements:\\n    ///      - The caller must be the contract owner.\\n    ///      - The contract must be paused.\\n    function unpause() external onlyOwner {\\n        _unpause();\\n    }\\n\\n    /// @notice Allows one of the minters to mint `amount` tokens and assign\\n    ///         them to `account`, increasing the total supply. Emits\\n    ///         a `Transfer` event with `from` set to the zero address.\\n    /// @dev Requirements:\\n    ///      - The caller must be a minter.\\n    ///      - `account` must not be the zero address.\\n    /// @param account The address to receive tokens.\\n    /// @param amount The amount of token to be minted.\\n    function mint(address account, uint256 amount)\\n        external\\n        whenNotPaused\\n        onlyMinter\\n    {\\n        _mint(account, amount);\\n    }\\n\\n    /// @notice Destroys `amount` tokens from the caller. Emits a `Transfer`\\n    ///         event with `to` set to the zero address.\\n    /// @dev Requirements:\\n    ///      - The caller must have at least `amount` tokens.\\n    /// @param amount The amount of token to be burned.\\n    function burn(uint256 amount) public override whenNotPaused {\\n        super.burn(amount);\\n    }\\n\\n    /// @notice Destroys `amount` tokens from `account`, deducting from the\\n    ///         caller's allowance. Emits a `Transfer` event with `to` set to\\n    ///         the zero address.\\n    /// @dev Requirements:\\n    ///      - The che caller must have allowance for `accounts`'s tokens of at\\n    ///        least `amount`.\\n    ///      - `account` must not be the zero address.\\n    ///      - `account` must have at least `amount` tokens.\\n    /// @param account The address owning tokens to be burned.\\n    /// @param amount The amount of token to be burned.\\n    function burnFrom(address account, uint256 amount)\\n        public\\n        override\\n        whenNotPaused\\n    {\\n        super.burnFrom(account, amount);\\n    }\\n\\n    /// @notice Allows to fetch a list of all minters.\\n    function getMinters() external view returns (address[] memory) {\\n        return minters;\\n    }\\n\\n    /// @notice Allows to fetch a list of all guardians.\\n    function getGuardians() external view returns (address[] memory) {\\n        return guardians;\\n    }\\n}\\n\",\"keccak256\":\"0x0ad24408cfce03caefa5f9c95b664f75867670b39016c059a28618e0e822ac85\",\"license\":\"GPL-3.0-only\"},\"contracts/l2/L2WormholeGateway.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0-only\\n\\n// \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588     \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c     \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\n// \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588     \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c     \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n// \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588     \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c     \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\n// \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588     \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c     \\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\u2588\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n//               \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c    \\u2590\\u2588\\u2588\\u2588\\u2588\\u258c\\n\\npragma solidity ^0.8.17;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\\\";\\n\\nimport \\\"./L2TBTC.sol\\\";\\n\\n/// @title IWormholeTokenBridge\\n/// @notice Wormhole Token Bridge interface. Contains only selected functions\\n///         used by L2WormholeGateway.\\ninterface IWormholeTokenBridge {\\n    function completeTransferWithPayload(bytes memory encodedVm)\\n        external\\n        returns (bytes memory);\\n\\n    function parseTransferWithPayload(bytes memory encoded)\\n        external\\n        pure\\n        returns (TransferWithPayload memory transfer);\\n\\n    function transferTokens(\\n        address token,\\n        uint256 amount,\\n        uint16 recipientChain,\\n        bytes32 recipient,\\n        uint256 arbiterFee,\\n        uint32 nonce\\n    ) external payable returns (uint64 sequence);\\n\\n    function transferTokensWithPayload(\\n        address token,\\n        uint256 amount,\\n        uint16 recipientChain,\\n        bytes32 recipient,\\n        uint32 nonce,\\n        bytes memory payload\\n    ) external payable returns (uint64 sequence);\\n\\n    struct TransferWithPayload {\\n        uint8 payloadID;\\n        uint256 amount;\\n        bytes32 tokenAddress;\\n        uint16 tokenChain;\\n        bytes32 to;\\n        uint16 toChain;\\n        bytes32 fromAddress;\\n        bytes payload;\\n    }\\n}\\n\\n/// @title L2WormholeGateway\\n/// @notice Selected cross-ecosystem bridges are given the minting authority for\\n///         tBTC token on L2 and sidechains. This contract gives a minting\\n///         authority to the Wormhole Bridge.\\n///\\n///         The process of bridging from L1 to L2 (or sidechain) looks as\\n///         follows:\\n///         1. There is a tBTC holder on L1. The holder goes to the Wormhole\\n///            Portal and selects the chain they want to bridge to.\\n///         2. The holder submits one transaction to L1 locking their tBTC\\n///            tokens in the bridge\\u2019s smart contract. After the transaction is\\n///            mined, they wait about 15 minutes for the Ethereum block\\n///            finality.\\n///         3. The holder submits one transaction to L2 that is minting tokens.\\n///            After that transaction is mined, they have their tBTC on L2.\\n///\\n///         The process of bridging from L2 (or sidechain) to L1 looks as\\n///         follows:\\n///         1. There is a tBTC holder on L2. That holder goes to the Wormhole\\n///            Portal and selects one of the L2 chains they want to bridge from.\\n///         2. The holder submits one transaction to L2 that is burning the\\n///            token. After the transaction is mined, they wait about 15 minutes\\n///            for the L2 block finality.\\n///         3. The holder submits one transaction to L1 unlocking their tBTC\\n///            tokens from the bridge\\u2019s smart contract. After that transaction\\n///            is mined, they have their tBTC on L1.\\n///\\n///         This smart contract is integrated with step 3 of L1->L2 bridging and\\n///         step 1 of L2->L1 or L2->L2 bridging. When the user redeems token on\\n///         L2, this contract receives the Wormhole tBTC representation and\\n///         mints the canonical tBTC in an equal amount. When user sends their\\n///         token from L1, this contract burns the canonical tBTC and sends\\n///         Wormhole tBTC representation through the bridge in an equal amount.\\n/// @dev This contract is supposed to be deployed behind a transparent\\n///      upgradeable proxy.\\ncontract L2WormholeGateway is\\n    Initializable,\\n    OwnableUpgradeable,\\n    ReentrancyGuardUpgradeable\\n{\\n    using SafeERC20Upgradeable for IERC20Upgradeable;\\n\\n    /// @notice Reference to the Wormhole Token Bridge contract.\\n    IWormholeTokenBridge public bridge;\\n\\n    /// @notice Wormhole tBTC token representation.\\n    IERC20Upgradeable public bridgeToken;\\n\\n    /// @notice Canonical tBTC token.\\n    L2TBTC public tbtc;\\n\\n    /// @notice Maps Wormhole chain ID to the Wormhole tBTC gateway address on\\n    ///         that chain. For example, this chain's ID should be mapped to\\n    ///         this contract's address. If there is no Wormhole tBTC gateway\\n    ///         address on the given chain, there is no entry in this mapping.\\n    ///         The mapping holds addresses in a Wormhole-specific format, where\\n    ///         Ethereum address is left-padded with zeros.\\n    mapping(uint16 => bytes32) public gateways;\\n\\n    /// @notice Minting limit for this gateway. Useful for early days of testing\\n    ///         the system. The gateway can not mint more canonical tBTC than\\n    ///         this limit.\\n    uint256 public mintingLimit;\\n\\n    /// @notice The amount of tBTC minted by this contract. tBTC burned by this\\n    ///         contract decreases this amount.\\n    uint256 public mintedAmount;\\n\\n    event WormholeTbtcReceived(address receiver, uint256 amount);\\n\\n    event WormholeTbtcSent(\\n        uint256 amount,\\n        uint16 recipientChain,\\n        bytes32 gateway,\\n        bytes32 recipient,\\n        uint256 arbiterFee,\\n        uint32 nonce\\n    );\\n\\n    event WormholeTbtcDeposited(address depositor, uint256 amount);\\n\\n    event GatewayAddressUpdated(uint16 chainId, bytes32 gateway);\\n\\n    event MintingLimitUpdated(uint256 mintingLimit);\\n\\n    function initialize(\\n        IWormholeTokenBridge _bridge,\\n        IERC20Upgradeable _bridgeToken,\\n        L2TBTC _tbtc\\n    ) external initializer {\\n        __Ownable_init();\\n        __ReentrancyGuard_init();\\n\\n        require(\\n            address(_bridge) != address(0),\\n            \\\"Wormhole bridge address must not be 0x0\\\"\\n        );\\n        require(\\n            address(_bridgeToken) != address(0),\\n            \\\"Bridge token address must not be 0x0\\\"\\n        );\\n        require(\\n            address(_tbtc) != address(0),\\n            \\\"L2TBTC token address must not be 0x0\\\"\\n        );\\n\\n        bridge = _bridge;\\n        bridgeToken = _bridgeToken;\\n        tbtc = _tbtc;\\n        mintingLimit = type(uint256).max;\\n    }\\n\\n    /// @notice This function is called when the user sends their token from L2.\\n    ///         The contract burns the canonical tBTC from the user and sends\\n    ///         wormhole tBTC representation over the bridge.\\n    ///         Keep in mind that when multiple bridges receive a minting\\n    ///         authority on the canonical tBTC, this function may not be able\\n    ///         to send all amounts of tBTC through the Wormhole bridge. The\\n    ///         capability of Wormhole Bridge to send tBTC from the chain is\\n    ///         limited to the amount of tBTC bridged through Wormhole to that\\n    ///         chain.\\n    /// @dev Requirements:\\n    ///      - The sender must have at least `amount` of the canonical tBTC and\\n    ///        it has to be approved for L2WormholeGateway.\\n    ///      - The L2WormholeGateway must have at least `amount` of the wormhole\\n    ///        tBTC.\\n    ///      - The recipient must not be 0x0.\\n    ///      - The amount to transfer must not be 0,\\n    ///      - The amount to transfer must be >= 10^10 (1e18 precision).\\n    ///      Depending if Wormhole tBTC gateway is registered on the target\\n    ///      chain, this function uses transfer or transfer with payload over\\n    ///      the Wormhole bridge.\\n    /// @param amount The amount of tBTC to be sent.\\n    /// @param recipientChain The Wormhole recipient chain ID.\\n    /// @param recipient The address of the recipient in the Wormhole format.\\n    /// @param arbiterFee The Wormhole arbiter fee. Ignored if sending\\n    ///                   tBTC to chain with Wormhole tBTC gateway.\\n    /// @param nonce The Wormhole nonce used to batch messages together.\\n    /// @return The Wormhole sequence number.\\n    function sendTbtc(\\n        uint256 amount,\\n        uint16 recipientChain,\\n        bytes32 recipient,\\n        uint256 arbiterFee,\\n        uint32 nonce\\n    ) external payable nonReentrant returns (uint64) {\\n        require(recipient != bytes32(0), \\\"0x0 recipient not allowed\\\");\\n        require(amount != 0, \\\"Amount must not be 0\\\");\\n\\n        // Normalize the amount to bridge. The dust can not be bridged due to\\n        // the decimal shift in the Wormhole Bridge contract.\\n        amount = normalize(amount);\\n\\n        // Check again after dropping the dust.\\n        require(amount != 0, \\\"Amount too low to bridge\\\");\\n\\n        require(\\n            bridgeToken.balanceOf(address(this)) >= amount,\\n            \\\"Not enough wormhole tBTC in the gateway to bridge\\\"\\n        );\\n\\n        bytes32 gateway = gateways[recipientChain];\\n\\n        emit WormholeTbtcSent(\\n            amount,\\n            recipientChain,\\n            gateway,\\n            recipient,\\n            arbiterFee,\\n            nonce\\n        );\\n\\n        mintedAmount -= amount;\\n        tbtc.burnFrom(msg.sender, amount);\\n        bridgeToken.safeApprove(address(bridge), amount);\\n\\n        if (gateway == bytes32(0)) {\\n            // No Wormhole tBTC gateway on the target chain. The token minted\\n            // by Wormhole should be considered canonical.\\n            return\\n                bridge.transferTokens{value: msg.value}(\\n                    address(bridgeToken),\\n                    amount,\\n                    recipientChain,\\n                    recipient,\\n                    arbiterFee,\\n                    nonce\\n                );\\n        } else {\\n            // There is a Wormhole tBTC gateway on the target chain.\\n            // The gateway needs to mint canonical tBTC for the recipient\\n            // encoded in the payload.\\n            return\\n                bridge.transferTokensWithPayload{value: msg.value}(\\n                    address(bridgeToken),\\n                    amount,\\n                    recipientChain,\\n                    gateway,\\n                    nonce,\\n                    abi.encode(recipient)\\n                );\\n        }\\n    }\\n\\n    /// @notice This function is called when the user redeems their token on L2.\\n    ///         The contract receives Wormhole tBTC representation and mints the\\n    ///         canonical tBTC for the user.\\n    ///         If the tBTC minting limit has been reached by this contract,\\n    ///         instead of minting tBTC the receiver address receives Wormhole\\n    ///         tBTC representation.\\n    /// @dev Requirements:\\n    ///      - The receiver of Wormhole tBTC should be the L2WormholeGateway\\n    ///        contract.\\n    ///      - The receiver of the canonical tBTC should be abi-encoded in the\\n    ///        payload.\\n    ///      - The receiver of the canonical tBTC must not be the zero address.\\n    ///\\n    ///      The Wormhole Token Bridge contract has protection against redeeming\\n    ///      the same VAA again. When a Token Bridge VAA is redeemed, its\\n    ///      message body hash is stored in a map. This map is used to check\\n    ///      whether the hash has already been set in this map. For this reason,\\n    ///      this function does not have to be nonReentrant in theory. However,\\n    ///      to make this function non-dependent on Wormhole Bridge implementation,\\n    ///      we are making it nonReentrant anyway.\\n    /// @param encodedVm A byte array containing a Wormhole VAA signed by the\\n    ///        guardians.\\n    function receiveTbtc(bytes calldata encodedVm) external nonReentrant {\\n        // ITokenBridge.completeTransferWithPayload completes a contract-controlled\\n        // transfer of an ERC20 token. Calling this function is not enough to\\n        // ensure L2WormholeGateway received Wormhole tBTC representation.\\n        // Instead of going too deep into the ITokenBridge implementation,\\n        // asserting who is the receiver of the token, and which token it is,\\n        // we check the balance before the ITokenBridge call and the balance\\n        // after ITokenBridge call. This way, we are sure this contract received\\n        // Wormhole tBTC token in the given amount. This is transparent to\\n        // all potential upgrades of ITokenBridge implementation and no other\\n        // validations are needed.\\n        uint256 balanceBefore = bridgeToken.balanceOf(address(this));\\n        bytes memory encoded = bridge.completeTransferWithPayload(encodedVm);\\n        uint256 balanceAfter = bridgeToken.balanceOf(address(this));\\n\\n        uint256 amount = balanceAfter - balanceBefore;\\n        // Protect against the custody of irrelevant tokens.\\n        require(amount > 0, \\\"No tBTC transferred\\\");\\n\\n        address receiver = fromWormholeAddress(\\n            bytes32(bridge.parseTransferWithPayload(encoded).payload)\\n        );\\n        require(receiver != address(0), \\\"0x0 receiver not allowed\\\");\\n\\n        // We send wormhole tBTC OR mint canonical tBTC. We do not want to send\\n        // dust. Sending wormhole tBTC is an exceptional situation and we want\\n        // to keep it simple.\\n        if (mintedAmount + amount > mintingLimit) {\\n            bridgeToken.safeTransfer(receiver, amount);\\n        } else {\\n            // The function is non-reentrant.\\n            // slither-disable-next-line reentrancy-benign\\n            mintedAmount += amount;\\n            tbtc.mint(receiver, amount);\\n        }\\n\\n        // The function is non-reentrant.\\n        // slither-disable-next-line reentrancy-events\\n        emit WormholeTbtcReceived(receiver, amount);\\n    }\\n\\n    /// @notice Lets the governance to update the tBTC gateway address on the\\n    ///         chain with the given Wormhole ID.\\n    /// @dev Use toWormholeAddress function to convert between Ethereum and\\n    ///      Wormhole address formats.\\n    /// @param chainId Wormhole ID of the chain.\\n    /// @param gateway Address of tBTC gateway on the given chain in a Wormhole\\n    ///                format.\\n    function updateGatewayAddress(uint16 chainId, bytes32 gateway)\\n        external\\n        onlyOwner\\n    {\\n        gateways[chainId] = gateway;\\n        emit GatewayAddressUpdated(chainId, gateway);\\n    }\\n\\n    /// @notice Lets the governance to update the tBTC minting limit for this\\n    ///         contract.\\n    /// @param _mintingLimit The new minting limit.\\n    function updateMintingLimit(uint256 _mintingLimit) external onlyOwner {\\n        mintingLimit = _mintingLimit;\\n        emit MintingLimitUpdated(_mintingLimit);\\n    }\\n\\n    /// @notice Converts Ethereum address into Wormhole format.\\n    /// @param _address The address to convert.\\n    function toWormholeAddress(address _address)\\n        external\\n        pure\\n        returns (bytes32)\\n    {\\n        return bytes32(uint256(uint160(_address)));\\n    }\\n\\n    /// @notice Converts Wormhole address into Ethereum format.\\n    /// @param _address The address to convert.\\n    function fromWormholeAddress(bytes32 _address)\\n        public\\n        pure\\n        returns (address)\\n    {\\n        return address(uint160(uint256(_address)));\\n    }\\n\\n    /// @dev Eliminates the dust that cannot be bridged with Wormhole\\n    ///      due to the decimal shift in the Wormhole Bridge contract.\\n    ///      See https://github.com/wormhole-foundation/wormhole/blob/96682bdbeb7c87bfa110eade0554b3d8cbf788d2/ethereum/contracts/bridge/Bridge.sol#L276-L288\\n    function normalize(uint256 amount) internal pure returns (uint256) {\\n        // slither-disable-next-line divide-before-multiply\\n        amount /= 10**10;\\n        amount *= 10**10;\\n        return amount;\\n    }\\n}\\n\",\"keccak256\":\"0x4f6e093db80674fc4197c79fba46458f430efbb3cfa612e649026ea6e322fbf0\",\"license\":\"GPL-3.0-only\"},\"contracts/test/TestERC20.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0-only\\n\\npragma solidity 0.8.17;\\n\\nimport \\\"@thesis/solidity-contracts/contracts/token/ERC20WithPermit.sol\\\";\\n\\ncontract TestERC20 is ERC20WithPermit {\\n    string public constant NAME = \\\"Test ERC20 Token\\\";\\n    string public constant SYMBOL = \\\"TT\\\";\\n\\n    constructor() ERC20WithPermit(NAME, SYMBOL) {}\\n}\\n\",\"keccak256\":\"0x05d5b0a7d4ad010e9c29cfeaff77f727dc3d714e4915e0dae22497dd890051b4\",\"license\":\"GPL-3.0-only\"},\"contracts/test/WormholeBridgeStub.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0-only\\n\\npragma solidity 0.8.17;\\n\\nimport \\\"./TestERC20.sol\\\";\\nimport \\\"../l2/L2WormholeGateway.sol\\\";\\n\\n/// @dev Stub contract used in L2WormholeGateway unit tests.\\n///      Stub contract is used instead of a smock because of the token transfer\\n///      that needs to happen in completeTransferWithPayload function.\\ncontract WormholeBridgeStub is IWormholeTokenBridge {\\n    TestERC20 public wormholeToken;\\n\\n    uint256 public transferAmount;\\n    bytes32 public receiverAddress;\\n\\n    // Two simple events allowing to assert Wormhole bridge functions are\\n    // called.\\n    event WormholeBridgeStub_completeTransferWithPayload(bytes encodedVm);\\n    event WormholeBridgeStub_transferTokens(\\n        address token,\\n        uint256 amount,\\n        uint16 recipientChain,\\n        bytes32 recipient,\\n        uint256 arbiterFee,\\n        uint32 nonce\\n    );\\n    event WormholeBridgeStub_transferTokensWithPayload(\\n        address token,\\n        uint256 amount,\\n        uint16 recipientChain,\\n        bytes32 recipient,\\n        uint32 nonce,\\n        bytes payload\\n    );\\n\\n    constructor(TestERC20 _wormholeToken) {\\n        wormholeToken = _wormholeToken;\\n    }\\n\\n    function completeTransferWithPayload(bytes memory encodedVm)\\n        external\\n        returns (bytes memory)\\n    {\\n        emit WormholeBridgeStub_completeTransferWithPayload(encodedVm);\\n        wormholeToken.mint(msg.sender, transferAmount);\\n\\n        // In a real implementation, encodedVm is parsed. To avoid copy-pasting\\n        // Wormhole code to this contract and then encoding parmaters in unit\\n        // tests, we allow to set the receiver address on the stub contract and\\n        // we return it here. The rest of the parameters does not matter.\\n        IWormholeTokenBridge.TransferWithPayload memory transfer = IWormholeTokenBridge\\n            .TransferWithPayload(\\n                1, // payloadID\\n                2, // amount\\n                0x3000000000000000000000000000000000000000000000000000000000000000, // tokenAddress\\n                4, // tokenChain\\n                0x5000000000000000000000000000000000000000000000000000000000000000, // to\\n                6, // toChain\\n                0x7000000000000000000000000000000000000000000000000000000000000000, // fromAddress\\n                abi.encode(receiverAddress) // payload\\n            );\\n\\n        return abi.encode(transfer);\\n    }\\n\\n    function transferTokens(\\n        address token,\\n        uint256 amount,\\n        uint16 recipientChain,\\n        bytes32 recipient,\\n        uint256 arbiterFee,\\n        uint32 nonce\\n    ) external payable returns (uint64 sequence) {\\n        emit WormholeBridgeStub_transferTokens(\\n            token,\\n            amount,\\n            recipientChain,\\n            recipient,\\n            arbiterFee,\\n            nonce\\n        );\\n        return 777;\\n    }\\n\\n    function transferTokensWithPayload(\\n        address token,\\n        uint256 amount,\\n        uint16 recipientChain,\\n        bytes32 recipient,\\n        uint32 nonce,\\n        bytes memory payload\\n    ) external payable returns (uint64 sequence) {\\n        emit WormholeBridgeStub_transferTokensWithPayload(\\n            token,\\n            amount,\\n            recipientChain,\\n            recipient,\\n            nonce,\\n            payload\\n        );\\n        return 888;\\n    }\\n\\n    function parseTransferWithPayload(bytes memory encoded)\\n        external\\n        pure\\n        returns (IWormholeTokenBridge.TransferWithPayload memory transfer)\\n    {\\n        return abi.decode(encoded, (IWormholeTokenBridge.TransferWithPayload));\\n    }\\n\\n    function setTransferAmount(uint256 _transferAmount) external {\\n        transferAmount = _transferAmount;\\n    }\\n\\n    function setReceiverAddress(bytes32 _receiverAddress) external {\\n        receiverAddress = _receiverAddress;\\n    }\\n\\n    // Allows to mint Wormhole tBTC for depositWormholeTbtc unit tests.\\n    function mintWormholeToken(address to, uint256 amount) external {\\n        wormholeToken.mint(to, amount);\\n    }\\n}\\n\",\"keccak256\":\"0xa040fbc4b5f912f8fcc01b9ec467bac64753657875dea39dfd3fd147e3674b3a\",\"license\":\"GPL-3.0-only\"}},\"version\":1}",
   "storageLayout": {
     "storage": [
       {
-        "astId": 41122,
+        "astId": 41078,
         "contract": "contracts/test/WormholeBridgeStub.sol:WormholeBridgeStub",
         "label": "wormholeToken",
         "offset": 0,
         "slot": "0",
-        "type": "t_contract(TestERC20)41058"
+        "type": "t_contract(TestERC20)41014"
       },
       {
-        "astId": 41124,
+        "astId": 41080,
         "contract": "contracts/test/WormholeBridgeStub.sol:WormholeBridgeStub",
         "label": "transferAmount",
         "offset": 0,
@@ -8631,7 +8631,7 @@
         "type": "t_uint256"
       },
       {
-        "astId": 41126,
+        "astId": 41082,
         "contract": "contracts/test/WormholeBridgeStub.sol:WormholeBridgeStub",
         "label": "receiverAddress",
         "offset": 0,
@@ -8645,7 +8645,7 @@
         "label": "bytes32",
         "numberOfBytes": "32"
       },
-      "t_contract(TestERC20)41058": {
+      "t_contract(TestERC20)41014": {
         "encoding": "inplace",
         "label": "contract TestERC20",
         "numberOfBytes": "20"