Created
April 28, 2025 00:44
-
-
Save FoobarProtocol/fe35110614a990871c4f20359d8bc540 to your computer and use it in GitHub Desktop.
This is the equivalent Yul code of the Gnosis Safe logic contract for version 1.1.1
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| // Decompiled by library.dedaub.com | |
| // 2025.04.18 18:07 UTC | |
| object "contract" { | |
| code { } | |
| object "runtime" { | |
| code { | |
| function func_0x311e(_0, _1, _2) -> ret_val_0, ret_val_1 { | |
| let _3 := mload(0x40) | |
| mstore(_3, _0) | |
| mstore(0x40, add(_3, add(0x20, mul(0x20, _0)))) | |
| let _4 := iszero(_0) | |
| if not(_4){ | |
| let _5 := add(0x20, _3) | |
| let _6 := mul(_0, 0x20) | |
| codecopy(_5, codesize(), _6) | |
| let _7 := add(_5, _6) | |
| } | |
| let _8 := 0x0 | |
| let _9 := 0x0 | |
| let _10 := 0x0 | |
| let _11 := 0x0 | |
| let _12 := 0x0 | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _1))) | |
| let _13 := add(0x20, 0x0) | |
| mstore(_13, 0x1) | |
| let _14 := sload(keccak256(0x0, add(0x20, _13))) | |
| let _15 := and(0xffffffffffffffffffffffffffffffffffffffff, div(_14, exp(0x100, 0x0))) | |
| let _16 := _15 | |
| let _17 := _15 | |
| let _18 := _15 | |
| let _19 := _15 | |
| let _20 := _15 | |
| for { | |
| let _22 := 0xffffffffffffffffffffffffffffffffffffffff | |
| let _23 := and(_22, _16) | |
| let _24 := 0xffffffffffffffffffffffffffffffffffffffff | |
| let _25 := 0x0 | |
| let _26 := and(_24, _25) | |
| let _27 := eq(_23, _26) | |
| let _28 := iszero(_27) | |
| let _21 := _28 | |
| let _29 := 0x1 | |
| let _30 := add(_29, _12) | |
| } | |
| not(iszero(_21)) | |
| { } | |
| { | |
| _25 := 0x0 | |
| _24 := 0xffffffffffffffffffffffffffffffffffffffff | |
| _26 := and(_24, _25) | |
| _22 := 0xffffffffffffffffffffffffffffffffffffffff | |
| _23 := and(_22, _16) | |
| _27 := eq(_23, _26) | |
| _28 := iszero(_27) | |
| let _31 := _28 | |
| _21 := _28 | |
| let _32 := iszero(_28) | |
| let _33 := iszero(_31) | |
| if not(_33){ | |
| _8 := _30 | |
| _21 := lt(_8, _0) | |
| } | |
| let _34 := not(iszero(_21)) | |
| if _34{ | |
| _9 := _30 | |
| mstore(_3, _9) | |
| ret_val_0 := _17 | |
| ret_val_1 := _3 | |
| leave | |
| break | |
| } | |
| if not(_34){ | |
| _10 := _30 | |
| let _35 := mload(_3) | |
| let _36 := lt(_10, _35) | |
| if _36{ | |
| _11 := _30 | |
| _12 := _30 | |
| mstore(add(add(0x20, mul(0x20, _11)), _3), and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _18))) | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _19))) | |
| let _37 := add(0x20, 0x0) | |
| mstore(_37, 0x1) | |
| let _38 := sload(keccak256(0x0, add(0x20, _37))) | |
| let _39 := and(0xffffffffffffffffffffffffffffffffffffffff, div(_38, exp(0x100, 0x0))) | |
| _16 := _39 | |
| _17 := _39 | |
| _18 := _39 | |
| _19 := _39 | |
| _20 := _39 | |
| _29 := 0x1 | |
| _30 := add(_29, _12) | |
| _8 := _30 | |
| _9 := _30 | |
| _10 := _30 | |
| _11 := _30 | |
| _12 := _30 | |
| } | |
| if not(_36){ | |
| invalid() | |
| } | |
| } | |
| let _40 := iszero(eq(and(0xffffffffffffffffffffffffffffffffffffffff, _20), and(0xffffffffffffffffffffffffffffffffffffffff, 0x1))) | |
| _31 := _40 | |
| _21 := _40 | |
| } | |
| } | |
| mstore(0x40, 0x80) | |
| let _41 := lt(calldatasize(), 0x4) | |
| if not(_41){ | |
| let _42 := shr(0xe0, calldataload(0x0)) | |
| let _43 := gt(0xaffed0e0, _42) | |
| if _43{ | |
| let _44 := gt(0x610b5925, _42) | |
| if _44{ | |
| let _45 := gt(0x2f54bf6e, _42) | |
| if _45{ | |
| let _46 := eq(0xa1028c4, _42) | |
| switch _42 | |
| case 0xa1028c4{ | |
| func_getMessageHash() | |
| } | |
| case 0xd582f13{ | |
| func_addOwnerWithThreshold() | |
| } | |
| case 0x20c13b0b{ | |
| func_isValidSignature() | |
| } | |
| default { } | |
| } | |
| if not(_45){ | |
| let _47 := eq(0x2f54bf6e, _42) | |
| switch _42 | |
| case 0x2f54bf6e{ | |
| func_isOwner() | |
| } | |
| case 0x468721a7{ | |
| func_execTransactionFromModule() | |
| } | |
| case 0x5229073f{ | |
| func_execTransactionFromModuleReturnData() | |
| } | |
| case 0x5ae6bd37{ | |
| func_signedMessages() | |
| } | |
| default { } | |
| } | |
| } | |
| if not(_44){ | |
| let _48 := gt(0x7de7edef, _42) | |
| if _48{ | |
| let _49 := eq(0x610b5925, _42) | |
| switch _42 | |
| case 0x610b5925{ | |
| func_enableModule() | |
| } | |
| case 0x694e80c3{ | |
| func_changeThreshold() | |
| } | |
| case 0x6a761202{ | |
| func_execTransaction() | |
| } | |
| case 0x7d832974{ | |
| func_approvedHashes() | |
| } | |
| default { } | |
| } | |
| if not(_48){ | |
| let _50 := eq(0x7de7edef, _42) | |
| switch _42 | |
| case 0x7de7edef{ | |
| func_changeMasterCopy() | |
| } | |
| case 0x85a5affe{ | |
| func_signMessage() | |
| } | |
| case 0xa0e67e2b{ | |
| func_getOwners() | |
| } | |
| case 0xa3f4df7e{ | |
| func_NAME() | |
| } | |
| default { } | |
| } | |
| } | |
| } | |
| if not(_43){ | |
| let _51 := gt(0xe009cfde, _42) | |
| if _51{ | |
| let _52 := gt(0xc4ca3a9c, _42) | |
| if _52{ | |
| let _53 := eq(0xaffed0e0, _42) | |
| switch _42 | |
| case 0xaffed0e0{ | |
| func_nonce() | |
| } | |
| case 0xb2494df3{ | |
| func_getModules() | |
| } | |
| case 0xb63e800d{ | |
| func_setup() | |
| } | |
| default { } | |
| } | |
| if not(_52){ | |
| let _54 := eq(0xc4ca3a9c, _42) | |
| switch _42 | |
| case 0xc4ca3a9c{ | |
| func_requiredTxGas() | |
| } | |
| case 0xcc2f8452{ | |
| func_getModulesPaginated() | |
| } | |
| case 0xd4d9bdcd{ | |
| func_approveHash() | |
| } | |
| case 0xd8d11f78{ | |
| func_getTransactionHash() | |
| } | |
| default { } | |
| } | |
| } | |
| if not(_51){ | |
| let _55 := gt(0xf08a0323, _42) | |
| if _55{ | |
| let _56 := eq(0xe009cfde, _42) | |
| switch _42 | |
| case 0xe009cfde{ | |
| func_disableModule() | |
| } | |
| case 0xe318b52b{ | |
| func_swapOwner() | |
| } | |
| case 0xe75235b8{ | |
| func_getThreshold() | |
| } | |
| case 0xe86637db{ | |
| func_encodeTransactionData() | |
| } | |
| default { } | |
| } | |
| if not(_55){ | |
| let _57 := eq(0xf08a0323, _42) | |
| switch _42 | |
| case 0xf08a0323{ | |
| func_setFallbackHandler() | |
| } | |
| case 0xf698da25{ | |
| func_domainSeparator() | |
| } | |
| case 0xf8dc5dd9{ | |
| func_removeOwner() | |
| } | |
| case 0xffa1ad74{ | |
| func_VERSION() | |
| } | |
| default { } | |
| } | |
| } | |
| } | |
| } | |
| func_fallback() | |
| function func_fallback() { | |
| let _58 := gt(callvalue(), 0x0) | |
| let _59 := _58 | |
| if not(_58){ | |
| _59 := eq(calldatasize(), 0x0) | |
| } | |
| let _60 := iszero(_59) | |
| if _60{ | |
| let _61 := sload(shl(0x0, 0x6c9a6c4a39284e37ed1cf53d337577d14212a4870fb976a4366c693b939918d5)) | |
| let _62 := eq(and(0xffffffffffffffffffffffffffffffffffffffff, _61), and(0xffffffffffffffffffffffffffffffffffffffff, 0x0)) | |
| if not(_62){ | |
| calldatacopy(0x0, 0x0, calldatasize()) | |
| let _63 := call(gas(), _61, 0x0, 0x0, calldatasize(), 0x0, 0x0) | |
| returndatacopy(0x0, 0x0, returndatasize()) | |
| let _64 := iszero(eq(_63, 0x0)) | |
| if _64{ | |
| return(0x0, returndatasize()) | |
| } | |
| if not(_64){ | |
| revert(0x0, returndatasize()) | |
| } | |
| } | |
| } | |
| stop() | |
| } | |
| function func_0x24af(_65, _66) { | |
| let _67 := eq(and(0xffffffffffffffffffffffffffffffffffffffff, caller()), and(0xffffffffffffffffffffffffffffffffffffffff, address())) | |
| if _67{ | |
| let _68 := sload(0x3) | |
| let _69 := iszero(gt(_65, _68)) | |
| if _69{ | |
| let _70 := iszero(lt(_65, 0x1)) | |
| if _70{ | |
| sstore(0x4, _65) | |
| let _71 := sload(0x4) | |
| let _72 := mload(0x40) | |
| mstore(_72, _71) | |
| let _73 := mload(0x40) | |
| log1(_73, sub(add(0x20, _72), _73), 0x610f7ff2b304ae8903c3de74c60c6ab1f7d6226b3f52c5161905bb5ad4039c93) | |
| leave | |
| } | |
| if not(_70){ | |
| let _74 := mload(0x40) | |
| mstore(_74, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _75 := add(0x4, _74) | |
| let _76 := add(0x20, _75) | |
| mstore(_75, sub(_76, _75)) | |
| mstore(_76, 0x24) | |
| let _77 := add(0x20, _76) | |
| codecopy(_77, 0x5c7a, 0x24) | |
| let _78 := mload(0x40) | |
| revert(_78, sub(add(0x40, _77), _78)) | |
| } | |
| } | |
| if not(_69){ | |
| let _79 := mload(0x40) | |
| mstore(_79, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _80 := add(0x4, _79) | |
| let _81 := add(0x20, _80) | |
| mstore(_80, sub(_81, _80)) | |
| mstore(_81, 0x23) | |
| let _82 := add(0x20, _81) | |
| codecopy(_82, 0x5ba4, 0x23) | |
| let _83 := mload(0x40) | |
| revert(_83, sub(add(0x40, _82), _83)) | |
| } | |
| } | |
| if not(_67){ | |
| let _84 := mload(0x40) | |
| mstore(_84, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _85 := add(0x4, _84) | |
| let _86 := add(0x20, _85) | |
| mstore(_85, sub(_86, _85)) | |
| mstore(_86, 0x2c) | |
| let _87 := add(0x20, _86) | |
| codecopy(_87, 0x5cd5, 0x2c) | |
| let _88 := mload(0x40) | |
| revert(_88, sub(add(0x40, _87), _88)) | |
| } | |
| } | |
| function func_0x470a(_89, _90, _91, _92, _93) { | |
| let _94 := 0x0 | |
| let _95 := 0x0 | |
| let _96 := 0x0 | |
| let _97 := 0x0 | |
| let _98 := 0x0 | |
| let _99 := 0x0 | |
| let _100 := sload(0x4) | |
| let _101 := gt(_100, 0x0) | |
| if _101{ | |
| let _102 := and(0xffffffff, 0x5938) | |
| let _103 := mload(_90) | |
| let _104 := iszero(lt(_103, func_0x5938(0x41, _100, 0x479b))) | |
| if _104{ | |
| let _105 := 0x0 | |
| let _106 := 0x0 | |
| let _107 := 0x0 | |
| let _108 := 0x0 | |
| for { | |
| let _109 := lt(_106, _100) | |
| let _110 := 0xffffffffffffffffffffffffffffffffffffffff | |
| let _111 := caller() | |
| let _112 := and(_110, _111) | |
| let _113 := 0xffffffffffffffffffffffffffffffffffffffff | |
| let _114 := 0x0 | |
| _99 := _94 | |
| _98 := _96 | |
| _97 := _96 | |
| let _115 := 0x0 | |
| let _116 := 0x41 | |
| let _117 := mul(_116, _107) | |
| let _118 := 0x20 | |
| let _119 := add(_117, _118) | |
| let _120 := add(_90, _119) | |
| let _121 := mload(_120) | |
| _96 := shr(_115, _121) | |
| _95 := _96 | |
| let _122 := 0x1 | |
| let _123 := add(_122, _108) | |
| let _124 := shr(_114, _121) | |
| let _125 := and(_113, _124) | |
| let _126 := eq(_112, _125) | |
| _94 := iszero(_126) | |
| } | |
| not(iszero(_109)) | |
| { } | |
| { | |
| _106 := _123 | |
| _109 := lt(_106, _100) | |
| let _127 := not(iszero(_109)) | |
| _107 := _123 | |
| _116 := 0x41 | |
| _117 := mul(_116, _107) | |
| _118 := 0x20 | |
| _119 := add(_117, _118) | |
| _120 := add(_90, _119) | |
| _121 := mload(_120) | |
| let _128 := mload(add(_90, add(_117, 0x40))) | |
| let _129 := mload(add(_90, add(_117, 0x41))) | |
| let _130 := and(_129, 0xff) | |
| let _131 := iszero(eq(and(0xff, _130), 0x0)) | |
| if _131{ | |
| let _132 := iszero(eq(and(0xff, _130), 0x1)) | |
| if _132{ | |
| let _133 := iszero(gt(and(0xff, _130), 0x1e)) | |
| if _133{ | |
| let _134 := mload(0x40) | |
| mstore(_134, 0x0) | |
| mstore(0x40, add(0x20, _134)) | |
| let _135 := mload(0x40) | |
| mstore(_135, _92) | |
| let _136 := add(0x20, _135) | |
| mstore(_136, and(0xff, and(0xff, _130))) | |
| let _137 := add(0x20, _136) | |
| mstore(_137, _121) | |
| let _138 := add(0x20, _137) | |
| mstore(_138, _128) | |
| let _139 := mload(0x40) | |
| let _140 := staticcall(gas(), 0x1, _139, sub(add(0x20, _138), _139), sub(_139, 0x20), 0x20) | |
| let _141 := iszero(iszero(_140)) | |
| if _141{ | |
| let _142 := mload(0x40) | |
| let _143 := mload(sub(_142, 0x20)) | |
| _105 := _143 | |
| _98 := _143 | |
| _97 := _143 | |
| _95 := _143 | |
| } | |
| if not(_141){ | |
| returndatacopy(0x0, 0x0, returndatasize()) | |
| revert(0x0, returndatasize()) | |
| } | |
| } | |
| if not(_133){ | |
| let _144 := mload(0x40) | |
| let _145 := add(0x20, _144) | |
| mstore(_145, 0x19457468657265756d205369676e6564204d6573736167653a0a333200000000) | |
| let _146 := add(0x1c, _145) | |
| mstore(_146, _92) | |
| let _147 := add(0x20, _146) | |
| let _148 := mload(0x40) | |
| mstore(_148, sub(sub(_147, _148), 0x20)) | |
| mstore(0x40, _147) | |
| let _149 := mload(_148) | |
| let _150 := mload(0x40) | |
| mstore(_150, 0x0) | |
| mstore(0x40, add(0x20, _150)) | |
| let _151 := mload(0x40) | |
| mstore(_151, keccak256(add(0x20, _148), _149)) | |
| let _152 := add(0x20, _151) | |
| mstore(_152, and(0xff, and(0xff, sub(_130, 0x4)))) | |
| let _153 := add(0x20, _152) | |
| mstore(_153, _121) | |
| let _154 := add(0x20, _153) | |
| mstore(_154, _128) | |
| let _155 := mload(0x40) | |
| let _156 := staticcall(gas(), 0x1, _155, sub(add(0x20, _154), _155), sub(_155, 0x20), 0x20) | |
| let _157 := iszero(iszero(_156)) | |
| if _157{ | |
| let _158 := mload(0x40) | |
| let _159 := mload(sub(_158, 0x20)) | |
| _105 := _159 | |
| _98 := _159 | |
| _97 := _159 | |
| _95 := _159 | |
| } | |
| if not(_157){ | |
| returndatacopy(0x0, 0x0, returndatasize()) | |
| revert(0x0, returndatasize()) | |
| } | |
| } | |
| } | |
| if not(_132){ | |
| _114 := 0x0 | |
| _124 := shr(_114, _121) | |
| _105 := _124 | |
| _98 := _124 | |
| _97 := _124 | |
| _95 := _124 | |
| let _160 := eq(and(0xffffffffffffffffffffffffffffffffffffffff, caller()), and(0xffffffffffffffffffffffffffffffffffffffff, _124)) | |
| let _161 := _160 | |
| if not(_160){ | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _124))) | |
| let _162 := add(0x20, 0x0) | |
| mstore(_162, 0x8) | |
| mstore(0x0, _92) | |
| let _163 := add(0x20, 0x0) | |
| mstore(_163, keccak256(0x0, add(0x20, _162))) | |
| let _164 := sload(keccak256(0x0, add(0x20, _163))) | |
| _161 := iszero(eq(_164, 0x0)) | |
| } | |
| if _161{ | |
| let _165 := iszero(_89) | |
| if not(_165){ | |
| _113 := 0xffffffffffffffffffffffffffffffffffffffff | |
| _125 := and(_113, _124) | |
| _111 := caller() | |
| _110 := 0xffffffffffffffffffffffffffffffffffffffff | |
| _112 := and(_110, _111) | |
| _126 := eq(_112, _125) | |
| _94 := iszero(_126) | |
| _99 := _94 | |
| } | |
| let _166 := iszero(_99) | |
| if not(_166){ | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _124))) | |
| let _167 := add(0x20, 0x0) | |
| mstore(_167, 0x8) | |
| mstore(0x0, _92) | |
| let _168 := add(0x20, 0x0) | |
| mstore(_168, keccak256(0x0, add(0x20, _167))) | |
| sstore(keccak256(0x0, add(0x20, _168)), 0x0) | |
| } | |
| } | |
| if not(_161){ | |
| let _169 := mload(0x40) | |
| mstore(_169, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _170 := add(0x4, _169) | |
| let _171 := add(0x20, _170) | |
| mstore(_170, sub(_171, _170)) | |
| mstore(_171, 0x1a) | |
| let _172 := add(0x20, _171) | |
| mstore(_172, 0x4861736820686173206e6f74206265656e20617070726f766564000000000000) | |
| let _173 := mload(0x40) | |
| revert(_173, sub(add(0x20, _172), _173)) | |
| } | |
| } | |
| } | |
| if not(_131){ | |
| _115 := 0x0 | |
| _96 := shr(_115, _121) | |
| _105 := _96 | |
| _98 := _96 | |
| _97 := _96 | |
| _95 := _96 | |
| let _174 := and(0xffffffff, 0x5938) | |
| let _175 := iszero(lt(shr(0x0, _128), func_0x5938(0x41, _100, 0x4866))) | |
| if _175{ | |
| let _176 := mload(_90) | |
| let _177 := and(0xffffffff, 0x59a1) | |
| let _178 := iszero(gt(func_0x59a1(0x20, shr(0x0, _128), 0x48da), _176)) | |
| if _178{ | |
| let _179 := mload(add(add(_90, _128), 0x20)) | |
| let _180 := mload(_90) | |
| let _181 := and(0xffffffff, 0x59a1) | |
| let _182 := and(0xffffffff, 0x59a1) | |
| let _183 := iszero(gt(func_0x59a1(_179, func_0x59a1(0x20, shr(0x0, _128), 0x4959), 0x4967), _180)) | |
| if _183{ | |
| let _184 := add(add(_90, _128), 0x20) | |
| let _185 := and(0xffffffffffffffffffffffffffffffffffffffff, _96) | |
| let _186 := mload(0x40) | |
| mstore(_186, shl(0xe0, and(0xffffffff, 0x20c13b0b))) | |
| let _187 := add(0x4, _186) | |
| let _188 := add(0x20, _187) | |
| let _189 := add(0x20, _188) | |
| mstore(_187, sub(_189, _187)) | |
| let _190 := mload(_91) | |
| mstore(_189, _190) | |
| let _191 := add(0x20, _189) | |
| let _192 := mload(_91) | |
| let _193 := 0x0 | |
| let _194 := 0x0 | |
| for { | |
| let _195 := lt(_193, _192) | |
| let _196 := 0x20 | |
| let _197 := add(_194, _196) | |
| } | |
| not(iszero(_195)) | |
| { } | |
| { | |
| _193 := _197 | |
| _195 := lt(_193, _192) | |
| let _198 := not(iszero(_195)) | |
| _194 := _197 | |
| let _199 := mload(add(add(0x20, _91), _194)) | |
| mstore(add(_191, _194), _199) | |
| _196 := 0x20 | |
| _197 := add(_194, _196) | |
| _193 := _197 | |
| _194 := _197 | |
| } | |
| let _200 := add(_192, _191) | |
| let _201 := _200 | |
| let _202 := and(0x1f, _192) | |
| let _203 := iszero(_202) | |
| if not(_203){ | |
| let _204 := sub(_200, _202) | |
| let _205 := mload(_204) | |
| mstore(_204, and(not(sub(exp(0x100, sub(0x20, _202)), 0x1)), _205)) | |
| _201 := add(0x20, _204) | |
| } | |
| mstore(_188, sub(_201, _187)) | |
| let _206 := mload(_184) | |
| mstore(_201, _206) | |
| let _207 := add(0x20, _201) | |
| let _208 := mload(_184) | |
| let _209 := 0x0 | |
| let _210 := 0x0 | |
| for { | |
| let _211 := lt(_209, _208) | |
| let _212 := 0x20 | |
| let _213 := add(_210, _212) | |
| } | |
| not(iszero(_211)) | |
| { } | |
| { | |
| _209 := _213 | |
| _211 := lt(_209, _208) | |
| let _214 := not(iszero(_211)) | |
| _210 := _213 | |
| let _215 := mload(add(add(0x20, _184), _210)) | |
| mstore(add(_207, _210), _215) | |
| _212 := 0x20 | |
| _213 := add(_210, _212) | |
| _209 := _213 | |
| _210 := _213 | |
| } | |
| let _216 := add(_208, _207) | |
| let _217 := _216 | |
| let _218 := and(0x1f, _208) | |
| let _219 := iszero(_218) | |
| if not(_219){ | |
| let _220 := sub(_216, _218) | |
| let _221 := mload(_220) | |
| mstore(_220, and(not(sub(exp(0x100, sub(0x20, _218)), 0x1)), _221)) | |
| _217 := add(0x20, _220) | |
| } | |
| let _222 := mload(0x40) | |
| let _223 := iszero(iszero(extcodesize(_185))) | |
| require(not(_223)) | |
| let _224 := staticcall(gas(), _185, _222, sub(_217, _222), _222, 0x20) | |
| let _225 := iszero(iszero(_224)) | |
| if _225{ | |
| let _226 := mload(0x40) | |
| let _227 := returndatasize() | |
| let _228 := iszero(lt(_227, 0x20)) | |
| require(not(_228)) | |
| let _229 := add(_226, _227) | |
| let _230 := mload(_226) | |
| let _231 := add(0x20, _226) | |
| let _232 := eq(and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff), _230), and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff), shl(0xe0, 0x20c13b0b))) | |
| if not(_232){ | |
| let _233 := mload(0x40) | |
| mstore(_233, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _234 := add(0x4, _233) | |
| let _235 := add(0x20, _234) | |
| mstore(_234, sub(_235, _234)) | |
| mstore(_235, 0x23) | |
| let _236 := add(0x20, _235) | |
| codecopy(_236, 0x5b59, 0x23) | |
| let _237 := mload(0x40) | |
| revert(_237, sub(add(0x40, _236), _237)) | |
| } | |
| } | |
| if not(_225){ | |
| returndatacopy(0x0, 0x0, returndatasize()) | |
| revert(0x0, returndatasize()) | |
| } | |
| } | |
| if not(_183){ | |
| let _238 := mload(0x40) | |
| mstore(_238, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _239 := add(0x4, _238) | |
| let _240 := add(0x20, _239) | |
| mstore(_239, sub(_240, _239)) | |
| mstore(_240, 0x36) | |
| let _241 := add(0x20, _240) | |
| codecopy(_241, 0x5c44, 0x36) | |
| let _242 := mload(0x40) | |
| revert(_242, sub(add(0x40, _241), _242)) | |
| } | |
| } | |
| if not(_178){ | |
| let _243 := mload(0x40) | |
| mstore(_243, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _244 := add(0x4, _243) | |
| let _245 := add(0x20, _244) | |
| mstore(_244, sub(_245, _244)) | |
| mstore(_245, 0x37) | |
| let _246 := add(0x20, _245) | |
| codecopy(_246, 0x5d31, 0x37) | |
| let _247 := mload(0x40) | |
| revert(_247, sub(add(0x40, _246), _247)) | |
| } | |
| } | |
| if not(_175){ | |
| let _248 := mload(0x40) | |
| mstore(_248, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _249 := add(0x4, _248) | |
| let _250 := add(0x20, _249) | |
| mstore(_249, sub(_250, _249)) | |
| mstore(_250, 0x37) | |
| let _251 := add(0x20, _250) | |
| codecopy(_251, 0x5c9e, 0x37) | |
| let _252 := mload(0x40) | |
| revert(_252, sub(add(0x40, _251), _252)) | |
| } | |
| } | |
| let _253 := gt(and(0xffffffffffffffffffffffffffffffffffffffff, _98), and(0xffffffffffffffffffffffffffffffffffffffff, _105)) | |
| let _254 := _253 | |
| let _255 := _253 | |
| let _256 := iszero(_253) | |
| if not(_256){ | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _97))) | |
| let _257 := add(0x20, 0x0) | |
| mstore(_257, 0x2) | |
| let _258 := sload(keccak256(0x0, add(0x20, _257))) | |
| let _259 := iszero(eq(and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, div(_258, exp(0x100, 0x0)))), and(0xffffffffffffffffffffffffffffffffffffffff, 0x0))) | |
| _254 := _259 | |
| _255 := _259 | |
| } | |
| let _260 := iszero(_255) | |
| if not(_260){ | |
| _254 := iszero(eq(and(0xffffffffffffffffffffffffffffffffffffffff, _95), and(0xffffffffffffffffffffffffffffffffffffffff, 0x1))) | |
| } | |
| if _254{ | |
| _108 := _123 | |
| _122 := 0x1 | |
| _123 := add(_122, _108) | |
| _106 := _123 | |
| _107 := _123 | |
| _108 := _123 | |
| } | |
| if not(_254){ | |
| let _261 := mload(0x40) | |
| mstore(_261, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _262 := add(0x4, _261) | |
| let _263 := add(0x20, _262) | |
| mstore(_262, sub(_263, _262)) | |
| mstore(_263, 0x16) | |
| let _264 := add(0x20, _263) | |
| mstore(_264, 0x496e76616c6964206f776e65722070726f766964656400000000000000000000) | |
| let _265 := mload(0x40) | |
| revert(_265, sub(add(0x20, _264), _265)) | |
| break | |
| } | |
| } | |
| leave | |
| } | |
| if not(_104){ | |
| let _266 := mload(0x40) | |
| mstore(_266, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _267 := add(0x4, _266) | |
| let _268 := add(0x20, _267) | |
| mstore(_267, sub(_268, _267)) | |
| mstore(_268, 0x19) | |
| let _269 := add(0x20, _268) | |
| mstore(_269, 0x5369676e617475726573206461746120746f6f2073686f727400000000000000) | |
| let _270 := mload(0x40) | |
| revert(_270, sub(add(0x20, _269), _270)) | |
| } | |
| } | |
| if not(_101){ | |
| let _271 := mload(0x40) | |
| mstore(_271, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _272 := add(0x4, _271) | |
| let _273 := add(0x20, _272) | |
| mstore(_272, sub(_273, _272)) | |
| mstore(_273, 0x1e) | |
| let _274 := add(0x20, _273) | |
| mstore(_274, 0x5468726573686f6c64206e6565647320746f20626520646566696e6564210000) | |
| let _275 := mload(0x40) | |
| revert(_275, sub(add(0x20, _274), _275)) | |
| } | |
| } | |
| function func_0x50ca(_276, _277, _278, _279, _280, _281) -> ret_val_0 { | |
| let _282 := 0x0 | |
| let _283 := 0x0 | |
| let _284 := 0x0 | |
| let _285 := 0x0 | |
| let _286 := 0x0 | |
| let _287 := 0x0 | |
| let _288 := eq(and(0xffffffffffffffffffffffffffffffffffffffff, _276), and(0xffffffffffffffffffffffffffffffffffffffff, 0x0)) | |
| if _288{ | |
| let _289 := origin() | |
| _287 := _289 | |
| _286 := _289 | |
| } | |
| let _290 := iszero(eq(and(0xffffffffffffffffffffffffffffffffffffffff, _277), and(0xffffffffffffffffffffffffffffffffffffffff, 0x0))) | |
| if _290{ | |
| let _291 := and(0xffffffff, 0x59a1) | |
| let _292 := and(0xffffffff, 0x5938) | |
| let _293 := func_0x5938(_278, func_0x59a1(_279, _280, 0x521b), 0x5229) | |
| _285 := _293 | |
| let _294 := func_0x59f0(_293, _287, _277, 0x5236) | |
| if not(_294){ | |
| let _295 := mload(0x40) | |
| mstore(_295, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _296 := add(0x4, _295) | |
| let _297 := add(0x20, _296) | |
| mstore(_296, sub(_297, _296)) | |
| mstore(_297, 0x22) | |
| let _298 := add(0x20, _297) | |
| codecopy(_298, 0x5bfc, 0x22) | |
| let _299 := mload(0x40) | |
| revert(_299, sub(add(0x40, _298), _299)) | |
| } | |
| } | |
| if not(_290){ | |
| let _300 := lt(_278, gasprice()) | |
| if not(_300){ | |
| let _301 := gasprice() | |
| _284 := _301 | |
| _283 := _301 | |
| } | |
| let _302 := and(0xffffffff, 0x59a1) | |
| let _303 := func_0x59a1(_279, _280, 0x5165) | |
| let _304 := and(0xffffffff, 0x5938) | |
| let _305 := iszero(eq(_303, 0x0)) | |
| if _305{ | |
| let _306 := mul(_303, _284) | |
| _282 := _306 | |
| _285 := _306 | |
| if _303{ | |
| let _307 := eq(div(_306, _303), _283) | |
| require(not(_307)) | |
| } | |
| if not(_303){ | |
| invalid() | |
| } | |
| } | |
| if not(_305){ | |
| _282 := 0x0 | |
| _285 := 0x0 | |
| } | |
| let _308 := mload(0x40) | |
| let _309 := mload(0x40) | |
| let _310 := call(mul(iszero(_282), 0x8fc), and(0xffffffffffffffffffffffffffffffffffffffff, _286), _282, _309, sub(_308, _309), _309, 0x0) | |
| if not(_310){ | |
| let _311 := mload(0x40) | |
| mstore(_311, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _312 := add(0x4, _311) | |
| let _313 := add(0x20, _312) | |
| mstore(_312, sub(_313, _312)) | |
| mstore(_313, 0x22) | |
| let _314 := add(0x20, _313) | |
| codecopy(_314, 0x5d68, 0x22) | |
| let _315 := mload(0x40) | |
| revert(_315, sub(add(0x40, _314), _315)) | |
| } | |
| } | |
| ret_val_0 := _285 | |
| leave | |
| } | |
| function func_0x5938(_316, _317, _318) -> ret_val_0 { | |
| let _319 := 0x0 | |
| let _320 := iszero(eq(_317, 0x0)) | |
| if _320{ | |
| let _321 := mul(_317, _316) | |
| _319 := _321 | |
| if _317{ | |
| let _322 := eq(div(_321, _317), _316) | |
| require(not(_322)) | |
| } | |
| if not(_317){ | |
| invalid() | |
| } | |
| } | |
| if not(_320){ | |
| _319 := 0x0 | |
| } | |
| ret_val_0 := _319 | |
| leave | |
| } | |
| function func_0x59a1(_323, _324, _325) -> ret_val_0 { | |
| let _326 := add(_324, _323) | |
| let _327 := iszero(lt(_326, _324)) | |
| require(not(_327)) | |
| ret_val_0 := _326 | |
| leave | |
| } | |
| function func_0x59f0(_328, _329, _330, _331) -> ret_val_0 { | |
| let _332 := mload(0x40) | |
| let _333 := add(0x24, _332) | |
| mstore(_333, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _329))) | |
| let _334 := add(0x20, _333) | |
| mstore(_334, _328) | |
| let _335 := add(0x20, _334) | |
| let _336 := mload(0x40) | |
| mstore(_336, sub(sub(_335, _336), 0x20)) | |
| mstore(0x40, _335) | |
| let _337 := add(_336, 0x20) | |
| let _338 := mload(_337) | |
| mstore(_337, or(and(_338, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff), and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff), 0xa9059cbb00000000000000000000000000000000000000000000000000000000))) | |
| let _339 := mload(_336) | |
| let _340 := call(sub(gas(), 0x2710), _330, 0x0, add(_336, 0x20), _339, 0x0, 0x0) | |
| let _341 := mload(0x40) | |
| mstore(0x40, add(_341, returndatasize())) | |
| returndatacopy(_341, 0x0, returndatasize()) | |
| let _342 := returndatasize() | |
| let _343 := eq(_342, 0x0) | |
| switch _342 | |
| case 0x0{ | |
| ret_val_0 := _340 | |
| leave | |
| } | |
| case 0x20{ | |
| let _344 := mload(_341) | |
| let _345 := iszero(or(iszero(_340), iszero(_344))) | |
| leave | |
| } | |
| default { | |
| leave | |
| } | |
| } | |
| function func_getMessageHash() { | |
| let _346 := iszero(callvalue()) | |
| require(not(_346)) | |
| let _347 := sub(calldatasize(), 0x4) | |
| let _348 := iszero(lt(_347, 0x20)) | |
| require(not(_348)) | |
| let _349 := add(0x4, _347) | |
| let _350 := calldataload(0x4) | |
| let _351 := add(0x20, 0x4) | |
| let _352 := iszero(gt(_350, 0x100000000)) | |
| require(not(_352)) | |
| let _353 := add(0x4, _350) | |
| let _354 := iszero(gt(add(_353, 0x20), _349)) | |
| require(not(_354)) | |
| let _355 := calldataload(_353) | |
| let _356 := add(0x20, _353) | |
| let _357 := iszero(or(gt(_355, 0x100000000), gt(add(_356, mul(_355, 0x1)), _349))) | |
| require(not(_357)) | |
| let _358 := mload(0x40) | |
| mstore(0x40, add(_358, add(0x20, mul(div(add(0x1f, _355), 0x20), 0x20)))) | |
| mstore(_358, _355) | |
| let _359 := add(0x20, _358) | |
| calldatacopy(_359, _356, _355) | |
| mstore(add(_359, _355), 0x0) | |
| let _360 := add(_359, and(add(_355, 0x1f), not(0x1f))) | |
| let _361 := mload(_358) | |
| let _362 := mload(0x40) | |
| let _363 := add(0x20, _362) | |
| mstore(_363, shl(0x0, 0x60b3cbf8b4a223d68d641b3b6ddf9a298e7f33710cf3d3a9d1146b5a6150fbca)) | |
| let _364 := add(0x20, _363) | |
| mstore(_364, keccak256(add(0x20, _358), _361)) | |
| let _365 := add(0x20, _364) | |
| let _366 := mload(0x40) | |
| mstore(_366, sub(sub(_365, _366), 0x20)) | |
| mstore(0x40, _365) | |
| let _367 := mload(_366) | |
| let _368 := sload(0x6) | |
| let _369 := mload(0x40) | |
| let _370 := add(0x20, _369) | |
| mstore(_370, and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), shl(0xf8, 0x19)))) | |
| let _371 := add(0x1, _370) | |
| mstore(_371, and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), shl(0xf8, 0x1)))) | |
| let _372 := add(0x1, _371) | |
| mstore(_372, _368) | |
| let _373 := add(0x20, _372) | |
| mstore(_373, keccak256(add(0x20, _366), _367)) | |
| let _374 := add(0x20, _373) | |
| let _375 := mload(0x40) | |
| mstore(_375, sub(sub(_374, _375), 0x20)) | |
| mstore(0x40, _374) | |
| let _376 := mload(_375) | |
| let _377 := mload(0x40) | |
| mstore(_377, keccak256(add(0x20, _375), _376)) | |
| let _378 := mload(0x40) | |
| return(_378, sub(add(0x20, _377), _378)) | |
| } | |
| function func_addOwnerWithThreshold() { | |
| let _379 := iszero(callvalue()) | |
| require(not(_379)) | |
| let _380 := sub(calldatasize(), 0x4) | |
| let _381 := iszero(lt(_380, 0x40)) | |
| require(not(_381)) | |
| let _382 := add(0x4, _380) | |
| let _383 := and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(0x4)) | |
| let _384 := add(0x20, 0x4) | |
| let _385 := calldataload(_384) | |
| let _386 := add(0x20, _384) | |
| let _387 := eq(and(0xffffffffffffffffffffffffffffffffffffffff, caller()), and(0xffffffffffffffffffffffffffffffffffffffff, address())) | |
| if _387{ | |
| let _388 := iszero(eq(and(0xffffffffffffffffffffffffffffffffffffffff, _383), and(0xffffffffffffffffffffffffffffffffffffffff, 0x0))) | |
| let _389 := _388 | |
| let _390 := iszero(_388) | |
| if not(_390){ | |
| _389 := iszero(eq(and(0xffffffffffffffffffffffffffffffffffffffff, _383), and(0xffffffffffffffffffffffffffffffffffffffff, 0x1))) | |
| } | |
| if _389{ | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _383))) | |
| let _391 := add(0x20, 0x0) | |
| mstore(_391, 0x2) | |
| let _392 := sload(keccak256(0x0, add(0x20, _391))) | |
| let _393 := eq(and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, div(_392, exp(0x100, 0x0)))), and(0xffffffffffffffffffffffffffffffffffffffff, 0x0)) | |
| if _393{ | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, 0x1))) | |
| let _394 := add(0x20, 0x0) | |
| mstore(_394, 0x2) | |
| let _395 := sload(keccak256(0x0, add(0x20, _394))) | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _383))) | |
| let _396 := add(0x20, 0x0) | |
| mstore(_396, 0x2) | |
| let _397 := keccak256(0x0, add(0x20, _396)) | |
| let _398 := exp(0x100, 0x0) | |
| let _399 := sload(_397) | |
| sstore(_397, or(mul(and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, div(_395, exp(0x100, 0x0)))), _398), and(not(mul(0xffffffffffffffffffffffffffffffffffffffff, _398)), _399))) | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, 0x1))) | |
| let _400 := add(0x20, 0x0) | |
| mstore(_400, 0x2) | |
| let _401 := keccak256(0x0, add(0x20, _400)) | |
| let _402 := exp(0x100, 0x0) | |
| let _403 := sload(_401) | |
| sstore(_401, or(mul(and(0xffffffffffffffffffffffffffffffffffffffff, _383), _402), and(not(mul(0xffffffffffffffffffffffffffffffffffffffff, _402)), _403))) | |
| let _404 := sload(0x3) | |
| sstore(0x3, add(0x1, _404)) | |
| let _405 := mload(0x40) | |
| mstore(_405, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _383))) | |
| let _406 := mload(0x40) | |
| log1(_406, sub(add(0x20, _405), _406), 0x9465fa0c962cc76958e6373a993326400c1c94f8be2fe3a952adfa7f60b2ea26) | |
| let _407 := sload(0x4) | |
| let _408 := eq(_407, _385) | |
| if not(_408){ | |
| func_0x24af(_385, 0x1c07) | |
| } | |
| stop() | |
| } | |
| if not(_393){ | |
| let _409 := mload(0x40) | |
| mstore(_409, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _410 := add(0x4, _409) | |
| let _411 := add(0x20, _410) | |
| mstore(_410, sub(_411, _410)) | |
| mstore(_411, 0x1b) | |
| let _412 := add(0x20, _411) | |
| mstore(_412, 0x4164647265737320697320616c726561647920616e206f776e65720000000000) | |
| let _413 := mload(0x40) | |
| revert(_413, sub(add(0x20, _412), _413)) | |
| } | |
| } | |
| if not(_389){ | |
| let _414 := mload(0x40) | |
| mstore(_414, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _415 := add(0x4, _414) | |
| let _416 := add(0x20, _415) | |
| mstore(_415, sub(_416, _415)) | |
| mstore(_416, 0x1e) | |
| let _417 := add(0x20, _416) | |
| mstore(_417, 0x496e76616c6964206f776e657220616464726573732070726f76696465640000) | |
| let _418 := mload(0x40) | |
| revert(_418, sub(add(0x20, _417), _418)) | |
| } | |
| } | |
| if not(_387){ | |
| let _419 := mload(0x40) | |
| mstore(_419, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _420 := add(0x4, _419) | |
| let _421 := add(0x20, _420) | |
| mstore(_420, sub(_421, _420)) | |
| mstore(_421, 0x2c) | |
| let _422 := add(0x20, _421) | |
| codecopy(_422, 0x5cd5, 0x2c) | |
| let _423 := mload(0x40) | |
| revert(_423, sub(add(0x40, _422), _423)) | |
| } | |
| } | |
| function func_isValidSignature() { | |
| let _424 := iszero(callvalue()) | |
| require(not(_424)) | |
| let _425 := sub(calldatasize(), 0x4) | |
| let _426 := iszero(lt(_425, 0x40)) | |
| require(not(_426)) | |
| let _427 := add(0x4, _425) | |
| let _428 := calldataload(0x4) | |
| let _429 := add(0x20, 0x4) | |
| let _430 := iszero(gt(_428, 0x100000000)) | |
| require(not(_430)) | |
| let _431 := add(0x4, _428) | |
| let _432 := iszero(gt(add(_431, 0x20), _427)) | |
| require(not(_432)) | |
| let _433 := calldataload(_431) | |
| let _434 := add(0x20, _431) | |
| let _435 := iszero(or(gt(_433, 0x100000000), gt(add(_434, mul(_433, 0x1)), _427))) | |
| require(not(_435)) | |
| let _436 := calldataload(_429) | |
| let _437 := add(0x20, _429) | |
| let _438 := iszero(gt(_436, 0x100000000)) | |
| require(not(_438)) | |
| let _439 := add(0x4, _436) | |
| let _440 := iszero(gt(add(_439, 0x20), _427)) | |
| require(not(_440)) | |
| let _441 := calldataload(_439) | |
| let _442 := add(0x20, _439) | |
| let _443 := iszero(or(gt(_441, 0x100000000), gt(add(_442, mul(_441, 0x1)), _427))) | |
| require(not(_443)) | |
| let _444 := mload(0x40) | |
| mstore(0x40, add(_444, add(0x20, mul(div(add(0x1f, _433), 0x20), 0x20)))) | |
| mstore(_444, _433) | |
| let _445 := add(0x20, _444) | |
| calldatacopy(_445, _434, _433) | |
| mstore(add(_445, _433), 0x0) | |
| let _446 := add(_445, and(add(_433, 0x1f), not(0x1f))) | |
| let _447 := mload(_444) | |
| let _448 := mload(0x40) | |
| let _449 := add(0x20, _448) | |
| mstore(_449, shl(0x0, 0x60b3cbf8b4a223d68d641b3b6ddf9a298e7f33710cf3d3a9d1146b5a6150fbca)) | |
| let _450 := add(0x20, _449) | |
| mstore(_450, keccak256(add(0x20, _444), _447)) | |
| let _451 := add(0x20, _450) | |
| let _452 := mload(0x40) | |
| mstore(_452, sub(sub(_451, _452), 0x20)) | |
| mstore(0x40, _451) | |
| let _453 := mload(_452) | |
| let _454 := sload(0x6) | |
| let _455 := mload(0x40) | |
| let _456 := add(0x20, _455) | |
| mstore(_456, and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), shl(0xf8, 0x19)))) | |
| let _457 := add(0x1, _456) | |
| mstore(_457, and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), shl(0xf8, 0x1)))) | |
| let _458 := add(0x1, _457) | |
| mstore(_458, _454) | |
| let _459 := add(0x20, _458) | |
| mstore(_459, keccak256(add(0x20, _452), _453)) | |
| let _460 := add(0x20, _459) | |
| let _461 := mload(0x40) | |
| mstore(_461, sub(sub(_460, _461), 0x20)) | |
| mstore(0x40, _460) | |
| let _462 := mload(_461) | |
| let _463 := keccak256(add(0x20, _461), _462) | |
| let _464 := iszero(eq(_441, 0x0)) | |
| if _464{ | |
| let _465 := mload(0x40) | |
| mstore(0x40, add(_465, add(0x20, mul(div(add(0x1f, _433), 0x20), 0x20)))) | |
| mstore(_465, _433) | |
| let _466 := add(0x20, _465) | |
| calldatacopy(_466, _434, _433) | |
| mstore(add(_466, _433), 0x0) | |
| let _467 := add(_466, and(add(_433, 0x1f), not(0x1f))) | |
| let _468 := mload(0x40) | |
| mstore(0x40, add(_468, add(0x20, mul(div(add(0x1f, _441), 0x20), 0x20)))) | |
| mstore(_468, _441) | |
| let _469 := add(0x20, _468) | |
| calldatacopy(_469, _442, _441) | |
| mstore(add(_469, _441), 0x0) | |
| let _470 := add(_469, and(add(_441, 0x1f), not(0x1f))) | |
| func_0x470a(0x0, _468, _465, _463, 0x1d8e) | |
| } | |
| if not(_464){ | |
| mstore(0x0, _463) | |
| let _471 := add(0x20, 0x0) | |
| mstore(_471, 0x7) | |
| let _472 := sload(keccak256(0x0, add(0x20, _471))) | |
| let _473 := iszero(eq(_472, 0x0)) | |
| if not(_473){ | |
| let _474 := mload(0x40) | |
| mstore(_474, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _475 := add(0x4, _474) | |
| let _476 := add(0x20, _475) | |
| mstore(_475, sub(_476, _475)) | |
| mstore(_476, 0x11) | |
| let _477 := add(0x20, _476) | |
| mstore(_477, 0x48617368206e6f7420617070726f766564000000000000000000000000000000) | |
| let _478 := mload(0x40) | |
| revert(_478, sub(add(0x20, _477), _478)) | |
| } | |
| } | |
| let _479 := mload(0x40) | |
| mstore(_479, and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff), and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff), shl(0xe0, 0x20c13b0b)))) | |
| let _480 := mload(0x40) | |
| return(_480, sub(add(0x20, _479), _480)) | |
| } | |
| function func_isOwner() { | |
| let _481 := iszero(callvalue()) | |
| require(not(_481)) | |
| let _482 := sub(calldatasize(), 0x4) | |
| let _483 := iszero(lt(_482, 0x20)) | |
| require(not(_483)) | |
| let _484 := add(0x4, _482) | |
| let _485 := and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(0x4)) | |
| let _486 := add(0x20, 0x4) | |
| let _487 := iszero(eq(and(0xffffffffffffffffffffffffffffffffffffffff, _485), and(0xffffffffffffffffffffffffffffffffffffffff, 0x1))) | |
| let _488 := _487 | |
| let _489 := iszero(_487) | |
| if not(_489){ | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _485))) | |
| let _490 := add(0x20, 0x0) | |
| mstore(_490, 0x2) | |
| let _491 := sload(keccak256(0x0, add(0x20, _490))) | |
| _488 := iszero(eq(and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, div(_491, exp(0x100, 0x0)))), and(0xffffffffffffffffffffffffffffffffffffffff, 0x0))) | |
| } | |
| let _492 := mload(0x40) | |
| mstore(_492, iszero(iszero(iszero(iszero(_488))))) | |
| let _493 := mload(0x40) | |
| return(_493, sub(add(0x20, _492), _493)) | |
| } | |
| function func_execTransactionFromModule() { | |
| let _494 := 0x0 | |
| let _495 := iszero(callvalue()) | |
| require(not(_495)) | |
| let _496 := sub(calldatasize(), 0x4) | |
| let _497 := iszero(lt(_496, 0x80)) | |
| require(not(_497)) | |
| let _498 := add(0x4, _496) | |
| let _499 := and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(0x4)) | |
| let _500 := add(0x20, 0x4) | |
| let _501 := add(0x20, _500) | |
| let _502 := calldataload(_501) | |
| let _503 := add(0x20, _501) | |
| let _504 := iszero(gt(_502, 0x100000000)) | |
| require(not(_504)) | |
| let _505 := add(0x4, _502) | |
| let _506 := iszero(gt(add(_505, 0x20), _498)) | |
| require(not(_506)) | |
| let _507 := calldataload(_505) | |
| let _508 := add(0x20, _505) | |
| let _509 := iszero(or(gt(_507, 0x100000000), gt(add(_508, mul(_507, 0x1)), _498))) | |
| require(not(_509)) | |
| let _510 := mload(0x40) | |
| mstore(0x40, add(_510, add(0x20, mul(div(add(0x1f, _507), 0x20), 0x20)))) | |
| mstore(_510, _507) | |
| let _511 := add(0x20, _510) | |
| calldatacopy(_511, _508, _507) | |
| mstore(add(_511, _507), 0x0) | |
| let _512 := add(_511, and(add(_507, 0x1f), not(0x1f))) | |
| let _513 := and(0xff, calldataload(_503)) | |
| let _514 := add(0x20, _503) | |
| let _515 := iszero(eq(and(0xffffffffffffffffffffffffffffffffffffffff, caller()), and(0xffffffffffffffffffffffffffffffffffffffff, 0x1))) | |
| let _516 := _515 | |
| let _517 := iszero(_515) | |
| if not(_517){ | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, caller()))) | |
| let _518 := add(0x20, 0x0) | |
| mstore(_518, 0x1) | |
| let _519 := sload(keccak256(0x0, add(0x20, _518))) | |
| _516 := iszero(eq(and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, div(_519, exp(0x100, 0x0)))), and(0xffffffffffffffffffffffffffffffffffffffff, 0x0))) | |
| } | |
| if _516{ | |
| let _520 := gas() | |
| let _521 := iszero(gt(0x0, 0x1)) | |
| if _521{ | |
| let _522 := iszero(gt(_513, 0x1)) | |
| if _522{ | |
| let _523 := iszero(eq(_513, 0x0)) | |
| if _523{ | |
| let _524 := iszero(gt(0x1, 0x1)) | |
| if _524{ | |
| let _525 := iszero(gt(_513, 0x1)) | |
| if _525{ | |
| let _526 := iszero(eq(_513, 0x1)) | |
| if _526{ | |
| let _527 := 0x0 | |
| } | |
| if not(_526){ | |
| let _528 := mload(_510) | |
| let _529 := delegatecall(_520, _499, add(_510, 0x20), _528, 0x0, 0x0) | |
| let _527 := _529 | |
| } | |
| } | |
| if not(_525){ | |
| invalid() | |
| } | |
| } | |
| if not(_524){ | |
| invalid() | |
| } | |
| } | |
| if not(_523){ | |
| let _530 := mload(_510) | |
| let _531 := call(_520, _499, calldataload(_500), add(_510, 0x20), _530, 0x0, 0x0) | |
| _494 := _531 | |
| } | |
| let _532 := iszero(_494) | |
| if _532{ | |
| let _533 := mload(0x40) | |
| let _534 := mload(0x40) | |
| log2(_534, sub(_533, _534), 0xacd2c8702804128fdb0db2bb49f6d127dd0181c13fd45dbfe16de0930e2bd375, and(0xffffffffffffffffffffffffffffffffffffffff, caller())) | |
| } | |
| if not(_532){ | |
| let _535 := mload(0x40) | |
| let _536 := mload(0x40) | |
| log2(_536, sub(_535, _536), 0x6895c13664aa4f67288b25d7a21d7aaa34916e355fb9b6fae0a139a9085becb8, and(0xffffffffffffffffffffffffffffffffffffffff, caller())) | |
| } | |
| let _537 := mload(0x40) | |
| mstore(_537, iszero(iszero(iszero(iszero(_494))))) | |
| let _538 := mload(0x40) | |
| return(_538, sub(add(0x20, _537), _538)) | |
| } | |
| if not(_522){ | |
| invalid() | |
| } | |
| } | |
| if not(_521){ | |
| invalid() | |
| } | |
| } | |
| if not(_516){ | |
| let _539 := mload(0x40) | |
| mstore(_539, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _540 := add(0x4, _539) | |
| let _541 := add(0x20, _540) | |
| mstore(_540, sub(_541, _540)) | |
| mstore(_541, 0x30) | |
| let _542 := add(0x20, _541) | |
| codecopy(_542, 0x5d01, 0x30) | |
| let _543 := mload(0x40) | |
| revert(_543, sub(add(0x40, _542), _543)) | |
| } | |
| } | |
| function func_execTransactionFromModuleReturnData() { | |
| let _544 := 0x0 | |
| let _545 := iszero(callvalue()) | |
| require(not(_545)) | |
| let _546 := sub(calldatasize(), 0x4) | |
| let _547 := iszero(lt(_546, 0x80)) | |
| require(not(_547)) | |
| let _548 := add(0x4, _546) | |
| let _549 := and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(0x4)) | |
| let _550 := add(0x20, 0x4) | |
| let _551 := add(0x20, _550) | |
| let _552 := calldataload(_551) | |
| let _553 := add(0x20, _551) | |
| let _554 := iszero(gt(_552, 0x100000000)) | |
| require(not(_554)) | |
| let _555 := add(0x4, _552) | |
| let _556 := iszero(gt(add(_555, 0x20), _548)) | |
| require(not(_556)) | |
| let _557 := calldataload(_555) | |
| let _558 := add(0x20, _555) | |
| let _559 := iszero(or(gt(_557, 0x100000000), gt(add(_558, mul(_557, 0x1)), _548))) | |
| require(not(_559)) | |
| let _560 := mload(0x40) | |
| mstore(0x40, add(_560, add(0x20, mul(div(add(0x1f, _557), 0x20), 0x20)))) | |
| mstore(_560, _557) | |
| let _561 := add(0x20, _560) | |
| calldatacopy(_561, _558, _557) | |
| mstore(add(_561, _557), 0x0) | |
| let _562 := add(_561, and(add(_557, 0x1f), not(0x1f))) | |
| let _563 := and(0xff, calldataload(_553)) | |
| let _564 := add(0x20, _553) | |
| let _565 := iszero(eq(and(0xffffffffffffffffffffffffffffffffffffffff, caller()), and(0xffffffffffffffffffffffffffffffffffffffff, 0x1))) | |
| let _566 := _565 | |
| let _567 := iszero(_565) | |
| if not(_567){ | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, caller()))) | |
| let _568 := add(0x20, 0x0) | |
| mstore(_568, 0x1) | |
| let _569 := sload(keccak256(0x0, add(0x20, _568))) | |
| _566 := iszero(eq(and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, div(_569, exp(0x100, 0x0)))), and(0xffffffffffffffffffffffffffffffffffffffff, 0x0))) | |
| } | |
| if _566{ | |
| let _570 := gas() | |
| let _571 := iszero(gt(0x0, 0x1)) | |
| if _571{ | |
| let _572 := iszero(gt(_563, 0x1)) | |
| if _572{ | |
| let _573 := iszero(eq(_563, 0x0)) | |
| if _573{ | |
| let _574 := iszero(gt(0x1, 0x1)) | |
| if _574{ | |
| let _575 := iszero(gt(_563, 0x1)) | |
| if _575{ | |
| let _576 := iszero(eq(_563, 0x1)) | |
| if _576{ | |
| let _577 := 0x0 | |
| } | |
| if not(_576){ | |
| let _578 := mload(_560) | |
| let _579 := delegatecall(_570, _549, add(_560, 0x20), _578, 0x0, 0x0) | |
| let _577 := _579 | |
| } | |
| } | |
| if not(_575){ | |
| invalid() | |
| } | |
| } | |
| if not(_574){ | |
| invalid() | |
| } | |
| } | |
| if not(_573){ | |
| let _580 := mload(_560) | |
| let _581 := call(_570, _549, calldataload(_550), add(_560, 0x20), _580, 0x0, 0x0) | |
| _544 := _581 | |
| } | |
| let _582 := iszero(_544) | |
| if _582{ | |
| let _583 := mload(0x40) | |
| let _584 := mload(0x40) | |
| log2(_584, sub(_583, _584), 0xacd2c8702804128fdb0db2bb49f6d127dd0181c13fd45dbfe16de0930e2bd375, and(0xffffffffffffffffffffffffffffffffffffffff, caller())) | |
| } | |
| if not(_582){ | |
| let _585 := mload(0x40) | |
| let _586 := mload(0x40) | |
| log2(_586, sub(_585, _586), 0x6895c13664aa4f67288b25d7a21d7aaa34916e355fb9b6fae0a139a9085becb8, and(0xffffffffffffffffffffffffffffffffffffffff, caller())) | |
| } | |
| let _587 := mload(0x40) | |
| mstore(0x40, add(_587, add(returndatasize(), 0x20))) | |
| mstore(_587, returndatasize()) | |
| returndatacopy(add(_587, 0x20), 0x0, returndatasize()) | |
| let _588 := mload(0x40) | |
| mstore(_588, iszero(iszero(iszero(iszero(_544))))) | |
| let _589 := add(0x20, _588) | |
| let _590 := add(0x20, _589) | |
| mstore(_589, sub(_590, _588)) | |
| let _591 := mload(_587) | |
| mstore(_590, _591) | |
| let _592 := add(0x20, _590) | |
| let _593 := mload(_587) | |
| let _594 := 0x0 | |
| let _595 := 0x0 | |
| for { | |
| let _596 := lt(_594, _593) | |
| let _597 := 0x20 | |
| let _598 := add(_595, _597) | |
| } | |
| not(iszero(_596)) | |
| { } | |
| { | |
| _594 := _598 | |
| _596 := lt(_594, _593) | |
| let _599 := not(iszero(_596)) | |
| _595 := _598 | |
| let _600 := mload(add(add(0x20, _587), _595)) | |
| mstore(add(_592, _595), _600) | |
| _597 := 0x20 | |
| _598 := add(_595, _597) | |
| _594 := _598 | |
| _595 := _598 | |
| } | |
| let _601 := add(_593, _592) | |
| let _602 := _601 | |
| let _603 := and(0x1f, _593) | |
| let _604 := iszero(_603) | |
| if not(_604){ | |
| let _605 := sub(_601, _603) | |
| let _606 := mload(_605) | |
| mstore(_605, and(not(sub(exp(0x100, sub(0x20, _603)), 0x1)), _606)) | |
| _602 := add(0x20, _605) | |
| } | |
| let _607 := mload(0x40) | |
| return(_607, sub(_602, _607)) | |
| } | |
| if not(_572){ | |
| invalid() | |
| } | |
| } | |
| if not(_571){ | |
| invalid() | |
| } | |
| } | |
| if not(_566){ | |
| let _608 := mload(0x40) | |
| mstore(_608, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _609 := add(0x4, _608) | |
| let _610 := add(0x20, _609) | |
| mstore(_609, sub(_610, _609)) | |
| mstore(_610, 0x30) | |
| let _611 := add(0x20, _610) | |
| codecopy(_611, 0x5d01, 0x30) | |
| let _612 := mload(0x40) | |
| revert(_612, sub(add(0x40, _611), _612)) | |
| } | |
| } | |
| function func_signedMessages() { | |
| let _613 := iszero(callvalue()) | |
| require(not(_613)) | |
| let _614 := sub(calldatasize(), 0x4) | |
| let _615 := iszero(lt(_614, 0x20)) | |
| require(not(_615)) | |
| let _616 := add(0x4, _614) | |
| let _617 := add(0x20, 0x4) | |
| mstore(0x20, 0x7) | |
| mstore(0x0, calldataload(0x4)) | |
| let _618 := sload(keccak256(0x0, 0x40)) | |
| let _619 := mload(0x40) | |
| mstore(_619, _618) | |
| let _620 := mload(0x40) | |
| return(_620, sub(add(0x20, _619), _620)) | |
| } | |
| function func_enableModule() { | |
| let _621 := iszero(callvalue()) | |
| require(not(_621)) | |
| let _622 := sub(calldatasize(), 0x4) | |
| let _623 := iszero(lt(_622, 0x20)) | |
| require(not(_623)) | |
| let _624 := add(0x4, _622) | |
| let _625 := and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(0x4)) | |
| let _626 := add(0x20, 0x4) | |
| let _627 := eq(and(0xffffffffffffffffffffffffffffffffffffffff, caller()), and(0xffffffffffffffffffffffffffffffffffffffff, address())) | |
| if _627{ | |
| let _628 := iszero(eq(and(0xffffffffffffffffffffffffffffffffffffffff, _625), and(0xffffffffffffffffffffffffffffffffffffffff, 0x0))) | |
| let _629 := _628 | |
| let _630 := iszero(_628) | |
| if not(_630){ | |
| _629 := iszero(eq(and(0xffffffffffffffffffffffffffffffffffffffff, _625), and(0xffffffffffffffffffffffffffffffffffffffff, 0x1))) | |
| } | |
| if _629{ | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _625))) | |
| let _631 := add(0x20, 0x0) | |
| mstore(_631, 0x1) | |
| let _632 := sload(keccak256(0x0, add(0x20, _631))) | |
| let _633 := eq(and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, div(_632, exp(0x100, 0x0)))), and(0xffffffffffffffffffffffffffffffffffffffff, 0x0)) | |
| if _633{ | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, 0x1))) | |
| let _634 := add(0x20, 0x0) | |
| mstore(_634, 0x1) | |
| let _635 := sload(keccak256(0x0, add(0x20, _634))) | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _625))) | |
| let _636 := add(0x20, 0x0) | |
| mstore(_636, 0x1) | |
| let _637 := keccak256(0x0, add(0x20, _636)) | |
| let _638 := exp(0x100, 0x0) | |
| let _639 := sload(_637) | |
| sstore(_637, or(mul(and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, div(_635, exp(0x100, 0x0)))), _638), and(not(mul(0xffffffffffffffffffffffffffffffffffffffff, _638)), _639))) | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, 0x1))) | |
| let _640 := add(0x20, 0x0) | |
| mstore(_640, 0x1) | |
| let _641 := keccak256(0x0, add(0x20, _640)) | |
| let _642 := exp(0x100, 0x0) | |
| let _643 := sload(_641) | |
| sstore(_641, or(mul(and(0xffffffffffffffffffffffffffffffffffffffff, _625), _642), and(not(mul(0xffffffffffffffffffffffffffffffffffffffff, _642)), _643))) | |
| let _644 := mload(0x40) | |
| mstore(_644, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _625))) | |
| let _645 := mload(0x40) | |
| log1(_645, sub(add(0x20, _644), _645), 0xecdf3a3effea5783a3c4c2140e677577666428d44ed9d474a0b3a4c9943f8440) | |
| stop() | |
| } | |
| if not(_633){ | |
| let _646 := mload(0x40) | |
| mstore(_646, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _647 := add(0x4, _646) | |
| let _648 := add(0x20, _647) | |
| mstore(_647, sub(_648, _647)) | |
| mstore(_648, 0x1d) | |
| let _649 := add(0x20, _648) | |
| mstore(_649, 0x4d6f64756c652068617320616c7265616479206265656e206164646564000000) | |
| let _650 := mload(0x40) | |
| revert(_650, sub(add(0x20, _649), _650)) | |
| } | |
| } | |
| if not(_629){ | |
| let _651 := mload(0x40) | |
| mstore(_651, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _652 := add(0x4, _651) | |
| let _653 := add(0x20, _652) | |
| mstore(_652, sub(_653, _652)) | |
| mstore(_653, 0x1f) | |
| let _654 := add(0x20, _653) | |
| mstore(_654, 0x496e76616c6964206d6f64756c6520616464726573732070726f766964656400) | |
| let _655 := mload(0x40) | |
| revert(_655, sub(add(0x20, _654), _655)) | |
| } | |
| } | |
| if not(_627){ | |
| let _656 := mload(0x40) | |
| mstore(_656, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _657 := add(0x4, _656) | |
| let _658 := add(0x20, _657) | |
| mstore(_657, sub(_658, _657)) | |
| mstore(_658, 0x2c) | |
| let _659 := add(0x20, _658) | |
| codecopy(_659, 0x5cd5, 0x2c) | |
| let _660 := mload(0x40) | |
| revert(_660, sub(add(0x40, _659), _660)) | |
| } | |
| } | |
| function func_changeThreshold() { | |
| let _661 := iszero(callvalue()) | |
| require(not(_661)) | |
| let _662 := sub(calldatasize(), 0x4) | |
| let _663 := iszero(lt(_662, 0x20)) | |
| require(not(_663)) | |
| let _664 := add(0x4, _662) | |
| let _665 := add(0x20, 0x4) | |
| func_0x24af(calldataload(0x4), 0x8b7) | |
| stop() | |
| } | |
| function func_execTransaction() { | |
| let _666 := 0x0 | |
| let _667 := 0x0 | |
| let _668 := iszero(callvalue()) | |
| require(not(_668)) | |
| let _669 := sub(calldatasize(), 0x4) | |
| let _670 := iszero(lt(_669, 0x140)) | |
| require(not(_670)) | |
| let _671 := add(0x4, _669) | |
| let _672 := and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(0x4)) | |
| let _673 := add(0x20, 0x4) | |
| let _674 := calldataload(_673) | |
| let _675 := add(0x20, _673) | |
| let _676 := calldataload(_675) | |
| let _677 := add(0x20, _675) | |
| let _678 := iszero(gt(_676, 0x100000000)) | |
| require(not(_678)) | |
| let _679 := add(0x4, _676) | |
| let _680 := iszero(gt(add(_679, 0x20), _671)) | |
| require(not(_680)) | |
| let _681 := calldataload(_679) | |
| let _682 := add(0x20, _679) | |
| let _683 := iszero(or(gt(_681, 0x100000000), gt(add(_682, mul(_681, 0x1)), _671))) | |
| require(not(_683)) | |
| let _684 := and(0xff, calldataload(_677)) | |
| let _685 := add(0x20, _677) | |
| let _686 := calldataload(_685) | |
| let _687 := _686 | |
| let _688 := _686 | |
| let _689 := add(0x20, _685) | |
| let _690 := calldataload(_689) | |
| let _691 := add(0x20, _689) | |
| let _692 := calldataload(_691) | |
| let _693 := add(0x20, _691) | |
| let _694 := and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(_693)) | |
| let _695 := add(0x20, _693) | |
| let _696 := and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(_695)) | |
| let _697 := add(0x20, _695) | |
| let _698 := calldataload(_697) | |
| let _699 := add(0x20, _697) | |
| let _700 := iszero(gt(_698, 0x100000000)) | |
| require(not(_700)) | |
| let _701 := add(0x4, _698) | |
| let _702 := iszero(gt(add(_701, 0x20), _671)) | |
| require(not(_702)) | |
| let _703 := calldataload(_701) | |
| let _704 := add(0x20, _701) | |
| let _705 := iszero(or(gt(_703, 0x100000000), gt(add(_704, mul(_703, 0x1)), _671))) | |
| require(not(_705)) | |
| let _706 := mload(0x40) | |
| mstore(0x40, add(_706, add(0x20, mul(div(add(0x1f, _681), 0x20), 0x20)))) | |
| mstore(_706, _681) | |
| let _707 := add(0x20, _706) | |
| calldatacopy(_707, _682, _681) | |
| mstore(add(_707, _681), 0x0) | |
| let _708 := add(_707, and(add(_681, 0x1f), not(0x1f))) | |
| let _709 := sload(0x5) | |
| let _710 := mload(_706) | |
| let _711 := mload(0x40) | |
| let _712 := add(0x20, _711) | |
| mstore(_712, shl(0x0, 0xbb8310d486368db6bd6f849402fdd73ad53d316b5a4b2644ad6efe0f941286d8)) | |
| let _713 := add(0x20, _712) | |
| mstore(_713, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _672))) | |
| let _714 := add(0x20, _713) | |
| mstore(_714, _674) | |
| let _715 := add(0x20, _714) | |
| mstore(_715, keccak256(add(0x20, _706), _710)) | |
| let _716 := add(0x20, _715) | |
| let _717 := iszero(gt(_684, 0x1)) | |
| if _717{ | |
| mstore(_716, and(0xff, _684)) | |
| let _718 := add(0x20, _716) | |
| mstore(_718, _686) | |
| let _719 := add(0x20, _718) | |
| mstore(_719, _690) | |
| let _720 := add(0x20, _719) | |
| mstore(_720, _692) | |
| let _721 := add(0x20, _720) | |
| mstore(_721, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _694))) | |
| let _722 := add(0x20, _721) | |
| mstore(_722, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _696))) | |
| let _723 := add(0x20, _722) | |
| mstore(_723, _709) | |
| let _724 := add(0x20, _723) | |
| let _725 := mload(0x40) | |
| mstore(_725, sub(sub(_724, _725), 0x20)) | |
| mstore(0x40, _724) | |
| let _726 := mload(_725) | |
| let _727 := sload(0x6) | |
| let _728 := mload(0x40) | |
| let _729 := add(0x20, _728) | |
| mstore(_729, and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), shl(0xf8, 0x19)))) | |
| let _730 := add(0x1, _729) | |
| mstore(_730, and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), shl(0xf8, 0x1)))) | |
| let _731 := add(0x1, _730) | |
| mstore(_731, _727) | |
| let _732 := add(0x20, _731) | |
| mstore(_732, keccak256(add(0x20, _725), _726)) | |
| let _733 := add(0x20, _732) | |
| let _734 := mload(0x40) | |
| mstore(_734, sub(sub(_733, _734), 0x20)) | |
| mstore(0x40, _733) | |
| let _735 := sload(0x5) | |
| sstore(0x5, add(0x1, _735)) | |
| let _736 := mload(_734) | |
| let _737 := keccak256(add(0x20, _734), _736) | |
| let _738 := mload(0x40) | |
| mstore(0x40, add(_738, add(0x20, mul(div(add(0x1f, _703), 0x20), 0x20)))) | |
| mstore(_738, _703) | |
| let _739 := add(0x20, _738) | |
| calldatacopy(_739, _704, _703) | |
| mstore(add(_739, _703), 0x0) | |
| let _740 := add(_739, and(add(_703, 0x1f), not(0x1f))) | |
| func_0x470a(0x1, _738, _734, _737, 0x26f7) | |
| let _741 := iszero(lt(gas(), _686)) | |
| if _741{ | |
| let _742 := gas() | |
| let _743 := mload(0x40) | |
| mstore(0x40, add(_743, add(0x20, mul(div(add(0x1f, _681), 0x20), 0x20)))) | |
| mstore(_743, _681) | |
| let _744 := add(0x20, _743) | |
| calldatacopy(_744, _682, _681) | |
| mstore(add(_744, _681), 0x0) | |
| let _745 := add(_744, and(add(_681, 0x1f), not(0x1f))) | |
| let _746 := eq(_686, 0x0) | |
| let _747 := _746 | |
| let _748 := iszero(_746) | |
| if not(_748){ | |
| _747 := eq(_692, 0x0) | |
| } | |
| if _747{ | |
| let _749 := gas() | |
| _687 := _749 | |
| _688 := _749 | |
| } | |
| let _750 := iszero(gt(0x0, 0x1)) | |
| if _750{ | |
| let _751 := iszero(gt(_684, 0x1)) | |
| if _751{ | |
| let _752 := iszero(eq(_684, 0x0)) | |
| if _752{ | |
| let _753 := iszero(gt(0x1, 0x1)) | |
| if _753{ | |
| let _754 := iszero(gt(_684, 0x1)) | |
| if _754{ | |
| let _755 := iszero(eq(_684, 0x1)) | |
| if _755{ | |
| _667 := 0x0 | |
| _666 := 0x0 | |
| } | |
| if not(_755){ | |
| let _756 := mload(_743) | |
| let _757 := delegatecall(_687, _672, add(_743, 0x20), _756, 0x0, 0x0) | |
| _667 := _757 | |
| _666 := _757 | |
| } | |
| } | |
| if not(_754){ | |
| invalid() | |
| } | |
| } | |
| if not(_753){ | |
| invalid() | |
| } | |
| } | |
| if not(_752){ | |
| let _758 := mload(_743) | |
| let _759 := call(_688, _672, _674, add(_743, 0x20), _758, 0x0, 0x0) | |
| _667 := _759 | |
| _666 := _759 | |
| } | |
| let _760 := gas() | |
| let _761 := and(0xffffffff, 0x50aa) | |
| let _762 := iszero(gt(_760, _742)) | |
| require(not(_762)) | |
| let _763 := 0x0 | |
| let _764 := 0x0 | |
| let _765 := iszero(gt(_692, 0x0)) | |
| if not(_765){ | |
| let _766 := func_0x50ca(_696, _694, _692, _690, sub(_742, _760), 0x27f4) | |
| _763 := _766 | |
| _764 := _766 | |
| } | |
| let _767 := iszero(_667) | |
| if _767{ | |
| let _768 := mload(0x40) | |
| mstore(_768, _737) | |
| let _769 := add(0x20, _768) | |
| mstore(_769, _763) | |
| let _770 := mload(0x40) | |
| log1(_770, sub(add(0x20, _769), _770), 0x23428b18acfb3ea64b08dc0c1d296ea9c09702c09083ca5272e64d115b687d23) | |
| } | |
| if not(_767){ | |
| let _771 := mload(0x40) | |
| mstore(_771, _737) | |
| let _772 := add(0x20, _771) | |
| mstore(_772, _764) | |
| let _773 := mload(0x40) | |
| log1(_773, sub(add(0x20, _772), _773), 0x442e715f626346e8c54381002da614f62bee8d27386535b2521ec8540898556e) | |
| } | |
| let _774 := mload(0x40) | |
| mstore(_774, iszero(iszero(iszero(iszero(_666))))) | |
| let _775 := mload(0x40) | |
| return(_775, sub(add(0x20, _774), _775)) | |
| } | |
| if not(_751){ | |
| invalid() | |
| } | |
| } | |
| if not(_750){ | |
| invalid() | |
| } | |
| } | |
| if not(_741){ | |
| let _776 := mload(0x40) | |
| mstore(_776, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _777 := add(0x4, _776) | |
| let _778 := add(0x20, _777) | |
| mstore(_777, sub(_778, _777)) | |
| mstore(_778, 0x2a) | |
| let _779 := add(0x20, _778) | |
| codecopy(_779, 0x5d8a, 0x2a) | |
| let _780 := mload(0x40) | |
| revert(_780, sub(add(0x40, _779), _780)) | |
| } | |
| } | |
| if not(_717){ | |
| invalid() | |
| } | |
| } | |
| function func_approvedHashes() { | |
| let _781 := iszero(callvalue()) | |
| require(not(_781)) | |
| let _782 := sub(calldatasize(), 0x4) | |
| let _783 := iszero(lt(_782, 0x40)) | |
| require(not(_783)) | |
| let _784 := add(0x4, _782) | |
| let _785 := add(0x20, 0x4) | |
| let _786 := add(0x20, _785) | |
| mstore(0x20, 0x8) | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(0x4))) | |
| mstore(0x20, keccak256(0x0, 0x40)) | |
| mstore(0x0, calldataload(_785)) | |
| let _787 := sload(keccak256(0x0, 0x40)) | |
| let _788 := mload(0x40) | |
| mstore(_788, _787) | |
| let _789 := mload(0x40) | |
| return(_789, sub(add(0x20, _788), _789)) | |
| } | |
| function func_changeMasterCopy() { | |
| let _790 := iszero(callvalue()) | |
| require(not(_790)) | |
| let _791 := sub(calldatasize(), 0x4) | |
| let _792 := iszero(lt(_791, 0x20)) | |
| require(not(_792)) | |
| let _793 := add(0x4, _791) | |
| let _794 := and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(0x4)) | |
| let _795 := add(0x20, 0x4) | |
| let _796 := eq(and(0xffffffffffffffffffffffffffffffffffffffff, caller()), and(0xffffffffffffffffffffffffffffffffffffffff, address())) | |
| if _796{ | |
| let _797 := iszero(eq(and(0xffffffffffffffffffffffffffffffffffffffff, _794), and(0xffffffffffffffffffffffffffffffffffffffff, 0x0))) | |
| if _797{ | |
| let _798 := exp(0x100, 0x0) | |
| let _799 := sload(0x0) | |
| sstore(0x0, or(mul(and(0xffffffffffffffffffffffffffffffffffffffff, _794), _798), and(not(mul(0xffffffffffffffffffffffffffffffffffffffff, _798)), _799))) | |
| let _800 := mload(0x40) | |
| mstore(_800, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _794))) | |
| let _801 := mload(0x40) | |
| log1(_801, sub(add(0x20, _800), _801), 0x75e41bc35ff1bf14d81d1d2f649c0084a0f974f9289c803ec9898eeec4c8d0b8) | |
| stop() | |
| } | |
| if not(_797){ | |
| let _802 := mload(0x40) | |
| mstore(_802, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _803 := add(0x4, _802) | |
| let _804 := add(0x20, _803) | |
| mstore(_803, sub(_804, _803)) | |
| mstore(_804, 0x24) | |
| let _805 := add(0x20, _804) | |
| codecopy(_805, 0x5b10, 0x24) | |
| let _806 := mload(0x40) | |
| revert(_806, sub(add(0x40, _805), _806)) | |
| } | |
| } | |
| if not(_796){ | |
| let _807 := mload(0x40) | |
| mstore(_807, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _808 := add(0x4, _807) | |
| let _809 := add(0x20, _808) | |
| mstore(_808, sub(_809, _808)) | |
| mstore(_809, 0x2c) | |
| let _810 := add(0x20, _809) | |
| codecopy(_810, 0x5cd5, 0x2c) | |
| let _811 := mload(0x40) | |
| revert(_811, sub(add(0x40, _810), _811)) | |
| } | |
| } | |
| function func_signMessage() { | |
| let _812 := iszero(callvalue()) | |
| require(not(_812)) | |
| let _813 := sub(calldatasize(), 0x4) | |
| let _814 := iszero(lt(_813, 0x20)) | |
| require(not(_814)) | |
| let _815 := add(0x4, _813) | |
| let _816 := calldataload(0x4) | |
| let _817 := add(0x20, 0x4) | |
| let _818 := iszero(gt(_816, 0x100000000)) | |
| require(not(_818)) | |
| let _819 := add(0x4, _816) | |
| let _820 := iszero(gt(add(_819, 0x20), _815)) | |
| require(not(_820)) | |
| let _821 := calldataload(_819) | |
| let _822 := add(0x20, _819) | |
| let _823 := iszero(or(gt(_821, 0x100000000), gt(add(_822, mul(_821, 0x1)), _815))) | |
| require(not(_823)) | |
| let _824 := eq(and(0xffffffffffffffffffffffffffffffffffffffff, caller()), and(0xffffffffffffffffffffffffffffffffffffffff, address())) | |
| if _824{ | |
| let _825 := mload(0x40) | |
| mstore(0x40, add(_825, add(0x20, mul(div(add(0x1f, _821), 0x20), 0x20)))) | |
| mstore(_825, _821) | |
| let _826 := add(0x20, _825) | |
| calldatacopy(_826, _822, _821) | |
| mstore(add(_826, _821), 0x0) | |
| let _827 := add(_826, and(add(_821, 0x1f), not(0x1f))) | |
| let _828 := mload(_825) | |
| let _829 := mload(0x40) | |
| let _830 := add(0x20, _829) | |
| mstore(_830, shl(0x0, 0x60b3cbf8b4a223d68d641b3b6ddf9a298e7f33710cf3d3a9d1146b5a6150fbca)) | |
| let _831 := add(0x20, _830) | |
| mstore(_831, keccak256(add(0x20, _825), _828)) | |
| let _832 := add(0x20, _831) | |
| let _833 := mload(0x40) | |
| mstore(_833, sub(sub(_832, _833), 0x20)) | |
| mstore(0x40, _832) | |
| let _834 := mload(_833) | |
| let _835 := sload(0x6) | |
| let _836 := mload(0x40) | |
| let _837 := add(0x20, _836) | |
| mstore(_837, and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), shl(0xf8, 0x19)))) | |
| let _838 := add(0x1, _837) | |
| mstore(_838, and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), shl(0xf8, 0x1)))) | |
| let _839 := add(0x1, _838) | |
| mstore(_839, _835) | |
| let _840 := add(0x20, _839) | |
| mstore(_840, keccak256(add(0x20, _833), _834)) | |
| let _841 := add(0x20, _840) | |
| let _842 := mload(0x40) | |
| mstore(_842, sub(sub(_841, _842), 0x20)) | |
| mstore(0x40, _841) | |
| let _843 := mload(_842) | |
| let _844 := keccak256(add(0x20, _842), _843) | |
| mstore(0x0, _844) | |
| let _845 := add(0x20, 0x0) | |
| mstore(_845, 0x7) | |
| sstore(keccak256(0x0, add(0x20, _845)), 0x1) | |
| let _846 := mload(0x40) | |
| let _847 := mload(0x40) | |
| log2(_847, sub(_846, _847), 0xe7f4675038f4f6034dfcbbb24c4dc08e4ebf10eb9d257d3d02c0f38d122ac6e4, _844) | |
| stop() | |
| } | |
| if not(_824){ | |
| let _848 := mload(0x40) | |
| mstore(_848, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _849 := add(0x4, _848) | |
| let _850 := add(0x20, _849) | |
| mstore(_849, sub(_850, _849)) | |
| mstore(_850, 0x2c) | |
| let _851 := add(0x20, _850) | |
| codecopy(_851, 0x5cd5, 0x2c) | |
| let _852 := mload(0x40) | |
| revert(_852, sub(add(0x40, _851), _852)) | |
| } | |
| } | |
| function func_getOwners() { | |
| let _853 := iszero(callvalue()) | |
| require(not(_853)) | |
| let _854 := sload(0x3) | |
| let _855 := mload(0x40) | |
| mstore(_855, _854) | |
| mstore(0x40, add(_855, add(0x20, mul(0x20, _854)))) | |
| let _856 := iszero(_854) | |
| if not(_856){ | |
| let _857 := add(0x20, _855) | |
| let _858 := mul(_854, 0x20) | |
| codecopy(_857, codesize(), _858) | |
| let _859 := add(_857, _858) | |
| } | |
| let _860 := 0x0 | |
| let _861 := 0x0 | |
| let _862 := 0x0 | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, 0x1))) | |
| let _863 := add(0x20, 0x0) | |
| mstore(_863, 0x2) | |
| let _864 := sload(keccak256(0x0, add(0x20, _863))) | |
| let _865 := and(0xffffffffffffffffffffffffffffffffffffffff, div(_864, exp(0x100, 0x0))) | |
| let _866 := _865 | |
| let _867 := _865 | |
| let _868 := _865 | |
| for { | |
| let _871 := 0xffffffffffffffffffffffffffffffffffffffff | |
| let _872 := 0x1 | |
| let _870 := and(_871, _872) | |
| let _873 := 0xffffffffffffffffffffffffffffffffffffffff | |
| let _869 := and(_873, _866) | |
| let _874 := 0x1 | |
| let _875 := add(_874, _862) | |
| } | |
| not(eq(_869, _870)) | |
| { } | |
| { | |
| _872 := 0x1 | |
| _871 := 0xffffffffffffffffffffffffffffffffffffffff | |
| _870 := and(_871, _872) | |
| _873 := 0xffffffffffffffffffffffffffffffffffffffff | |
| _869 := and(_873, _866) | |
| let _876 := not(eq(_869, _870)) | |
| _860 := _875 | |
| let _877 := mload(_855) | |
| let _878 := lt(_860, _877) | |
| if _878{ | |
| _861 := _875 | |
| _862 := _875 | |
| mstore(add(add(0x20, mul(0x20, _861)), _855), and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _867))) | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _868))) | |
| let _879 := add(0x20, 0x0) | |
| mstore(_879, 0x2) | |
| let _880 := sload(keccak256(0x0, add(0x20, _879))) | |
| let _881 := and(0xffffffffffffffffffffffffffffffffffffffff, div(_880, exp(0x100, 0x0))) | |
| _866 := _881 | |
| _867 := _881 | |
| _868 := _881 | |
| _874 := 0x1 | |
| _875 := add(_874, _862) | |
| _860 := _875 | |
| _861 := _875 | |
| _862 := _875 | |
| } | |
| if not(_878){ | |
| invalid() | |
| break | |
| } | |
| } | |
| let _882 := mload(0x40) | |
| let _883 := add(0x20, _882) | |
| mstore(_882, sub(_883, _882)) | |
| let _884 := mload(_855) | |
| mstore(_883, _884) | |
| let _885 := add(0x20, _883) | |
| let _886 := mload(_855) | |
| let _887 := mul(0x20, _886) | |
| let _888 := 0x0 | |
| let _889 := 0x0 | |
| for { | |
| let _890 := lt(_888, _887) | |
| let _891 := 0x20 | |
| let _892 := add(_889, _891) | |
| } | |
| not(iszero(_890)) | |
| { } | |
| { | |
| _888 := _892 | |
| _890 := lt(_888, _887) | |
| let _893 := not(iszero(_890)) | |
| _889 := _892 | |
| let _894 := mload(add(add(0x20, _855), _889)) | |
| mstore(add(_885, _889), _894) | |
| _891 := 0x20 | |
| _892 := add(_889, _891) | |
| _888 := _892 | |
| _889 := _892 | |
| } | |
| let _895 := mload(0x40) | |
| return(_895, sub(add(_887, _885), _895)) | |
| } | |
| function func_NAME() { | |
| let _896 := iszero(callvalue()) | |
| require(not(_896)) | |
| let _897 := mload(0x40) | |
| mstore(0x40, add(0x40, _897)) | |
| mstore(_897, 0xb) | |
| mstore(add(0x20, _897), 0x476e6f7369732053616665000000000000000000000000000000000000000000) | |
| let _898 := mload(0x40) | |
| let _899 := add(0x20, _898) | |
| mstore(_898, sub(_899, _898)) | |
| let _900 := mload(_897) | |
| mstore(_899, _900) | |
| let _901 := add(0x20, _899) | |
| let _902 := mload(_897) | |
| let _903 := 0x0 | |
| let _904 := 0x0 | |
| for { | |
| let _905 := lt(_903, _902) | |
| let _906 := 0x20 | |
| let _907 := add(_904, _906) | |
| } | |
| not(iszero(_905)) | |
| { } | |
| { | |
| _903 := _907 | |
| _905 := lt(_903, _902) | |
| let _908 := not(iszero(_905)) | |
| _904 := _907 | |
| let _909 := mload(add(add(0x20, _897), _904)) | |
| mstore(add(_901, _904), _909) | |
| _906 := 0x20 | |
| _907 := add(_904, _906) | |
| _903 := _907 | |
| _904 := _907 | |
| } | |
| let _910 := add(_902, _901) | |
| let _911 := _910 | |
| let _912 := and(0x1f, _902) | |
| let _913 := iszero(_912) | |
| if not(_913){ | |
| let _914 := sub(_910, _912) | |
| let _915 := mload(_914) | |
| mstore(_914, and(not(sub(exp(0x100, sub(0x20, _912)), 0x1)), _915)) | |
| _911 := add(0x20, _914) | |
| } | |
| let _916 := mload(0x40) | |
| return(_916, sub(_911, _916)) | |
| } | |
| function func_nonce() { | |
| let _917 := iszero(callvalue()) | |
| require(not(_917)) | |
| let _918 := sload(0x5) | |
| let _919 := mload(0x40) | |
| mstore(_919, _918) | |
| let _920 := mload(0x40) | |
| return(_920, sub(add(0x20, _919), _920)) | |
| } | |
| function func_getModules() { | |
| let _921 := iszero(callvalue()) | |
| require(not(_921)) | |
| let _922, _923 := func_0x311e(0xa, 0x1, 0x2d6c) | |
| let _924 := mload(0x40) | |
| let _925 := add(0x20, _924) | |
| mstore(_924, sub(_925, _924)) | |
| let _926 := mload(_923) | |
| mstore(_925, _926) | |
| let _927 := add(0x20, _925) | |
| let _928 := mload(_923) | |
| let _929 := mul(0x20, _928) | |
| let _930 := 0x0 | |
| let _931 := 0x0 | |
| for { | |
| let _932 := lt(_930, _929) | |
| let _933 := 0x20 | |
| let _934 := add(_931, _933) | |
| } | |
| not(iszero(_932)) | |
| { } | |
| { | |
| _930 := _934 | |
| _932 := lt(_930, _929) | |
| let _935 := not(iszero(_932)) | |
| _931 := _934 | |
| let _936 := mload(add(add(0x20, _923), _931)) | |
| mstore(add(_927, _931), _936) | |
| _933 := 0x20 | |
| _934 := add(_931, _933) | |
| _930 := _934 | |
| _931 := _934 | |
| } | |
| let _937 := mload(0x40) | |
| return(_937, sub(add(_929, _927), _937)) | |
| } | |
| function func_setup() { | |
| let _938 := iszero(callvalue()) | |
| require(not(_938)) | |
| let _939 := sub(calldatasize(), 0x4) | |
| let _940 := iszero(lt(_939, 0x100)) | |
| require(not(_940)) | |
| let _941 := add(0x4, _939) | |
| let _942 := calldataload(0x4) | |
| let _943 := add(0x20, 0x4) | |
| let _944 := iszero(gt(_942, 0x100000000)) | |
| require(not(_944)) | |
| let _945 := add(0x4, _942) | |
| let _946 := iszero(gt(add(_945, 0x20), _941)) | |
| require(not(_946)) | |
| let _947 := calldataload(_945) | |
| let _948 := add(0x20, _945) | |
| let _949 := iszero(or(gt(_947, 0x100000000), gt(add(_948, mul(_947, 0x20)), _941))) | |
| require(not(_949)) | |
| let _950 := calldataload(_943) | |
| let _951 := add(0x20, _943) | |
| let _952 := and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(_951)) | |
| let _953 := add(0x20, _951) | |
| let _954 := calldataload(_953) | |
| let _955 := add(0x20, _953) | |
| let _956 := iszero(gt(_954, 0x100000000)) | |
| require(not(_956)) | |
| let _957 := add(0x4, _954) | |
| let _958 := iszero(gt(add(_957, 0x20), _941)) | |
| require(not(_958)) | |
| let _959 := calldataload(_957) | |
| let _960 := add(0x20, _957) | |
| let _961 := iszero(or(gt(_959, 0x100000000), gt(add(_960, mul(_959, 0x1)), _941))) | |
| require(not(_961)) | |
| let _962 := and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(_955)) | |
| let _963 := add(0x20, _955) | |
| let _964 := add(0x20, _963) | |
| let _965 := calldataload(_964) | |
| let _966 := add(0x20, _964) | |
| let _967 := add(0x20, _966) | |
| let _968 := sload(0x6) | |
| let _969 := eq(_968, shl(0x0, 0x0)) | |
| if _969{ | |
| let _970 := mload(0x40) | |
| let _971 := add(0x20, _970) | |
| mstore(_971, shl(0x0, 0x35aff83d86937d35b32e04f0ddc6ff469290eef2f1b692d8a815c89404d4749)) | |
| let _972 := add(0x20, _971) | |
| mstore(_972, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, address()))) | |
| let _973 := add(0x20, _972) | |
| let _974 := mload(0x40) | |
| mstore(_974, sub(sub(_973, _974), 0x20)) | |
| mstore(0x40, _973) | |
| let _975 := mload(_974) | |
| sstore(0x6, keccak256(add(0x20, _974), _975)) | |
| let _976 := mload(0x40) | |
| mstore(0x40, add(_976, add(0x20, mul(0x20, _947)))) | |
| mstore(_976, _947) | |
| let _977 := add(0x20, _976) | |
| let _978 := mul(0x20, _947) | |
| calldatacopy(_977, _948, _978) | |
| mstore(add(_977, _978), 0x0) | |
| let _979 := add(_977, and(add(_978, 0x1f), not(0x1f))) | |
| let _980 := sload(0x4) | |
| let _981 := eq(_980, 0x0) | |
| switch _980 | |
| case 0x0{ | |
| let _982 := mload(_976) | |
| let _983 := iszero(gt(_950, _982)) | |
| if _983{ | |
| let _984 := iszero(lt(_950, 0x1)) | |
| if _984{ | |
| let _985 := 0x1 | |
| let _986 := 0x1 | |
| let _987 := 0x0 | |
| let _988 := 0x0 | |
| let _989 := 0x0 | |
| let _990 := 0x0 | |
| for { | |
| let _992 := mload(_976) | |
| let _991 := lt(_987, _992) | |
| let _993 := 0x1 | |
| let _994 := add(_993, _990) | |
| } | |
| not(iszero(_991)) | |
| { } | |
| { | |
| _987 := _994 | |
| _992 := mload(_976) | |
| _991 := lt(_987, _992) | |
| let _995 := not(iszero(_991)) | |
| _988 := _994 | |
| let _996 := mload(_976) | |
| let _997 := lt(_988, _996) | |
| if _997{ | |
| _989 := _994 | |
| let _998 := mload(add(add(0x20, mul(0x20, _989)), _976)) | |
| _985 := _998 | |
| _986 := _998 | |
| let _999 := iszero(eq(and(0xffffffffffffffffffffffffffffffffffffffff, _998), and(0xffffffffffffffffffffffffffffffffffffffff, 0x0))) | |
| let _1000 := _999 | |
| let _1001 := iszero(_999) | |
| if not(_1001){ | |
| _1000 := iszero(eq(and(0xffffffffffffffffffffffffffffffffffffffff, _998), and(0xffffffffffffffffffffffffffffffffffffffff, 0x1))) | |
| } | |
| if _1000{ | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _998))) | |
| let _1002 := add(0x20, 0x0) | |
| mstore(_1002, 0x2) | |
| let _1003 := sload(keccak256(0x0, add(0x20, _1002))) | |
| let _1004 := eq(and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, div(_1003, exp(0x100, 0x0)))), and(0xffffffffffffffffffffffffffffffffffffffff, 0x0)) | |
| if _1004{ | |
| _990 := _994 | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _985))) | |
| let _1005 := add(0x20, 0x0) | |
| mstore(_1005, 0x2) | |
| let _1006 := keccak256(0x0, add(0x20, _1005)) | |
| let _1007 := exp(0x100, 0x0) | |
| let _1008 := sload(_1006) | |
| sstore(_1006, or(mul(and(0xffffffffffffffffffffffffffffffffffffffff, _998), _1007), and(not(mul(0xffffffffffffffffffffffffffffffffffffffff, _1007)), _1008))) | |
| _993 := 0x1 | |
| _994 := add(_993, _990) | |
| _987 := _994 | |
| _988 := _994 | |
| _989 := _994 | |
| _990 := _994 | |
| } | |
| if not(_1004){ | |
| let _1009 := mload(0x40) | |
| mstore(_1009, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _1010 := add(0x4, _1009) | |
| let _1011 := add(0x20, _1010) | |
| mstore(_1010, sub(_1011, _1010)) | |
| mstore(_1011, 0x20) | |
| let _1012 := add(0x20, _1011) | |
| mstore(_1012, 0x4475706c6963617465206f776e657220616464726573732070726f7669646564) | |
| let _1013 := mload(0x40) | |
| revert(_1013, sub(add(0x20, _1012), _1013)) | |
| } | |
| } | |
| if not(_1000){ | |
| let _1014 := mload(0x40) | |
| mstore(_1014, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _1015 := add(0x4, _1014) | |
| let _1016 := add(0x20, _1015) | |
| mstore(_1015, sub(_1016, _1015)) | |
| mstore(_1016, 0x1e) | |
| let _1017 := add(0x20, _1016) | |
| mstore(_1017, 0x496e76616c6964206f776e657220616464726573732070726f76696465640000) | |
| let _1018 := mload(0x40) | |
| revert(_1018, sub(add(0x20, _1017), _1018)) | |
| } | |
| } | |
| if not(_997){ | |
| invalid() | |
| break | |
| } | |
| } | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _986))) | |
| let _1019 := add(0x20, 0x0) | |
| mstore(_1019, 0x2) | |
| let _1020 := keccak256(0x0, add(0x20, _1019)) | |
| let _1021 := exp(0x100, 0x0) | |
| let _1022 := sload(_1020) | |
| sstore(_1020, or(mul(and(0xffffffffffffffffffffffffffffffffffffffff, 0x1), _1021), and(not(mul(0xffffffffffffffffffffffffffffffffffffffff, _1021)), _1022))) | |
| let _1023 := mload(_976) | |
| sstore(0x3, _1023) | |
| sstore(0x4, _950) | |
| let _1024 := eq(and(0xffffffffffffffffffffffffffffffffffffffff, _962), and(0xffffffffffffffffffffffffffffffffffffffff, 0x0)) | |
| if not(_1024){ | |
| sstore(shl(0x0, 0x6c9a6c4a39284e37ed1cf53d337577d14212a4870fb976a4366c693b939918d5), _962) | |
| } | |
| let _1025 := mload(0x40) | |
| mstore(0x40, add(_1025, add(0x20, mul(div(add(0x1f, _959), 0x20), 0x20)))) | |
| mstore(_1025, _959) | |
| let _1026 := add(0x20, _1025) | |
| calldatacopy(_1026, _960, _959) | |
| mstore(add(_1026, _959), 0x0) | |
| let _1027 := add(_1026, and(add(_959, 0x1f), not(0x1f))) | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, 0x1))) | |
| let _1028 := add(0x20, 0x0) | |
| mstore(_1028, 0x1) | |
| let _1029 := sload(keccak256(0x0, add(0x20, _1028))) | |
| let _1030 := eq(and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, div(_1029, exp(0x100, 0x0)))), and(0xffffffffffffffffffffffffffffffffffffffff, 0x0)) | |
| if _1030{ | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, 0x1))) | |
| let _1031 := add(0x20, 0x0) | |
| mstore(_1031, 0x1) | |
| let _1032 := keccak256(0x0, add(0x20, _1031)) | |
| let _1033 := exp(0x100, 0x0) | |
| let _1034 := sload(_1032) | |
| sstore(_1032, or(mul(and(0xffffffffffffffffffffffffffffffffffffffff, 0x1), _1033), and(not(mul(0xffffffffffffffffffffffffffffffffffffffff, _1033)), _1034))) | |
| let _1035 := eq(and(0xffffffffffffffffffffffffffffffffffffffff, _952), and(0xffffffffffffffffffffffffffffffffffffffff, 0x0)) | |
| if not(_1035){ | |
| let _1036 := mload(_1025) | |
| let _1037 := delegatecall(gas(), _952, add(_1025, 0x20), _1036, 0x0, 0x0) | |
| if not(_1037){ | |
| let _1038 := mload(0x40) | |
| mstore(_1038, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _1039 := add(0x4, _1038) | |
| let _1040 := add(0x20, _1039) | |
| mstore(_1039, sub(_1040, _1039)) | |
| mstore(_1040, 0x1f) | |
| let _1041 := add(0x20, _1040) | |
| mstore(_1041, 0x436f756c64206e6f742066696e69736820696e697469616c697a6174696f6e00) | |
| let _1042 := mload(0x40) | |
| revert(_1042, sub(add(0x20, _1041), _1042)) | |
| } | |
| } | |
| let _1043 := iszero(gt(_965, 0x0)) | |
| if not(_1043){ | |
| let _1044 := func_0x50ca(and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(_966)), and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(_963)), 0x1, 0x0, _965, 0x2f63) | |
| } | |
| stop() | |
| } | |
| if not(_1030){ | |
| let _1045 := mload(0x40) | |
| mstore(_1045, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _1046 := add(0x4, _1045) | |
| let _1047 := add(0x20, _1046) | |
| mstore(_1046, sub(_1047, _1046)) | |
| mstore(_1047, 0x25) | |
| let _1048 := add(0x20, _1047) | |
| codecopy(_1048, 0x5b34, 0x25) | |
| let _1049 := mload(0x40) | |
| revert(_1049, sub(add(0x40, _1048), _1049)) | |
| } | |
| } | |
| if not(_984){ | |
| let _1050 := mload(0x40) | |
| mstore(_1050, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _1051 := add(0x4, _1050) | |
| let _1052 := add(0x20, _1051) | |
| mstore(_1051, sub(_1052, _1051)) | |
| mstore(_1052, 0x24) | |
| let _1053 := add(0x20, _1052) | |
| codecopy(_1053, 0x5c7a, 0x24) | |
| let _1054 := mload(0x40) | |
| revert(_1054, sub(add(0x40, _1053), _1054)) | |
| } | |
| } | |
| if not(_983){ | |
| let _1055 := mload(0x40) | |
| mstore(_1055, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _1056 := add(0x4, _1055) | |
| let _1057 := add(0x20, _1056) | |
| mstore(_1056, sub(_1057, _1056)) | |
| mstore(_1057, 0x23) | |
| let _1058 := add(0x20, _1057) | |
| codecopy(_1058, 0x5ba4, 0x23) | |
| let _1059 := mload(0x40) | |
| revert(_1059, sub(add(0x40, _1058), _1059)) | |
| } | |
| } | |
| default { | |
| let _1060 := mload(0x40) | |
| mstore(_1060, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _1061 := add(0x4, _1060) | |
| let _1062 := add(0x20, _1061) | |
| mstore(_1061, sub(_1062, _1061)) | |
| mstore(_1062, 0x1e) | |
| let _1063 := add(0x20, _1062) | |
| mstore(_1063, 0x4f776e657273206861766520616c7265616479206265656e2073657475700000) | |
| let _1064 := mload(0x40) | |
| revert(_1064, sub(add(0x20, _1063), _1064)) | |
| } | |
| } | |
| if not(_969){ | |
| let _1065 := mload(0x40) | |
| mstore(_1065, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _1066 := add(0x4, _1065) | |
| let _1067 := add(0x20, _1066) | |
| mstore(_1066, sub(_1067, _1066)) | |
| mstore(_1067, 0x1d) | |
| let _1068 := add(0x20, _1067) | |
| mstore(_1068, 0x446f6d61696e20536570617261746f7220616c72656164792073657421000000) | |
| let _1069 := mload(0x40) | |
| revert(_1069, sub(add(0x20, _1068), _1069)) | |
| } | |
| } | |
| function func_requiredTxGas() { | |
| let _1070 := 0x0 | |
| let _1071 := iszero(callvalue()) | |
| require(not(_1071)) | |
| let _1072 := sub(calldatasize(), 0x4) | |
| let _1073 := iszero(lt(_1072, 0x80)) | |
| require(not(_1073)) | |
| let _1074 := add(0x4, _1072) | |
| let _1075 := and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(0x4)) | |
| let _1076 := add(0x20, 0x4) | |
| let _1077 := add(0x20, _1076) | |
| let _1078 := calldataload(_1077) | |
| let _1079 := add(0x20, _1077) | |
| let _1080 := iszero(gt(_1078, 0x100000000)) | |
| require(not(_1080)) | |
| let _1081 := add(0x4, _1078) | |
| let _1082 := iszero(gt(add(_1081, 0x20), _1074)) | |
| require(not(_1082)) | |
| let _1083 := calldataload(_1081) | |
| let _1084 := add(0x20, _1081) | |
| let _1085 := iszero(or(gt(_1083, 0x100000000), gt(add(_1084, mul(_1083, 0x1)), _1074))) | |
| require(not(_1085)) | |
| let _1086 := and(0xff, calldataload(_1079)) | |
| let _1087 := add(0x20, _1079) | |
| let _1088 := eq(and(0xffffffffffffffffffffffffffffffffffffffff, caller()), and(0xffffffffffffffffffffffffffffffffffffffff, address())) | |
| if _1088{ | |
| let _1089 := mload(0x40) | |
| mstore(0x40, add(_1089, add(0x20, mul(div(add(0x1f, _1083), 0x20), 0x20)))) | |
| mstore(_1089, _1083) | |
| let _1090 := add(0x20, _1089) | |
| calldatacopy(_1090, _1084, _1083) | |
| mstore(add(_1090, _1083), 0x0) | |
| let _1091 := add(_1090, and(add(_1083, 0x1f), not(0x1f))) | |
| let _1092 := gas() | |
| let _1093 := iszero(gt(0x0, 0x1)) | |
| if _1093{ | |
| let _1094 := iszero(gt(_1086, 0x1)) | |
| if _1094{ | |
| let _1095 := iszero(eq(_1086, 0x0)) | |
| if _1095{ | |
| let _1096 := iszero(gt(0x1, 0x1)) | |
| if _1096{ | |
| let _1097 := iszero(gt(_1086, 0x1)) | |
| if _1097{ | |
| let _1098 := iszero(eq(_1086, 0x1)) | |
| if _1098{ | |
| let _1099 := 0x0 | |
| } | |
| if not(_1098){ | |
| let _1100 := mload(_1089) | |
| let _1101 := delegatecall(_1092, _1075, add(_1089, 0x20), _1100, 0x0, 0x0) | |
| let _1099 := _1101 | |
| } | |
| } | |
| if not(_1097){ | |
| invalid() | |
| } | |
| } | |
| if not(_1096){ | |
| invalid() | |
| } | |
| } | |
| if not(_1095){ | |
| let _1102 := mload(_1089) | |
| let _1103 := call(_1092, _1075, calldataload(_1076), add(_1089, 0x20), _1102, 0x0, 0x0) | |
| _1070 := _1103 | |
| } | |
| require(not(_1070)) | |
| let _1104 := mload(0x40) | |
| let _1105 := add(0x20, _1104) | |
| mstore(_1105, sub(gas(), gas())) | |
| let _1106 := add(0x20, _1105) | |
| let _1107 := mload(0x40) | |
| mstore(_1107, sub(sub(_1106, _1107), 0x20)) | |
| mstore(0x40, _1106) | |
| let _1108 := mload(0x40) | |
| mstore(_1108, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _1109 := add(0x4, _1108) | |
| let _1110 := add(0x20, _1109) | |
| mstore(_1109, sub(_1110, _1109)) | |
| let _1111 := mload(_1107) | |
| mstore(_1110, _1111) | |
| let _1112 := add(0x20, _1110) | |
| let _1113 := mload(_1107) | |
| let _1114 := 0x0 | |
| let _1115 := 0x0 | |
| for { | |
| let _1116 := lt(_1114, _1113) | |
| let _1117 := 0x20 | |
| let _1118 := add(_1115, _1117) | |
| } | |
| not(iszero(_1116)) | |
| { } | |
| { | |
| _1114 := _1118 | |
| _1116 := lt(_1114, _1113) | |
| let _1119 := not(iszero(_1116)) | |
| _1115 := _1118 | |
| let _1120 := mload(add(add(0x20, _1107), _1115)) | |
| mstore(add(_1112, _1115), _1120) | |
| _1117 := 0x20 | |
| _1118 := add(_1115, _1117) | |
| _1114 := _1118 | |
| _1115 := _1118 | |
| } | |
| let _1121 := add(_1113, _1112) | |
| let _1122 := _1121 | |
| let _1123 := and(0x1f, _1113) | |
| let _1124 := iszero(_1123) | |
| if not(_1124){ | |
| let _1125 := sub(_1121, _1123) | |
| let _1126 := mload(_1125) | |
| mstore(_1125, and(not(sub(exp(0x100, sub(0x20, _1123)), 0x1)), _1126)) | |
| _1122 := add(0x20, _1125) | |
| } | |
| let _1127 := mload(0x40) | |
| revert(_1127, sub(_1122, _1127)) | |
| } | |
| if not(_1094){ | |
| invalid() | |
| } | |
| } | |
| if not(_1093){ | |
| invalid() | |
| } | |
| } | |
| if not(_1088){ | |
| let _1128 := mload(0x40) | |
| mstore(_1128, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _1129 := add(0x4, _1128) | |
| let _1130 := add(0x20, _1129) | |
| mstore(_1129, sub(_1130, _1129)) | |
| mstore(_1130, 0x2c) | |
| let _1131 := add(0x20, _1130) | |
| codecopy(_1131, 0x5cd5, 0x2c) | |
| let _1132 := mload(0x40) | |
| revert(_1132, sub(add(0x40, _1131), _1132)) | |
| } | |
| } | |
| function func_getModulesPaginated() { | |
| let _1133 := iszero(callvalue()) | |
| require(not(_1133)) | |
| let _1134 := sub(calldatasize(), 0x4) | |
| let _1135 := iszero(lt(_1134, 0x40)) | |
| require(not(_1135)) | |
| let _1136 := add(0x4, _1134) | |
| let _1137 := add(0x20, 0x4) | |
| let _1138 := add(0x20, _1137) | |
| let _1139, _1140 := func_0x311e(calldataload(_1137), and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(0x4)), 0xfb5) | |
| let _1141 := mload(0x40) | |
| let _1142 := add(0x20, _1141) | |
| mstore(_1142, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _1139))) | |
| let _1143 := add(0x20, _1142) | |
| mstore(_1141, sub(_1143, _1141)) | |
| let _1144 := mload(_1140) | |
| mstore(_1143, _1144) | |
| let _1145 := add(0x20, _1143) | |
| let _1146 := mload(_1140) | |
| let _1147 := mul(0x20, _1146) | |
| let _1148 := 0x0 | |
| let _1149 := 0x0 | |
| for { | |
| let _1150 := lt(_1148, _1147) | |
| let _1151 := 0x20 | |
| let _1152 := add(_1149, _1151) | |
| } | |
| not(iszero(_1150)) | |
| { } | |
| { | |
| _1148 := _1152 | |
| _1150 := lt(_1148, _1147) | |
| let _1153 := not(iszero(_1150)) | |
| _1149 := _1152 | |
| let _1154 := mload(add(add(0x20, _1140), _1149)) | |
| mstore(add(_1145, _1149), _1154) | |
| _1151 := 0x20 | |
| _1152 := add(_1149, _1151) | |
| _1148 := _1152 | |
| _1149 := _1152 | |
| } | |
| let _1155 := mload(0x40) | |
| return(_1155, sub(add(_1147, _1145), _1155)) | |
| } | |
| function func_approveHash() { | |
| let _1156 := iszero(callvalue()) | |
| require(not(_1156)) | |
| let _1157 := sub(calldatasize(), 0x4) | |
| let _1158 := iszero(lt(_1157, 0x20)) | |
| require(not(_1158)) | |
| let _1159 := add(0x4, _1157) | |
| let _1160 := calldataload(0x4) | |
| let _1161 := add(0x20, 0x4) | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, caller()))) | |
| let _1162 := add(0x20, 0x0) | |
| mstore(_1162, 0x2) | |
| let _1163 := sload(keccak256(0x0, add(0x20, _1162))) | |
| let _1164 := iszero(eq(and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, div(_1163, exp(0x100, 0x0)))), and(0xffffffffffffffffffffffffffffffffffffffff, 0x0))) | |
| if _1164{ | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, caller()))) | |
| let _1165 := add(0x20, 0x0) | |
| mstore(_1165, 0x8) | |
| mstore(0x0, _1160) | |
| let _1166 := add(0x20, 0x0) | |
| mstore(_1166, keccak256(0x0, add(0x20, _1165))) | |
| sstore(keccak256(0x0, add(0x20, _1166)), 0x1) | |
| let _1167 := mload(0x40) | |
| let _1168 := mload(0x40) | |
| log3(_1168, sub(_1167, _1168), 0xf2a0eb156472d1440255b0d7c1e19cc07115d1051fe605b0dce69acfec884d9c, _1160, and(0xffffffffffffffffffffffffffffffffffffffff, caller())) | |
| stop() | |
| } | |
| if not(_1164){ | |
| let _1169 := mload(0x40) | |
| mstore(_1169, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _1170 := add(0x4, _1169) | |
| let _1171 := add(0x20, _1170) | |
| mstore(_1170, sub(_1171, _1170)) | |
| mstore(_1171, 0x1e) | |
| let _1172 := add(0x20, _1171) | |
| mstore(_1172, 0x4f6e6c79206f776e6572732063616e20617070726f7665206120686173680000) | |
| let _1173 := mload(0x40) | |
| revert(_1173, sub(add(0x20, _1172), _1173)) | |
| } | |
| } | |
| function func_getTransactionHash() { | |
| let _1174 := iszero(callvalue()) | |
| require(not(_1174)) | |
| let _1175 := sub(calldatasize(), 0x4) | |
| let _1176 := iszero(lt(_1175, 0x140)) | |
| require(not(_1176)) | |
| let _1177 := add(0x4, _1175) | |
| let _1178 := add(0x20, 0x4) | |
| let _1179 := add(0x20, _1178) | |
| let _1180 := calldataload(_1179) | |
| let _1181 := add(0x20, _1179) | |
| let _1182 := iszero(gt(_1180, 0x100000000)) | |
| require(not(_1182)) | |
| let _1183 := add(0x4, _1180) | |
| let _1184 := iszero(gt(add(_1183, 0x20), _1177)) | |
| require(not(_1184)) | |
| let _1185 := calldataload(_1183) | |
| let _1186 := add(0x20, _1183) | |
| let _1187 := iszero(or(gt(_1185, 0x100000000), gt(add(_1186, mul(_1185, 0x1)), _1177))) | |
| require(not(_1187)) | |
| let _1188 := mload(0x40) | |
| mstore(0x40, add(_1188, add(0x20, mul(div(add(0x1f, _1185), 0x20), 0x20)))) | |
| mstore(_1188, _1185) | |
| let _1189 := add(0x20, _1188) | |
| calldatacopy(_1189, _1186, _1185) | |
| mstore(add(_1189, _1185), 0x0) | |
| let _1190 := add(_1189, and(add(_1185, 0x1f), not(0x1f))) | |
| let _1191 := and(0xff, calldataload(_1181)) | |
| let _1192 := add(0x20, _1181) | |
| let _1193 := add(0x20, _1192) | |
| let _1194 := add(0x20, _1193) | |
| let _1195 := add(0x20, _1194) | |
| let _1196 := add(0x20, _1195) | |
| let _1197 := add(0x20, _1196) | |
| let _1198 := add(0x20, _1197) | |
| let _1199 := mload(_1188) | |
| let _1200 := mload(0x40) | |
| let _1201 := add(0x20, _1200) | |
| mstore(_1201, shl(0x0, 0xbb8310d486368db6bd6f849402fdd73ad53d316b5a4b2644ad6efe0f941286d8)) | |
| let _1202 := add(0x20, _1201) | |
| mstore(_1202, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(0x4))))) | |
| let _1203 := add(0x20, _1202) | |
| mstore(_1203, calldataload(_1178)) | |
| let _1204 := add(0x20, _1203) | |
| mstore(_1204, keccak256(add(0x20, _1188), _1199)) | |
| let _1205 := add(0x20, _1204) | |
| let _1206 := iszero(gt(_1191, 0x1)) | |
| if _1206{ | |
| mstore(_1205, and(0xff, _1191)) | |
| let _1207 := add(0x20, _1205) | |
| mstore(_1207, calldataload(_1192)) | |
| let _1208 := add(0x20, _1207) | |
| mstore(_1208, calldataload(_1193)) | |
| let _1209 := add(0x20, _1208) | |
| mstore(_1209, calldataload(_1194)) | |
| let _1210 := add(0x20, _1209) | |
| mstore(_1210, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(_1195))))) | |
| let _1211 := add(0x20, _1210) | |
| mstore(_1211, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(_1196))))) | |
| let _1212 := add(0x20, _1211) | |
| mstore(_1212, calldataload(_1197)) | |
| let _1213 := add(0x20, _1212) | |
| let _1214 := mload(0x40) | |
| mstore(_1214, sub(sub(_1213, _1214), 0x20)) | |
| mstore(0x40, _1213) | |
| let _1215 := mload(_1214) | |
| let _1216 := sload(0x6) | |
| let _1217 := mload(0x40) | |
| let _1218 := add(0x20, _1217) | |
| mstore(_1218, and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), shl(0xf8, 0x19)))) | |
| let _1219 := add(0x1, _1218) | |
| mstore(_1219, and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), shl(0xf8, 0x1)))) | |
| let _1220 := add(0x1, _1219) | |
| mstore(_1220, _1216) | |
| let _1221 := add(0x20, _1220) | |
| mstore(_1221, keccak256(add(0x20, _1214), _1215)) | |
| let _1222 := add(0x20, _1221) | |
| let _1223 := mload(0x40) | |
| mstore(_1223, sub(sub(_1222, _1223), 0x20)) | |
| mstore(0x40, _1222) | |
| let _1224 := mload(_1223) | |
| let _1225 := mload(0x40) | |
| mstore(_1225, keccak256(add(0x20, _1223), _1224)) | |
| let _1226 := mload(0x40) | |
| return(_1226, sub(add(0x20, _1225), _1226)) | |
| } | |
| if not(_1206){ | |
| invalid() | |
| } | |
| } | |
| function func_disableModule() { | |
| let _1227 := iszero(callvalue()) | |
| require(not(_1227)) | |
| let _1228 := sub(calldatasize(), 0x4) | |
| let _1229 := iszero(lt(_1228, 0x40)) | |
| require(not(_1229)) | |
| let _1230 := add(0x4, _1228) | |
| let _1231 := and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(0x4)) | |
| let _1232 := add(0x20, 0x4) | |
| let _1233 := and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(_1232)) | |
| let _1234 := add(0x20, _1232) | |
| let _1235 := eq(and(0xffffffffffffffffffffffffffffffffffffffff, caller()), and(0xffffffffffffffffffffffffffffffffffffffff, address())) | |
| if _1235{ | |
| let _1236 := iszero(eq(and(0xffffffffffffffffffffffffffffffffffffffff, _1233), and(0xffffffffffffffffffffffffffffffffffffffff, 0x0))) | |
| let _1237 := _1236 | |
| let _1238 := iszero(_1236) | |
| if not(_1238){ | |
| _1237 := iszero(eq(and(0xffffffffffffffffffffffffffffffffffffffff, _1233), and(0xffffffffffffffffffffffffffffffffffffffff, 0x1))) | |
| } | |
| if _1237{ | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _1231))) | |
| let _1239 := add(0x20, 0x0) | |
| mstore(_1239, 0x1) | |
| let _1240 := sload(keccak256(0x0, add(0x20, _1239))) | |
| let _1241 := eq(and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, div(_1240, exp(0x100, 0x0)))), and(0xffffffffffffffffffffffffffffffffffffffff, _1233)) | |
| if _1241{ | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _1233))) | |
| let _1242 := add(0x20, 0x0) | |
| mstore(_1242, 0x1) | |
| let _1243 := sload(keccak256(0x0, add(0x20, _1242))) | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _1231))) | |
| let _1244 := add(0x20, 0x0) | |
| mstore(_1244, 0x1) | |
| let _1245 := keccak256(0x0, add(0x20, _1244)) | |
| let _1246 := exp(0x100, 0x0) | |
| let _1247 := sload(_1245) | |
| sstore(_1245, or(mul(and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, div(_1243, exp(0x100, 0x0)))), _1246), and(not(mul(0xffffffffffffffffffffffffffffffffffffffff, _1246)), _1247))) | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _1233))) | |
| let _1248 := add(0x20, 0x0) | |
| mstore(_1248, 0x1) | |
| let _1249 := keccak256(0x0, add(0x20, _1248)) | |
| let _1250 := exp(0x100, 0x0) | |
| let _1251 := sload(_1249) | |
| sstore(_1249, or(mul(and(0xffffffffffffffffffffffffffffffffffffffff, 0x0), _1250), and(not(mul(0xffffffffffffffffffffffffffffffffffffffff, _1250)), _1251))) | |
| let _1252 := mload(0x40) | |
| mstore(_1252, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _1233))) | |
| let _1253 := mload(0x40) | |
| log1(_1253, sub(add(0x20, _1252), _1253), 0xaab4fa2b463f581b2b32cb3b7e3b704b9ce37cc209b5fb4d77e593ace4054276) | |
| stop() | |
| } | |
| if not(_1241){ | |
| let _1254 := mload(0x40) | |
| mstore(_1254, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _1255 := add(0x4, _1254) | |
| let _1256 := add(0x20, _1255) | |
| mstore(_1255, sub(_1256, _1255)) | |
| mstore(_1256, 0x28) | |
| let _1257 := add(0x20, _1256) | |
| codecopy(_1257, 0x5b7c, 0x28) | |
| let _1258 := mload(0x40) | |
| revert(_1258, sub(add(0x40, _1257), _1258)) | |
| } | |
| } | |
| if not(_1237){ | |
| let _1259 := mload(0x40) | |
| mstore(_1259, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _1260 := add(0x4, _1259) | |
| let _1261 := add(0x20, _1260) | |
| mstore(_1260, sub(_1261, _1260)) | |
| mstore(_1261, 0x1f) | |
| let _1262 := add(0x20, _1261) | |
| mstore(_1262, 0x496e76616c6964206d6f64756c6520616464726573732070726f766964656400) | |
| let _1263 := mload(0x40) | |
| revert(_1263, sub(add(0x20, _1262), _1263)) | |
| } | |
| } | |
| if not(_1235){ | |
| let _1264 := mload(0x40) | |
| mstore(_1264, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _1265 := add(0x4, _1264) | |
| let _1266 := add(0x20, _1265) | |
| mstore(_1265, sub(_1266, _1265)) | |
| mstore(_1266, 0x2c) | |
| let _1267 := add(0x20, _1266) | |
| codecopy(_1267, 0x5cd5, 0x2c) | |
| let _1268 := mload(0x40) | |
| revert(_1268, sub(add(0x40, _1267), _1268)) | |
| } | |
| } | |
| function func_swapOwner() { | |
| let _1269 := iszero(callvalue()) | |
| require(not(_1269)) | |
| let _1270 := sub(calldatasize(), 0x4) | |
| let _1271 := iszero(lt(_1270, 0x60)) | |
| require(not(_1271)) | |
| let _1272 := add(0x4, _1270) | |
| let _1273 := and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(0x4)) | |
| let _1274 := add(0x20, 0x4) | |
| let _1275 := and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(_1274)) | |
| let _1276 := add(0x20, _1274) | |
| let _1277 := and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(_1276)) | |
| let _1278 := add(0x20, _1276) | |
| let _1279 := eq(and(0xffffffffffffffffffffffffffffffffffffffff, caller()), and(0xffffffffffffffffffffffffffffffffffffffff, address())) | |
| if _1279{ | |
| let _1280 := iszero(eq(and(0xffffffffffffffffffffffffffffffffffffffff, _1277), and(0xffffffffffffffffffffffffffffffffffffffff, 0x0))) | |
| let _1281 := _1280 | |
| let _1282 := iszero(_1280) | |
| if not(_1282){ | |
| _1281 := iszero(eq(and(0xffffffffffffffffffffffffffffffffffffffff, _1277), and(0xffffffffffffffffffffffffffffffffffffffff, 0x1))) | |
| } | |
| if _1281{ | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _1277))) | |
| let _1283 := add(0x20, 0x0) | |
| mstore(_1283, 0x2) | |
| let _1284 := sload(keccak256(0x0, add(0x20, _1283))) | |
| let _1285 := eq(and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, div(_1284, exp(0x100, 0x0)))), and(0xffffffffffffffffffffffffffffffffffffffff, 0x0)) | |
| if _1285{ | |
| let _1286 := iszero(eq(and(0xffffffffffffffffffffffffffffffffffffffff, _1275), and(0xffffffffffffffffffffffffffffffffffffffff, 0x0))) | |
| let _1287 := _1286 | |
| let _1288 := iszero(_1286) | |
| if not(_1288){ | |
| _1287 := iszero(eq(and(0xffffffffffffffffffffffffffffffffffffffff, _1275), and(0xffffffffffffffffffffffffffffffffffffffff, 0x1))) | |
| } | |
| if _1287{ | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _1273))) | |
| let _1289 := add(0x20, 0x0) | |
| mstore(_1289, 0x2) | |
| let _1290 := sload(keccak256(0x0, add(0x20, _1289))) | |
| let _1291 := eq(and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, div(_1290, exp(0x100, 0x0)))), and(0xffffffffffffffffffffffffffffffffffffffff, _1275)) | |
| if _1291{ | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _1275))) | |
| let _1292 := add(0x20, 0x0) | |
| mstore(_1292, 0x2) | |
| let _1293 := sload(keccak256(0x0, add(0x20, _1292))) | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _1277))) | |
| let _1294 := add(0x20, 0x0) | |
| mstore(_1294, 0x2) | |
| let _1295 := keccak256(0x0, add(0x20, _1294)) | |
| let _1296 := exp(0x100, 0x0) | |
| let _1297 := sload(_1295) | |
| sstore(_1295, or(mul(and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, div(_1293, exp(0x100, 0x0)))), _1296), and(not(mul(0xffffffffffffffffffffffffffffffffffffffff, _1296)), _1297))) | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _1273))) | |
| let _1298 := add(0x20, 0x0) | |
| mstore(_1298, 0x2) | |
| let _1299 := keccak256(0x0, add(0x20, _1298)) | |
| let _1300 := exp(0x100, 0x0) | |
| let _1301 := sload(_1299) | |
| sstore(_1299, or(mul(and(0xffffffffffffffffffffffffffffffffffffffff, _1277), _1300), and(not(mul(0xffffffffffffffffffffffffffffffffffffffff, _1300)), _1301))) | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _1275))) | |
| let _1302 := add(0x20, 0x0) | |
| mstore(_1302, 0x2) | |
| let _1303 := keccak256(0x0, add(0x20, _1302)) | |
| let _1304 := exp(0x100, 0x0) | |
| let _1305 := sload(_1303) | |
| sstore(_1303, or(mul(and(0xffffffffffffffffffffffffffffffffffffffff, 0x0), _1304), and(not(mul(0xffffffffffffffffffffffffffffffffffffffff, _1304)), _1305))) | |
| let _1306 := mload(0x40) | |
| mstore(_1306, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _1275))) | |
| let _1307 := mload(0x40) | |
| log1(_1307, sub(add(0x20, _1306), _1307), 0xf8d49fc529812e9a7c5c50e69c20f0dccc0db8fa95c98bc58cc9a4f1c1299eaf) | |
| let _1308 := mload(0x40) | |
| mstore(_1308, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _1277))) | |
| let _1309 := mload(0x40) | |
| log1(_1309, sub(add(0x20, _1308), _1309), 0x9465fa0c962cc76958e6373a993326400c1c94f8be2fe3a952adfa7f60b2ea26) | |
| stop() | |
| } | |
| if not(_1291){ | |
| let _1310 := mload(0x40) | |
| mstore(_1310, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _1311 := add(0x4, _1310) | |
| let _1312 := add(0x20, _1311) | |
| mstore(_1311, sub(_1312, _1311)) | |
| mstore(_1312, 0x26) | |
| let _1313 := add(0x20, _1312) | |
| codecopy(_1313, 0x5c1e, 0x26) | |
| let _1314 := mload(0x40) | |
| revert(_1314, sub(add(0x40, _1313), _1314)) | |
| } | |
| } | |
| if not(_1287){ | |
| let _1315 := mload(0x40) | |
| mstore(_1315, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _1316 := add(0x4, _1315) | |
| let _1317 := add(0x20, _1316) | |
| mstore(_1316, sub(_1317, _1316)) | |
| mstore(_1317, 0x1e) | |
| let _1318 := add(0x20, _1317) | |
| mstore(_1318, 0x496e76616c6964206f776e657220616464726573732070726f76696465640000) | |
| let _1319 := mload(0x40) | |
| revert(_1319, sub(add(0x20, _1318), _1319)) | |
| } | |
| } | |
| if not(_1285){ | |
| let _1320 := mload(0x40) | |
| mstore(_1320, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _1321 := add(0x4, _1320) | |
| let _1322 := add(0x20, _1321) | |
| mstore(_1321, sub(_1322, _1321)) | |
| mstore(_1322, 0x1b) | |
| let _1323 := add(0x20, _1322) | |
| mstore(_1323, 0x4164647265737320697320616c726561647920616e206f776e65720000000000) | |
| let _1324 := mload(0x40) | |
| revert(_1324, sub(add(0x20, _1323), _1324)) | |
| } | |
| } | |
| if not(_1281){ | |
| let _1325 := mload(0x40) | |
| mstore(_1325, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _1326 := add(0x4, _1325) | |
| let _1327 := add(0x20, _1326) | |
| mstore(_1326, sub(_1327, _1326)) | |
| mstore(_1327, 0x1e) | |
| let _1328 := add(0x20, _1327) | |
| mstore(_1328, 0x496e76616c6964206f776e657220616464726573732070726f76696465640000) | |
| let _1329 := mload(0x40) | |
| revert(_1329, sub(add(0x20, _1328), _1329)) | |
| } | |
| } | |
| if not(_1279){ | |
| let _1330 := mload(0x40) | |
| mstore(_1330, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _1331 := add(0x4, _1330) | |
| let _1332 := add(0x20, _1331) | |
| mstore(_1331, sub(_1332, _1331)) | |
| mstore(_1332, 0x2c) | |
| let _1333 := add(0x20, _1332) | |
| codecopy(_1333, 0x5cd5, 0x2c) | |
| let _1334 := mload(0x40) | |
| revert(_1334, sub(add(0x40, _1333), _1334)) | |
| } | |
| } | |
| function func_getThreshold() { | |
| let _1335 := iszero(callvalue()) | |
| require(not(_1335)) | |
| let _1336 := sload(0x4) | |
| let _1337 := mload(0x40) | |
| mstore(_1337, _1336) | |
| let _1338 := mload(0x40) | |
| return(_1338, sub(add(0x20, _1337), _1338)) | |
| } | |
| function func_encodeTransactionData() { | |
| let _1339 := iszero(callvalue()) | |
| require(not(_1339)) | |
| let _1340 := sub(calldatasize(), 0x4) | |
| let _1341 := iszero(lt(_1340, 0x140)) | |
| require(not(_1341)) | |
| let _1342 := add(0x4, _1340) | |
| let _1343 := add(0x20, 0x4) | |
| let _1344 := add(0x20, _1343) | |
| let _1345 := calldataload(_1344) | |
| let _1346 := add(0x20, _1344) | |
| let _1347 := iszero(gt(_1345, 0x100000000)) | |
| require(not(_1347)) | |
| let _1348 := add(0x4, _1345) | |
| let _1349 := iszero(gt(add(_1348, 0x20), _1342)) | |
| require(not(_1349)) | |
| let _1350 := calldataload(_1348) | |
| let _1351 := add(0x20, _1348) | |
| let _1352 := iszero(or(gt(_1350, 0x100000000), gt(add(_1351, mul(_1350, 0x1)), _1342))) | |
| require(not(_1352)) | |
| let _1353 := mload(0x40) | |
| mstore(0x40, add(_1353, add(0x20, mul(div(add(0x1f, _1350), 0x20), 0x20)))) | |
| mstore(_1353, _1350) | |
| let _1354 := add(0x20, _1353) | |
| calldatacopy(_1354, _1351, _1350) | |
| mstore(add(_1354, _1350), 0x0) | |
| let _1355 := add(_1354, and(add(_1350, 0x1f), not(0x1f))) | |
| let _1356 := and(0xff, calldataload(_1346)) | |
| let _1357 := add(0x20, _1346) | |
| let _1358 := add(0x20, _1357) | |
| let _1359 := add(0x20, _1358) | |
| let _1360 := add(0x20, _1359) | |
| let _1361 := add(0x20, _1360) | |
| let _1362 := add(0x20, _1361) | |
| let _1363 := add(0x20, _1362) | |
| let _1364 := mload(_1353) | |
| let _1365 := mload(0x40) | |
| let _1366 := add(0x20, _1365) | |
| mstore(_1366, shl(0x0, 0xbb8310d486368db6bd6f849402fdd73ad53d316b5a4b2644ad6efe0f941286d8)) | |
| let _1367 := add(0x20, _1366) | |
| mstore(_1367, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(0x4))))) | |
| let _1368 := add(0x20, _1367) | |
| mstore(_1368, calldataload(_1343)) | |
| let _1369 := add(0x20, _1368) | |
| mstore(_1369, keccak256(add(0x20, _1353), _1364)) | |
| let _1370 := add(0x20, _1369) | |
| let _1371 := iszero(gt(_1356, 0x1)) | |
| if _1371{ | |
| mstore(_1370, and(0xff, _1356)) | |
| let _1372 := add(0x20, _1370) | |
| mstore(_1372, calldataload(_1357)) | |
| let _1373 := add(0x20, _1372) | |
| mstore(_1373, calldataload(_1358)) | |
| let _1374 := add(0x20, _1373) | |
| mstore(_1374, calldataload(_1359)) | |
| let _1375 := add(0x20, _1374) | |
| mstore(_1375, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(_1360))))) | |
| let _1376 := add(0x20, _1375) | |
| mstore(_1376, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(_1361))))) | |
| let _1377 := add(0x20, _1376) | |
| mstore(_1377, calldataload(_1362)) | |
| let _1378 := add(0x20, _1377) | |
| let _1379 := mload(0x40) | |
| mstore(_1379, sub(sub(_1378, _1379), 0x20)) | |
| mstore(0x40, _1378) | |
| let _1380 := mload(_1379) | |
| let _1381 := sload(0x6) | |
| let _1382 := mload(0x40) | |
| let _1383 := add(0x20, _1382) | |
| mstore(_1383, and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), shl(0xf8, 0x19)))) | |
| let _1384 := add(0x1, _1383) | |
| mstore(_1384, and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), and(not(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), shl(0xf8, 0x1)))) | |
| let _1385 := add(0x1, _1384) | |
| mstore(_1385, _1381) | |
| let _1386 := add(0x20, _1385) | |
| mstore(_1386, keccak256(add(0x20, _1379), _1380)) | |
| let _1387 := add(0x20, _1386) | |
| let _1388 := mload(0x40) | |
| mstore(_1388, sub(sub(_1387, _1388), 0x20)) | |
| mstore(0x40, _1387) | |
| let _1389 := mload(0x40) | |
| let _1390 := add(0x20, _1389) | |
| mstore(_1389, sub(_1390, _1389)) | |
| let _1391 := mload(_1388) | |
| mstore(_1390, _1391) | |
| let _1392 := add(0x20, _1390) | |
| let _1393 := mload(_1388) | |
| let _1394 := 0x0 | |
| let _1395 := 0x0 | |
| for { | |
| let _1396 := lt(_1394, _1393) | |
| let _1397 := 0x20 | |
| let _1398 := add(_1395, _1397) | |
| } | |
| not(iszero(_1396)) | |
| { } | |
| { | |
| _1394 := _1398 | |
| _1396 := lt(_1394, _1393) | |
| let _1399 := not(iszero(_1396)) | |
| _1395 := _1398 | |
| let _1400 := mload(add(add(0x20, _1388), _1395)) | |
| mstore(add(_1392, _1395), _1400) | |
| _1397 := 0x20 | |
| _1398 := add(_1395, _1397) | |
| _1394 := _1398 | |
| _1395 := _1398 | |
| } | |
| let _1401 := add(_1393, _1392) | |
| let _1402 := _1401 | |
| let _1403 := and(0x1f, _1393) | |
| let _1404 := iszero(_1403) | |
| if not(_1404){ | |
| let _1405 := sub(_1401, _1403) | |
| let _1406 := mload(_1405) | |
| mstore(_1405, and(not(sub(exp(0x100, sub(0x20, _1403)), 0x1)), _1406)) | |
| _1402 := add(0x20, _1405) | |
| } | |
| let _1407 := mload(0x40) | |
| return(_1407, sub(_1402, _1407)) | |
| } | |
| if not(_1371){ | |
| invalid() | |
| } | |
| } | |
| function func_setFallbackHandler() { | |
| let _1408 := iszero(callvalue()) | |
| require(not(_1408)) | |
| let _1409 := sub(calldatasize(), 0x4) | |
| let _1410 := iszero(lt(_1409, 0x20)) | |
| require(not(_1410)) | |
| let _1411 := add(0x4, _1409) | |
| let _1412 := add(0x20, 0x4) | |
| let _1413 := eq(and(0xffffffffffffffffffffffffffffffffffffffff, caller()), and(0xffffffffffffffffffffffffffffffffffffffff, address())) | |
| if _1413{ | |
| sstore(shl(0x0, 0x6c9a6c4a39284e37ed1cf53d337577d14212a4870fb976a4366c693b939918d5), and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(0x4))) | |
| stop() | |
| } | |
| if not(_1413){ | |
| let _1414 := mload(0x40) | |
| mstore(_1414, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _1415 := add(0x4, _1414) | |
| let _1416 := add(0x20, _1415) | |
| mstore(_1415, sub(_1416, _1415)) | |
| mstore(_1416, 0x2c) | |
| let _1417 := add(0x20, _1416) | |
| codecopy(_1417, 0x5cd5, 0x2c) | |
| let _1418 := mload(0x40) | |
| revert(_1418, sub(add(0x40, _1417), _1418)) | |
| } | |
| } | |
| function func_domainSeparator() { | |
| let _1419 := iszero(callvalue()) | |
| require(not(_1419)) | |
| let _1420 := sload(0x6) | |
| let _1421 := mload(0x40) | |
| mstore(_1421, _1420) | |
| let _1422 := mload(0x40) | |
| return(_1422, sub(add(0x20, _1421), _1422)) | |
| } | |
| function func_removeOwner() { | |
| let _1423 := iszero(callvalue()) | |
| require(not(_1423)) | |
| let _1424 := sub(calldatasize(), 0x4) | |
| let _1425 := iszero(lt(_1424, 0x60)) | |
| require(not(_1425)) | |
| let _1426 := add(0x4, _1424) | |
| let _1427 := and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(0x4)) | |
| let _1428 := add(0x20, 0x4) | |
| let _1429 := and(0xffffffffffffffffffffffffffffffffffffffff, calldataload(_1428)) | |
| let _1430 := add(0x20, _1428) | |
| let _1431 := calldataload(_1430) | |
| let _1432 := add(0x20, _1430) | |
| let _1433 := eq(and(0xffffffffffffffffffffffffffffffffffffffff, caller()), and(0xffffffffffffffffffffffffffffffffffffffff, address())) | |
| if _1433{ | |
| let _1434 := sload(0x3) | |
| let _1435 := iszero(lt(sub(_1434, 0x1), _1431)) | |
| if _1435{ | |
| let _1436 := iszero(eq(and(0xffffffffffffffffffffffffffffffffffffffff, _1429), and(0xffffffffffffffffffffffffffffffffffffffff, 0x0))) | |
| let _1437 := _1436 | |
| let _1438 := iszero(_1436) | |
| if not(_1438){ | |
| _1437 := iszero(eq(and(0xffffffffffffffffffffffffffffffffffffffff, _1429), and(0xffffffffffffffffffffffffffffffffffffffff, 0x1))) | |
| } | |
| if _1437{ | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _1427))) | |
| let _1439 := add(0x20, 0x0) | |
| mstore(_1439, 0x2) | |
| let _1440 := sload(keccak256(0x0, add(0x20, _1439))) | |
| let _1441 := eq(and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, div(_1440, exp(0x100, 0x0)))), and(0xffffffffffffffffffffffffffffffffffffffff, _1429)) | |
| if _1441{ | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _1429))) | |
| let _1442 := add(0x20, 0x0) | |
| mstore(_1442, 0x2) | |
| let _1443 := sload(keccak256(0x0, add(0x20, _1442))) | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _1427))) | |
| let _1444 := add(0x20, 0x0) | |
| mstore(_1444, 0x2) | |
| let _1445 := keccak256(0x0, add(0x20, _1444)) | |
| let _1446 := exp(0x100, 0x0) | |
| let _1447 := sload(_1445) | |
| sstore(_1445, or(mul(and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, div(_1443, exp(0x100, 0x0)))), _1446), and(not(mul(0xffffffffffffffffffffffffffffffffffffffff, _1446)), _1447))) | |
| mstore(0x0, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _1429))) | |
| let _1448 := add(0x20, 0x0) | |
| mstore(_1448, 0x2) | |
| let _1449 := keccak256(0x0, add(0x20, _1448)) | |
| let _1450 := exp(0x100, 0x0) | |
| let _1451 := sload(_1449) | |
| sstore(_1449, or(mul(and(0xffffffffffffffffffffffffffffffffffffffff, 0x0), _1450), and(not(mul(0xffffffffffffffffffffffffffffffffffffffff, _1450)), _1451))) | |
| let _1452 := sload(0x3) | |
| sstore(0x3, sub(_1452, 0x1)) | |
| let _1453 := mload(0x40) | |
| mstore(_1453, and(0xffffffffffffffffffffffffffffffffffffffff, and(0xffffffffffffffffffffffffffffffffffffffff, _1429))) | |
| let _1454 := mload(0x40) | |
| log1(_1454, sub(add(0x20, _1453), _1454), 0xf8d49fc529812e9a7c5c50e69c20f0dccc0db8fa95c98bc58cc9a4f1c1299eaf) | |
| let _1455 := sload(0x4) | |
| let _1456 := eq(_1455, _1431) | |
| if not(_1456){ | |
| func_0x24af(_1431, 0x46cb) | |
| } | |
| stop() | |
| } | |
| if not(_1441){ | |
| let _1457 := mload(0x40) | |
| mstore(_1457, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _1458 := add(0x4, _1457) | |
| let _1459 := add(0x20, _1458) | |
| mstore(_1458, sub(_1459, _1458)) | |
| mstore(_1459, 0x26) | |
| let _1460 := add(0x20, _1459) | |
| codecopy(_1460, 0x5c1e, 0x26) | |
| let _1461 := mload(0x40) | |
| revert(_1461, sub(add(0x40, _1460), _1461)) | |
| } | |
| } | |
| if not(_1437){ | |
| let _1462 := mload(0x40) | |
| mstore(_1462, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _1463 := add(0x4, _1462) | |
| let _1464 := add(0x20, _1463) | |
| mstore(_1463, sub(_1464, _1463)) | |
| mstore(_1464, 0x1e) | |
| let _1465 := add(0x20, _1464) | |
| mstore(_1465, 0x496e76616c6964206f776e657220616464726573732070726f76696465640000) | |
| let _1466 := mload(0x40) | |
| revert(_1466, sub(add(0x20, _1465), _1466)) | |
| } | |
| } | |
| if not(_1435){ | |
| let _1467 := mload(0x40) | |
| mstore(_1467, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _1468 := add(0x4, _1467) | |
| let _1469 := add(0x20, _1468) | |
| mstore(_1468, sub(_1469, _1468)) | |
| mstore(_1469, 0x35) | |
| let _1470 := add(0x20, _1469) | |
| codecopy(_1470, 0x5bc7, 0x35) | |
| let _1471 := mload(0x40) | |
| revert(_1471, sub(add(0x40, _1470), _1471)) | |
| } | |
| } | |
| if not(_1433){ | |
| let _1472 := mload(0x40) | |
| mstore(_1472, 0x8c379a000000000000000000000000000000000000000000000000000000000) | |
| let _1473 := add(0x4, _1472) | |
| let _1474 := add(0x20, _1473) | |
| mstore(_1473, sub(_1474, _1473)) | |
| mstore(_1474, 0x2c) | |
| let _1475 := add(0x20, _1474) | |
| codecopy(_1475, 0x5cd5, 0x2c) | |
| let _1476 := mload(0x40) | |
| revert(_1476, sub(add(0x40, _1475), _1476)) | |
| } | |
| } | |
| function func_VERSION() { | |
| let _1477 := iszero(callvalue()) | |
| require(not(_1477)) | |
| let _1478 := mload(0x40) | |
| mstore(0x40, add(0x40, _1478)) | |
| mstore(_1478, 0x5) | |
| mstore(add(0x20, _1478), 0x312e312e31000000000000000000000000000000000000000000000000000000) | |
| let _1479 := mload(0x40) | |
| let _1480 := add(0x20, _1479) | |
| mstore(_1479, sub(_1480, _1479)) | |
| let _1481 := mload(_1478) | |
| mstore(_1480, _1481) | |
| let _1482 := add(0x20, _1480) | |
| let _1483 := mload(_1478) | |
| let _1484 := 0x0 | |
| let _1485 := 0x0 | |
| for { | |
| let _1486 := lt(_1484, _1483) | |
| let _1487 := 0x20 | |
| let _1488 := add(_1485, _1487) | |
| } | |
| not(iszero(_1486)) | |
| { } | |
| { | |
| _1484 := _1488 | |
| _1486 := lt(_1484, _1483) | |
| let _1489 := not(iszero(_1486)) | |
| _1485 := _1488 | |
| let _1490 := mload(add(add(0x20, _1478), _1485)) | |
| mstore(add(_1482, _1485), _1490) | |
| _1487 := 0x20 | |
| _1488 := add(_1485, _1487) | |
| _1484 := _1488 | |
| _1485 := _1488 | |
| } | |
| let _1491 := add(_1483, _1482) | |
| let _1492 := _1491 | |
| let _1493 := and(0x1f, _1483) | |
| let _1494 := iszero(_1493) | |
| if not(_1494){ | |
| let _1495 := sub(_1491, _1493) | |
| let _1496 := mload(_1495) | |
| mstore(_1495, and(not(sub(exp(0x100, sub(0x20, _1493)), 0x1)), _1496)) | |
| _1492 := add(0x20, _1495) | |
| } | |
| let _1497 := mload(0x40) | |
| return(_1497, sub(_1492, _1497)) | |
| } | |
| function require(condition) { | |
| if iszero(condition){ | |
| revert(0x0, 0x0) | |
| } | |
| } | |
| } | |
| } | |
| } |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment