DECOMPILED SOLIDITY (Heimdall)
VERIFY
// SPDX-License-Identifier: MIT
pragma solidity > = 0.8 . 0 ;
/// @title Decompiled Contract
/// @author Jonathan Becker <jonathan@jbecker.dev>
/// @custom:version heimdall-rs v0.9.2
///
/// @notice This contract was decompiled using the heimdall-rs decompiler.
/// It was generated directly by tracing the EVM opcodes from this contract.
/// As a result, it may not compile or even be valid solidity code.
/// Despite this, it should be obvious what each function does. Overall
/// logic should have been preserved throughout decompiling.
///
/// @custom:github You can find the open-source decompiler here:
/// https://heimdall.rs
contract DecompiledContract {
mapping ( bytes32 = > bytes32 ) storage_map_f;
mapping ( bytes32 = > bytes32 ) storage_map_w;
mapping ( bytes32 = > bytes32 ) storage_map_q;
mapping ( bytes32 = > bytes32 ) storage_map_al;
mapping ( bytes32 = > bytes32 ) storage_map_ak;
mapping ( bytes32 = > bytes32 ) storage_map_af;
mapping ( bytes32 = > bytes32 ) storage_map_ac;
mapping ( bytes32 = > bytes32 ) storage_map_j;
address public _authority;
mapping ( bytes32 = > bytes32 ) storage_map_i;
mapping ( bytes32 = > bytes32 ) storage_map_b;
bytes32 store_c;
bytes32 store_l;
mapping ( bytes32 = > bytes32 ) storage_map_x;
bytes32 store_s;
mapping ( bytes32 = > bytes32 ) storage_map_e;
mapping ( bytes32 = > bytes32 ) storage_map_n;
mapping ( bytes32 = > bytes32 ) storage_map_ae;
mapping ( bytes32 = > bytes32 ) storage_map_o;
bytes32 store_d;
mapping ( bytes32 = > bytes32 ) storage_map_z;
mapping ( bytes32 = > bytes32 ) storage_map_v;
mapping ( bytes32 = > bytes32 ) storage_map_ah;
bytes public getInfo;
mapping ( bytes32 = > bytes32 ) storage_map_ab;
mapping ( bytes32 = > bytes32 ) storage_map_h;
mapping ( bytes32 = > bytes32 ) storage_map_g;
mapping ( bytes32 = > bytes32 ) storage_map_ad;
mapping ( bytes32 = > bytes32 ) storage_map_t;
mapping ( bytes32 = > bytes32 ) storage_map_r;
mapping ( bytes32 = > bytes32 ) storage_map_aa;
mapping ( bytes32 = > bytes32 ) storage_map_ai;
mapping ( bytes32 = > bytes32 ) storage_map_y;
mapping ( bytes32 = > bytes32 ) storage_map_p;
mapping ( bytes32 = > bytes32 ) storage_map_m;
mapping ( bytes32 = > bytes32 ) storage_map_ag;
mapping ( bytes32 = > bytes32 ) storage_map_u;
mapping ( bytes32 = > bytes32 ) storage_map_aj;
event Event_b96a5204( ) ;
event Confirmed( uint256 , address ) ;
event MemberAdded( address ) ;
event Proposed( uint256 , bytes ) ;
event Triggered( uint256 ) ;
/// @custom:selector 0x7e1db2a1
/// @custom:signature Unresolved_7e1db2a1(address arg0, uint256 arg1, uint256 arg2) public payable returns (uint256)
/// @param arg0 ["address", "uint160", "bytes20", "int160"]
/// @param arg1 ["uint256", "bytes32", "int256"]
/// @param arg2 ["uint256", "bytes32", "int256"]
function Unresolved_7e1db2a1( address arg0, uint256 arg1, uint256 arg2) public payable returns ( uint256 ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
address var_b = address ( msg. sender) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: 0 ether } Unresolved_b7009613( var_b) ; // call
if ( ! msg. data. length) {
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( 0x31c2bd0b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0x5a9b0b89 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return abi. encodePacked( getInfo, store_l, store_c, store_d) ;
if ( 0x7e1db2a1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( 0xa230c524 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( arg0) ;
return ! ( ! bytes1 ( storage_map_b[ var_f] / 0x01 ) ) ;
if ( 0xba0179b5 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( msg. sender) ;
if ( storage_map_b[ var_f] / 0x01 ) {
var_f = address ( msg. sender) ;
if ( ! storage_map_b[ var_f] / 0x01 ) {
if ( ! arg0 > store_d) {
var_f = arg0;
if ( ! block. timestamp > ( storage_map_i[ var_f] ) ) {
if ( ! ( storage_map_j[ var_f] ) / 0x01 ) {
var_f = address ( msg. sender) ;
storage_map_b[ var_f] = 0x01 | ( uint248 ( storage_map_b[ var_f] ) ) ;
storage_map_h[ var_f] = ( storage_map_h[ var_f] ) + 0x01 ;
var_f = arg0;
storage_map_e[ var_f] = ( address ( storage_map_m[ var_f] / 0x01 ) * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) {
storage_map_f[ var_f] = 0x01 + ( ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) ) / 0x02 ) {
var_f = keccak256( var_f) + 0x01 ;
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = storage_map_o[ var_f] ;
storage_map_h[ var_f] = storage_map_p[ var_f] ;
storage_map_i[ var_f] = storage_map_q[ var_f] ;
storage_map_j[ var_f] = ( bytes1 ( storage_map_r[ var_f] / 0x01 ) * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
emit Confirmed( arg0, address ( msg. sender) ) ;
return 0 ;
if ( 0xc2205ee1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return address ( _authority / 0x0100 ) ;
if ( 0xc7d6faf1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( msg. sender) ;
var_e = var_e + ( 0x20 + ( ( ( 0x1f + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_b[ var_f] ) ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) * 0x20 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) ) / 0x02 ) {
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) {
var_f = keccak256( var_f) ;
if ( ( 0x20 + var_e) + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) > ( 0x20 + ( 0x20 + var_e) ) ) {
var_e = var_e + 0x20 ;
var_k = 0 ;
var_n = 0 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0xca6d56dc = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
address var_ac = address ( msg. sender) ;
address var_ad = address ( this) ;
uint32 var_ae = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_k ether } canCall( var_ac, var_ad, var_ae) ; // call
if ( ! msg. data. length) {
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( 0x31c2bd0b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0x5a9b0b89 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return abi. encodePacked( getInfo, store_l, store_c, store_d) ;
if ( 0x7e1db2a1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( 0xa230c524 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( arg0) ;
return ! ( ! bytes1 ( storage_map_b[ var_f] / 0x01 ) ) ;
if ( 0xba0179b5 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( msg. sender) ;
if ( storage_map_b[ var_f] / 0x01 ) {
var_f = address ( msg. sender) ;
if ( ! storage_map_b[ var_f] / 0x01 ) {
if ( ! arg0 > store_d) {
var_f = arg0;
if ( ! block. timestamp > ( storage_map_i[ var_f] ) ) {
if ( ! ( storage_map_j[ var_f] ) / 0x01 ) {
var_f = address ( msg. sender) ;
storage_map_b[ var_f] = 0x01 | ( uint248 ( storage_map_b[ var_f] ) ) ;
storage_map_h[ var_f] = ( storage_map_h[ var_f] ) + 0x01 ;
var_f = arg0;
storage_map_e[ var_f] = ( address ( storage_map_m[ var_f] / 0x01 ) * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) {
storage_map_f[ var_f] = 0x01 + ( ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) ) / 0x02 ) {
var_f = keccak256( var_f) + 0x01 ;
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = storage_map_o[ var_f] ;
storage_map_h[ var_f] = storage_map_p[ var_f] ;
storage_map_i[ var_f] = storage_map_q[ var_f] ;
storage_map_j[ var_f] = ( bytes1 ( storage_map_r[ var_f] / 0x01 ) * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
emit Confirmed( arg0, address ( msg. sender) ) ;
return 0 ;
if ( 0xc2205ee1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return address ( _authority / 0x0100 ) ;
if ( 0xc7d6faf1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( msg. sender) ;
var_e = var_e + ( 0x20 + ( ( ( 0x1f + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_b[ var_f] ) ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) * 0x20 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) ) / 0x02 ) {
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) {
var_f = keccak256( var_f) ;
if ( ( 0x20 + var_e) + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) > ( 0x20 + ( 0x20 + var_e) ) ) {
var_e = var_e + 0x20 ;
var_ah = 0 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0xca6d56dc = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
address var_aq = address ( msg. sender) ;
address var_ar = address ( this) ;
uint32 var_as = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_ah ether } canCall( var_aq, var_ar, var_as) ; // call
if ( ! msg. data. length) {
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( 0x31c2bd0b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0x5a9b0b89 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return abi. encodePacked( getInfo, store_l, store_c, store_d) ;
if ( 0x7e1db2a1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( 0xa230c524 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( arg0) ;
return ! ( ! bytes1 ( storage_map_b[ var_f] / 0x01 ) ) ;
if ( 0xba0179b5 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( msg. sender) ;
if ( storage_map_b[ var_f] / 0x01 ) {
var_f = address ( msg. sender) ;
if ( ! storage_map_b[ var_f] / 0x01 ) {
if ( ! arg0 > store_d) {
var_f = arg0;
if ( ! block. timestamp > ( storage_map_i[ var_f] ) ) {
if ( ! ( storage_map_j[ var_f] ) / 0x01 ) {
var_f = address ( msg. sender) ;
storage_map_b[ var_f] = 0x01 | ( uint248 ( storage_map_b[ var_f] ) ) ;
storage_map_h[ var_f] = ( storage_map_h[ var_f] ) + 0x01 ;
var_f = arg0;
storage_map_e[ var_f] = ( address ( storage_map_m[ var_f] / 0x01 ) * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) {
storage_map_f[ var_f] = 0x01 + ( ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) ) / 0x02 ) {
var_f = keccak256( var_f) + 0x01 ;
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = storage_map_o[ var_f] ;
storage_map_h[ var_f] = storage_map_p[ var_f] ;
storage_map_i[ var_f] = storage_map_q[ var_f] ;
storage_map_j[ var_f] = ( bytes1 ( storage_map_r[ var_f] / 0x01 ) * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
emit Confirmed( arg0, address ( msg. sender) ) ;
return 0 ;
if ( 0xc2205ee1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return address ( _authority / 0x0100 ) ;
if ( 0xc7d6faf1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( msg. sender) ;
var_e = var_e + ( 0x20 + ( ( ( 0x1f + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_b[ var_f] ) ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) * 0x20 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) ) / 0x02 ) {
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) {
var_f = keccak256( var_f) ;
if ( ( 0x20 + var_e) + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) > ( 0x20 + ( 0x20 + var_e) ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0xca6d56dc = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
address var_be = address ( msg. sender) ;
address var_bf = address ( this) ;
address var_bg = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_k ether } canCall( var_be, var_bf, var_bg) ; // call
if ( ! msg. data. length) {
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( 0x31c2bd0b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0x5a9b0b89 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return abi. encodePacked( getInfo, store_l, store_c, store_d) ;
if ( 0x7e1db2a1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( 0xa230c524 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( arg0) ;
return ! ( ! bytes1 ( storage_map_b[ var_f] / 0x01 ) ) ;
if ( 0xba0179b5 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( msg. sender) ;
if ( storage_map_b[ var_f] / 0x01 ) {
var_f = address ( msg. sender) ;
if ( ! storage_map_b[ var_f] / 0x01 ) {
if ( ! arg0 > store_d) {
var_f = arg0;
if ( ! block. timestamp > ( storage_map_i[ var_f] ) ) {
if ( ! ( storage_map_j[ var_f] ) / 0x01 ) {
var_f = address ( msg. sender) ;
storage_map_b[ var_f] = 0x01 | ( uint248 ( storage_map_b[ var_f] ) ) ;
storage_map_h[ var_f] = ( storage_map_h[ var_f] ) + 0x01 ;
var_f = arg0;
storage_map_e[ var_f] = ( address ( storage_map_m[ var_f] / 0x01 ) * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) {
storage_map_f[ var_f] = 0x01 + ( ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) ) / 0x02 ) {
var_f = keccak256( var_f) + 0x01 ;
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = storage_map_o[ var_f] ;
storage_map_h[ var_f] = storage_map_p[ var_f] ;
storage_map_i[ var_f] = storage_map_q[ var_f] ;
storage_map_j[ var_f] = ( bytes1 ( storage_map_r[ var_f] / 0x01 ) * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
emit Confirmed( arg0, address ( msg. sender) ) ;
return 0 ;
if ( 0xc2205ee1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return address ( _authority / 0x0100 ) ;
if ( 0xc7d6faf1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( msg. sender) ;
var_e = var_e + ( 0x20 + ( ( ( 0x1f + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_b[ var_f] ) ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) * 0x20 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) ) / 0x02 ) {
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) {
var_f = keccak256( var_f) ;
if ( ( 0x20 + var_e) + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) > ( 0x20 + ( 0x20 + var_e) ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0xca6d56dc = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
address var_bs = address ( msg. sender) ;
address var_bt = address ( this) ;
address var_bu = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_k ether } canCall( var_bs, var_bt, var_bu) ; // call
if ( ! msg. data. length) {
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( 0x31c2bd0b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0x5a9b0b89 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return abi. encodePacked( getInfo, store_l, store_c, store_d) ;
if ( 0x7e1db2a1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( 0xa230c524 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( arg0) ;
return ! ( ! bytes1 ( storage_map_b[ var_f] / 0x01 ) ) ;
if ( 0xba0179b5 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( msg. sender) ;
if ( storage_map_b[ var_f] / 0x01 ) {
var_f = address ( msg. sender) ;
if ( ! storage_map_b[ var_f] / 0x01 ) {
if ( ! arg0 > store_d) {
var_f = arg0;
if ( ! block. timestamp > ( storage_map_i[ var_f] ) ) {
if ( ! ( storage_map_j[ var_f] ) / 0x01 ) {
var_f = address ( msg. sender) ;
storage_map_b[ var_f] = 0x01 | ( uint248 ( storage_map_b[ var_f] ) ) ;
storage_map_h[ var_f] = ( storage_map_h[ var_f] ) + 0x01 ;
var_f = arg0;
storage_map_e[ var_f] = ( address ( storage_map_m[ var_f] / 0x01 ) * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) {
storage_map_f[ var_f] = 0x01 + ( ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) ) / 0x02 ) {
var_f = keccak256( var_f) + 0x01 ;
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = storage_map_o[ var_f] ;
storage_map_h[ var_f] = storage_map_p[ var_f] ;
storage_map_i[ var_f] = storage_map_q[ var_f] ;
storage_map_j[ var_f] = ( bytes1 ( storage_map_r[ var_f] / 0x01 ) * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
emit Confirmed( arg0, address ( msg. sender) ) ;
return 0 ;
if ( 0xc2205ee1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return address ( _authority / 0x0100 ) ;
if ( 0xc7d6faf1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( msg. sender) ;
var_e = var_e + ( 0x20 + ( ( ( 0x1f + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_b[ var_f] ) ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) * 0x20 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) ) / 0x02 ) {
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) {
var_f = keccak256( var_f) ;
if ( ( 0x20 + var_e) + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) > ( 0x20 + ( 0x20 + var_e) ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0xca6d56dc = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
address var_cg = address ( msg. sender) ;
address var_ch = address ( this) ;
address var_ci = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_k ether } canCall( var_cg, var_ch, var_ci) ; // call
if ( ! msg. data. length) {
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( 0x31c2bd0b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0x5a9b0b89 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return abi. encodePacked( getInfo, store_l, store_c, store_d) ;
if ( 0x7e1db2a1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( 0xa230c524 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( arg0) ;
return ! ( ! bytes1 ( storage_map_b[ var_f] / 0x01 ) ) ;
if ( 0xba0179b5 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( msg. sender) ;
if ( storage_map_b[ var_f] / 0x01 ) {
var_f = address ( msg. sender) ;
if ( ! storage_map_b[ var_f] / 0x01 ) {
if ( ! arg0 > store_d) {
var_f = arg0;
if ( ! block. timestamp > ( storage_map_i[ var_f] ) ) {
if ( ! ( storage_map_j[ var_f] ) / 0x01 ) {
var_f = address ( msg. sender) ;
storage_map_b[ var_f] = 0x01 | ( uint248 ( storage_map_b[ var_f] ) ) ;
storage_map_h[ var_f] = ( storage_map_h[ var_f] ) + 0x01 ;
var_f = arg0;
storage_map_e[ var_f] = ( address ( storage_map_m[ var_f] / 0x01 ) * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) {
storage_map_f[ var_f] = 0x01 + ( ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) ) / 0x02 ) {
var_f = keccak256( var_f) + 0x01 ;
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = storage_map_o[ var_f] ;
storage_map_h[ var_f] = storage_map_p[ var_f] ;
storage_map_i[ var_f] = storage_map_q[ var_f] ;
storage_map_j[ var_f] = ( bytes1 ( storage_map_r[ var_f] / 0x01 ) * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
emit Confirmed( arg0, address ( msg. sender) ) ;
return 0 ;
if ( 0xc2205ee1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return address ( _authority / 0x0100 ) ;
if ( 0xc7d6faf1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( msg. sender) ;
var_e = var_e + ( 0x20 + ( ( ( 0x1f + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_b[ var_f] ) ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) * 0x20 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) ) / 0x02 ) {
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) {
var_f = keccak256( var_f) ;
if ( ( 0x20 + var_e) + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) > ( 0x20 + ( 0x20 + var_e) ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0xca6d56dc = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
address var_cu = address ( msg. sender) ;
address var_cv = address ( this) ;
address var_cw = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_k ether } canCall( var_cu, var_cv, var_cw) ; // call
if ( ! msg. data. length) {
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( 0x31c2bd0b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0x5a9b0b89 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return abi. encodePacked( getInfo, store_l, store_c, store_d) ;
if ( 0x7e1db2a1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( 0xa230c524 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( arg0) ;
return ! ( ! bytes1 ( storage_map_b[ var_f] / 0x01 ) ) ;
if ( 0xba0179b5 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( msg. sender) ;
if ( storage_map_b[ var_f] / 0x01 ) {
var_f = address ( msg. sender) ;
if ( ! storage_map_b[ var_f] / 0x01 ) {
if ( ! arg0 > store_d) {
var_f = arg0;
if ( ! block. timestamp > ( storage_map_i[ var_f] ) ) {
if ( ! ( storage_map_j[ var_f] ) / 0x01 ) {
var_f = address ( msg. sender) ;
storage_map_b[ var_f] = 0x01 | ( uint248 ( storage_map_b[ var_f] ) ) ;
storage_map_h[ var_f] = ( storage_map_h[ var_f] ) + 0x01 ;
var_f = arg0;
storage_map_e[ var_f] = ( address ( storage_map_m[ var_f] / 0x01 ) * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) {
storage_map_f[ var_f] = 0x01 + ( ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) ) / 0x02 ) {
var_f = keccak256( var_f) + 0x01 ;
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = storage_map_o[ var_f] ;
storage_map_h[ var_f] = storage_map_p[ var_f] ;
storage_map_i[ var_f] = storage_map_q[ var_f] ;
storage_map_j[ var_f] = ( bytes1 ( storage_map_r[ var_f] / 0x01 ) * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
emit Confirmed( arg0, address ( msg. sender) ) ;
return 0 ;
if ( 0xc2205ee1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return address ( _authority / 0x0100 ) ;
if ( 0xc7d6faf1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( msg. sender) ;
var_e = var_e + ( 0x20 + ( ( ( 0x1f + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_b[ var_f] ) ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) * 0x20 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) ) / 0x02 ) {
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) {
var_f = keccak256( var_f) ;
if ( ( 0x20 + var_e) + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) > ( 0x20 + ( 0x20 + var_e) ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0xca6d56dc = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
uint32 var_di = address ( msg. sender) ;
uint32 var_dj = address ( this) ;
uint32 var_dk = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_n ether } canCall( var_di, var_dj, var_dk) ; // call
if ( ! msg. data. length) {
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( 0x31c2bd0b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0x5a9b0b89 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return abi. encodePacked( getInfo, store_l, store_c, store_d) ;
if ( 0x7e1db2a1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( 0xa230c524 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( arg0) ;
return ! ( ! bytes1 ( storage_map_b[ var_f] / 0x01 ) ) ;
if ( 0xba0179b5 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( msg. sender) ;
if ( storage_map_b[ var_f] / 0x01 ) {
var_f = address ( msg. sender) ;
if ( ! storage_map_b[ var_f] / 0x01 ) {
if ( ! arg0 > store_d) {
var_f = arg0;
if ( ! block. timestamp > ( storage_map_i[ var_f] ) ) {
if ( ! ( storage_map_j[ var_f] ) / 0x01 ) {
var_f = address ( msg. sender) ;
storage_map_b[ var_f] = 0x01 | ( uint248 ( storage_map_b[ var_f] ) ) ;
storage_map_h[ var_f] = ( storage_map_h[ var_f] ) + 0x01 ;
var_f = arg0;
storage_map_e[ var_f] = ( address ( storage_map_m[ var_f] / 0x01 ) * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) {
storage_map_f[ var_f] = 0x01 + ( ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) ) / 0x02 ) {
var_f = keccak256( var_f) + 0x01 ;
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = storage_map_o[ var_f] ;
storage_map_h[ var_f] = storage_map_p[ var_f] ;
storage_map_i[ var_f] = storage_map_q[ var_f] ;
storage_map_j[ var_f] = ( bytes1 ( storage_map_r[ var_f] / 0x01 ) * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
emit Confirmed( arg0, address ( msg. sender) ) ;
return 0 ;
if ( 0xc2205ee1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return address ( _authority / 0x0100 ) ;
if ( 0xc7d6faf1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( msg. sender) ;
var_e = var_e + ( 0x20 + ( ( ( 0x1f + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_b[ var_f] ) ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) * 0x20 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) ) / 0x02 ) {
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) {
var_f = keccak256( var_f) ;
if ( ( 0x20 + var_e) + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) > ( 0x20 + ( 0x20 + var_e) ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0xca6d56dc = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
uint32 var_dw = address ( msg. sender) ;
uint32 var_dx = address ( this) ;
uint32 var_dy = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_n ether } canCall( var_dw, var_dx, var_dy) ; // call
if ( ! msg. data. length) {
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( 0x31c2bd0b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0x5a9b0b89 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return abi. encodePacked( getInfo, store_l, store_c, store_d) ;
if ( 0x7e1db2a1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( 0xa230c524 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( arg0) ;
return ! ( ! bytes1 ( storage_map_b[ var_f] / 0x01 ) ) ;
if ( 0xba0179b5 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( msg. sender) ;
if ( storage_map_b[ var_f] / 0x01 ) {
var_f = address ( msg. sender) ;
if ( ! storage_map_b[ var_f] / 0x01 ) {
if ( ! arg0 > store_d) {
var_f = arg0;
if ( ! block. timestamp > ( storage_map_i[ var_f] ) ) {
if ( ! ( storage_map_j[ var_f] ) / 0x01 ) {
var_f = address ( msg. sender) ;
storage_map_b[ var_f] = 0x01 | ( uint248 ( storage_map_b[ var_f] ) ) ;
storage_map_h[ var_f] = ( storage_map_h[ var_f] ) + 0x01 ;
var_f = arg0;
storage_map_e[ var_f] = ( address ( storage_map_m[ var_f] / 0x01 ) * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) {
storage_map_f[ var_f] = 0x01 + ( ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) ) / 0x02 ) {
var_f = keccak256( var_f) + 0x01 ;
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = storage_map_o[ var_f] ;
storage_map_h[ var_f] = storage_map_p[ var_f] ;
storage_map_i[ var_f] = storage_map_q[ var_f] ;
storage_map_j[ var_f] = ( bytes1 ( storage_map_r[ var_f] / 0x01 ) * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
emit Confirmed( arg0, address ( msg. sender) ) ;
return 0 ;
if ( 0xc2205ee1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return address ( _authority / 0x0100 ) ;
if ( 0xc7d6faf1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( msg. sender) ;
var_e = var_e + ( 0x20 + ( ( ( 0x1f + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_b[ var_f] ) ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) * 0x20 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) ) / 0x02 ) {
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) {
var_f = keccak256( var_f) ;
if ( ( 0x20 + var_e) + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) > ( 0x20 + ( 0x20 + var_e) ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0xca6d56dc = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
uint256 var_ek = address ( msg. sender) ;
uint256 var_el = address ( this) ;
uint256 var_em = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_n ether } canCall( var_ek, var_el, var_em) ; // call
if ( ! msg. data. length) {
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( 0x31c2bd0b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0x5a9b0b89 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return abi. encodePacked( getInfo, store_l, store_c, store_d) ;
if ( 0x7e1db2a1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( 0xa230c524 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( arg0) ;
return ! ( ! bytes1 ( storage_map_b[ var_f] / 0x01 ) ) ;
if ( 0xba0179b5 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( msg. sender) ;
if ( storage_map_b[ var_f] / 0x01 ) {
var_f = address ( msg. sender) ;
if ( ! storage_map_b[ var_f] / 0x01 ) {
if ( ! arg0 > store_d) {
var_f = arg0;
if ( ! block. timestamp > ( storage_map_i[ var_f] ) ) {
if ( ! ( storage_map_j[ var_f] ) / 0x01 ) {
var_f = address ( msg. sender) ;
storage_map_b[ var_f] = 0x01 | ( uint248 ( storage_map_b[ var_f] ) ) ;
storage_map_h[ var_f] = ( storage_map_h[ var_f] ) + 0x01 ;
var_f = arg0;
storage_map_e[ var_f] = ( address ( storage_map_m[ var_f] / 0x01 ) * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) {
storage_map_f[ var_f] = 0x01 + ( ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) ) / 0x02 ) {
var_f = keccak256( var_f) + 0x01 ;
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = storage_map_o[ var_f] ;
storage_map_h[ var_f] = storage_map_p[ var_f] ;
storage_map_i[ var_f] = storage_map_q[ var_f] ;
storage_map_j[ var_f] = ( bytes1 ( storage_map_r[ var_f] / 0x01 ) * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
emit Confirmed( arg0, address ( msg. sender) ) ;
return 0 ;
if ( 0xc2205ee1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return address ( _authority / 0x0100 ) ;
if ( 0xc7d6faf1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( msg. sender) ;
var_e = var_e + ( 0x20 + ( ( ( 0x1f + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_b[ var_f] ) ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) * 0x20 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) ) / 0x02 ) {
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) {
var_f = keccak256( var_f) ;
if ( ( 0x20 + var_e) + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) > ( 0x20 + ( 0x20 + var_e) ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0xca6d56dc = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
uint256 var_ey = address ( msg. sender) ;
uint256 var_ez = address ( this) ;
address var_fa = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_n ether } canCall( var_ey, var_ez, var_fa) ; // call
if ( ! msg. data. length) {
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( 0x31c2bd0b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0x5a9b0b89 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return abi. encodePacked( getInfo, store_l, store_c, store_d) ;
if ( 0x7e1db2a1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( 0xa230c524 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( arg0) ;
return ! ( ! bytes1 ( storage_map_b[ var_f] / 0x01 ) ) ;
if ( 0xba0179b5 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( msg. sender) ;
if ( storage_map_b[ var_f] / 0x01 ) {
var_f = address ( msg. sender) ;
if ( ! storage_map_b[ var_f] / 0x01 ) {
if ( ! arg0 > store_d) {
var_f = arg0;
if ( ! block. timestamp > ( storage_map_i[ var_f] ) ) {
if ( ! ( storage_map_j[ var_f] ) / 0x01 ) {
var_f = address ( msg. sender) ;
storage_map_b[ var_f] = 0x01 | ( uint248 ( storage_map_b[ var_f] ) ) ;
storage_map_h[ var_f] = ( storage_map_h[ var_f] ) + 0x01 ;
var_f = arg0;
storage_map_e[ var_f] = ( address ( storage_map_m[ var_f] / 0x01 ) * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) {
storage_map_f[ var_f] = 0x01 + ( ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) ) / 0x02 ) {
var_f = keccak256( var_f) + 0x01 ;
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = storage_map_o[ var_f] ;
storage_map_h[ var_f] = storage_map_p[ var_f] ;
storage_map_i[ var_f] = storage_map_q[ var_f] ;
storage_map_j[ var_f] = ( bytes1 ( storage_map_r[ var_f] / 0x01 ) * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
emit Confirmed( arg0, address ( msg. sender) ) ;
return 0 ;
if ( 0xc2205ee1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return address ( _authority / 0x0100 ) ;
if ( 0xc7d6faf1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( msg. sender) ;
var_e = var_e + ( 0x20 + ( ( ( 0x1f + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_b[ var_f] ) ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) * 0x20 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) ) / 0x02 ) {
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) {
var_f = keccak256( var_f) ;
if ( ( 0x20 + var_e) + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) > ( 0x20 + ( 0x20 + var_e) ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0xca6d56dc = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
address var_fm = address ( msg. sender) ;
address var_fn = address ( this) ;
address var_fo = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_n ether } canCall( var_fm, var_fn, var_fo) ; // call
if ( ! msg. data. length) {
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( 0x31c2bd0b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0x5a9b0b89 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return abi. encodePacked( getInfo, store_l, store_c, store_d) ;
if ( 0x7e1db2a1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( 0xa230c524 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( arg0) ;
return ! ( ! bytes1 ( storage_map_b[ var_f] / 0x01 ) ) ;
if ( 0xba0179b5 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( msg. sender) ;
if ( storage_map_b[ var_f] / 0x01 ) {
var_f = address ( msg. sender) ;
if ( ! storage_map_b[ var_f] / 0x01 ) {
if ( ! arg0 > store_d) {
var_f = arg0;
if ( ! block. timestamp > ( storage_map_i[ var_f] ) ) {
if ( ! ( storage_map_j[ var_f] ) / 0x01 ) {
var_f = address ( msg. sender) ;
storage_map_b[ var_f] = 0x01 | ( uint248 ( storage_map_b[ var_f] ) ) ;
storage_map_h[ var_f] = ( storage_map_h[ var_f] ) + 0x01 ;
var_f = arg0;
storage_map_e[ var_f] = ( address ( storage_map_m[ var_f] / 0x01 ) * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) {
storage_map_f[ var_f] = 0x01 + ( ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) ) / 0x02 ) {
var_f = keccak256( var_f) + 0x01 ;
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = storage_map_o[ var_f] ;
storage_map_h[ var_f] = storage_map_p[ var_f] ;
storage_map_i[ var_f] = storage_map_q[ var_f] ;
storage_map_j[ var_f] = ( bytes1 ( storage_map_r[ var_f] / 0x01 ) * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
emit Confirmed( arg0, address ( msg. sender) ) ;
return 0 ;
if ( 0xc2205ee1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return address ( _authority / 0x0100 ) ;
if ( 0xc7d6faf1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( msg. sender) ;
var_e = var_e + ( 0x20 + ( ( ( 0x1f + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_b[ var_f] ) ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) * 0x20 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) ) / 0x02 ) {
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) {
var_f = keccak256( var_f) ;
if ( ( 0x20 + var_e) + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) > ( 0x20 + ( 0x20 + var_e) ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0xca6d56dc = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
address var_ga = address ( msg. sender) ;
address var_gb = address ( this) ;
address var_gc = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_n ether } canCall( var_ga, var_gb, var_gc) ; // call
if ( ! msg. data. length) {
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( 0x31c2bd0b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0x5a9b0b89 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return abi. encodePacked( getInfo, store_l, store_c, store_d) ;
if ( 0x7e1db2a1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( 0xa230c524 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( arg0) ;
return ! ( ! bytes1 ( storage_map_b[ var_f] / 0x01 ) ) ;
if ( 0xba0179b5 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( msg. sender) ;
if ( storage_map_b[ var_f] / 0x01 ) {
var_f = address ( msg. sender) ;
if ( ! storage_map_b[ var_f] / 0x01 ) {
if ( ! arg0 > store_d) {
var_f = arg0;
if ( ! block. timestamp > ( storage_map_i[ var_f] ) ) {
if ( ! ( storage_map_j[ var_f] ) / 0x01 ) {
var_f = address ( msg. sender) ;
storage_map_b[ var_f] = 0x01 | ( uint248 ( storage_map_b[ var_f] ) ) ;
storage_map_h[ var_f] = ( storage_map_h[ var_f] ) + 0x01 ;
var_f = arg0;
storage_map_e[ var_f] = ( address ( storage_map_m[ var_f] / 0x01 ) * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) {
storage_map_f[ var_f] = 0x01 + ( ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) ) / 0x02 ) {
var_f = keccak256( var_f) + 0x01 ;
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = storage_map_o[ var_f] ;
storage_map_h[ var_f] = storage_map_p[ var_f] ;
storage_map_i[ var_f] = storage_map_q[ var_f] ;
storage_map_j[ var_f] = ( bytes1 ( storage_map_r[ var_f] / 0x01 ) * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
emit Confirmed( arg0, address ( msg. sender) ) ;
return 0 ;
if ( 0xc2205ee1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return address ( _authority / 0x0100 ) ;
if ( 0xc7d6faf1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( msg. sender) ;
var_e = var_e + ( 0x20 + ( ( ( 0x1f + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_b[ var_f] ) ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) * 0x20 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) ) / 0x02 ) {
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) {
var_f = keccak256( var_f) ;
if ( ( 0x20 + var_e) + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) > ( 0x20 + ( 0x20 + var_e) ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0xca6d56dc = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
address var_go = address ( msg. sender) ;
address var_gp = address ( this) ;
address var_gq = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_n ether } canCall( var_go, var_gp, var_gq) ; // call
if ( ! msg. data. length) {
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( 0x31c2bd0b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0x5a9b0b89 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return abi. encodePacked( getInfo, store_l, store_c, store_d) ;
if ( 0x7e1db2a1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( 0xa230c524 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( arg0) ;
return ! ( ! bytes1 ( storage_map_b[ var_f] / 0x01 ) ) ;
if ( 0xba0179b5 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( 0xc2205ee1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return address ( _authority / 0x0100 ) ;
if ( 0xc7d6faf1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( 0xca6d56dc = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
uint256 var_hc = address ( msg. sender) ;
uint256 var_hd = address ( this) ;
uint256 var_he = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_n ether } canCall( var_hc, var_hd, var_he) ; // call
var_e = 0x20 + ( 0x20 + ( 0x20 + ( 0x04 + var_e) ) ) ;
if ( ! msg. data. length) {
}
if ( ! var_e. length) {
var_f = address ( arg0) ;
if ( ! storage_map_b[ var_f] / 0x01 ) {
var_f = address ( arg0) ;
storage_map_b[ var_f] = 0x01 | ( uint248 ( storage_map_b[ var_f] ) ) ;
emit MemberAdded( address ( arg0) ) ;
store_s = store_s - 0x01 ;
if ( ! store_s = = 0 ) {
if ( 0xd551f601 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return bytes1 ( _authority / 0x01 ) ;
if ( 0xed684cc6 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = arg0;
if ( ! ( storage_map_h[ var_f] ) < getInfo) {
if ( ! block. timestamp > ( storage_map_i[ var_f] ) ) {
if ( ! ( storage_map_j[ var_f] ) / 0x01 ) {
if ( ! ( address ( this) . balance) < ( storage_map_g[ var_f] ) ) {
storage_map_j[ var_f] = 0x01 | ( uint248 ( storage_map_j[ var_f] ) ) ;
var_e = var_e + ( 0x20 + ( ( ( 0x1f + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_f[ var_f] ) ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) * 0x20 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) ) / 0x02 ) {
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) {
var_f = 0x01 + keccak256( var_f) ;
if ( ( 0x20 + var_e) + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) > ( 0x20 + ( 0x20 + var_e) ) ) {
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
( bool success, bytes memory ret0) = address ( storage_map_e[ var_f] / 0x01 ) . { gas: gasleft( ) - 0x8502 , value: storage_map_g[ var_f] } adfepixw( ) ; // call
var_f = arg0;
storage_map_e[ var_f] = ( address ( storage_map_m[ var_f] / 0x01 ) * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) {
storage_map_f[ var_f] = 0x01 + ( ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) ) / 0x02 ) {
var_f = keccak256( var_f) + 0x01 ;
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = storage_map_o[ var_f] ;
storage_map_h[ var_f] = storage_map_p[ var_f] ;
storage_map_i[ var_f] = storage_map_q[ var_f] ;
storage_map_j[ var_f] = ( bytes1 ( storage_map_r[ var_f] / 0x01 ) * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
emit Triggered( arg0) ;
if ( 0xf6d5959b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = arg0;
return abi. encodePacked( storage_map_h[ var_f] , storage_map_i[ var_f] , ! ( ! bytes1 ( storage_map_j[ var_f] / 0x01 ) ) , address ( storage_map_e[ var_f] / 0x01 ) , storage_map_g[ var_f] ) ;
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
var_hc = address ( msg. sender) ;
var_hd = address ( this) ;
var_he = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_n ether } canCall( var_hc, var_hd, var_he) ; // call
var_e = 0x20 + ( 0x20 + ( 0x20 + ( 0x04 + var_e) ) ) ;
if ( ! msg. data. length) {
}
if ( ! var_e. length) {
_authority = ( arg0 * 0x0100 ) | ( uint96 ( _authority) ) ;
_authority = ( arg1 * 0x01 ) | ( uint248 ( _authority) ) ;
emit Event_b96a5204( address ( arg0) , arg1) ;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
/// @custom:selector 0xed684cc6
/// @custom:signature trigger(uint256 arg0) public payable
/// @param arg0 ["uint256", "bytes32", "int256"]
function trigger( uint256 arg0) public payable {
uint256 var_a = arg0;
if ( ! ( storage_map_t[ var_a] ) < getInfo) {
if ( ! block. timestamp > ( storage_map_u[ var_a] ) ) {
if ( ! ( storage_map_v[ var_a] ) / 0x01 ) {
if ( ! ( address ( this) . balance) < ( storage_map_w[ var_a] ) ) {
storage_map_v[ var_a] = 0x01 | ( uint248 ( storage_map_v[ var_a] ) ) ;
uint256 var_c = var_c + ( 0x20 + ( ( ( 0x1f + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_x[ var_a] ) ) ) - 0x01 ) & ( storage_map_x[ var_a] ) / 0x02 ) ) / 0x20 ) * 0x20 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_x[ var_a] ) ) - 0x01 ) & ( storage_map_x[ var_a] ) ) / 0x02 ) {
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_x[ var_a] ) ) - 0x01 ) & ( storage_map_x[ var_a] ) / 0x02 ) ) {
var_a = 0x01 + keccak256( var_a) ;
if ( ( 0x20 + var_c) + ( ( ( 0x0100 * ( ! storage_map_x[ var_a] ) ) - 0x01 ) & ( storage_map_x[ var_a] ) / 0x02 ) > ( 0x20 + ( 0x20 + var_c) ) ) {
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_c. length) {
( bool success, bytes memory ret0) = address ( storage_map_z[ var_a] / 0x01 ) . { gas: gasleft( ) - 0x8502 , value: storage_map_w[ var_a] } adfepixw( ) ; // call
var_a = arg0;
storage_map_z[ var_a] = ( address ( storage_map_aa[ var_a] / 0x01 ) * 0x01 ) | ( uint96 ( storage_map_z[ var_a] ) ) ;
var_a = 0x01 + keccak256( var_a) ;
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_ab[ var_a] ) ) - 0x01 ) & ( storage_map_ab[ var_a] ) / 0x02 ) ) {
storage_map_x[ var_a] = 0x01 + ( ( ( ( 0x0100 * ( ! bytes1 ( storage_map_ab[ var_a] ) ) ) - 0x01 ) & ( storage_map_ab[ var_a] ) / 0x02 ) + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_ab[ var_a] ) ) ) - 0x01 ) & ( storage_map_ab[ var_a] ) / 0x02 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_ab[ var_a] ) ) - 0x01 ) & ( storage_map_ab[ var_a] ) ) / 0x02 ) {
var_a = keccak256( var_a) + 0x01 ;
if ( ! ( keccak256( var_a) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_ab[ var_a] ) ) - 0x01 ) & ( storage_map_ab[ var_a] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_a) ) {
if ( ! ( keccak256( var_a) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_x[ var_a] ) ) - 0x01 ) & ( storage_map_x[ var_a] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_a) ) {
storage_map_w[ var_a] = storage_map_ac[ var_a] ;
storage_map_t[ var_a] = storage_map_ad[ var_a] ;
storage_map_u[ var_a] = storage_map_ae[ var_a] ;
storage_map_v[ var_a] = ( bytes1 ( storage_map_af[ var_a] / 0x01 ) * 0x01 ) | ( uint248 ( storage_map_v[ var_a] ) ) ;
emit Triggered( arg0) ;
}
}
}
}
}
}
}
}
}
}
}
}
}
/// @custom:selector 0xc7d6faf1
/// @custom:signature easyPropose(address arg0, uint256 arg1) public payable returns (uint256)
/// @param arg0 ["address", "uint160", "bytes20", "int160"]
/// @param arg1 ["uint256", "bytes32", "int256"]
function easyPropose( address arg0, uint256 arg1) public payable returns ( uint256 ) {
address var_a = address ( msg. sender) ;
address var_c = var_c + ( 0x20 + ( ( ( 0x1f + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_y[ var_a] ) ) ) - 0x01 ) & ( storage_map_y[ var_a] ) / 0x02 ) ) / 0x20 ) * 0x20 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_y[ var_a] ) ) - 0x01 ) & ( storage_map_y[ var_a] ) ) / 0x02 ) {
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_y[ var_a] ) ) - 0x01 ) & ( storage_map_y[ var_a] ) / 0x02 ) ) {
var_a = keccak256( var_a) ;
if ( ( 0x20 + var_c) + ( ( ( 0x0100 * ( ! storage_map_y[ var_a] ) ) - 0x01 ) & ( storage_map_y[ var_a] ) / 0x02 ) > ( 0x20 + ( 0x20 + var_c) ) ) {
var_c = var_c + 0x20 ;
store_d = 0x01 + store_d;
var_a = store_d;
storage_map_z[ var_a] = ( var_l * 0x01 ) | ( uint96 ( storage_map_z[ var_a] ) ) ;
var_a = 0x01 + keccak256( var_a) ;
if ( 0x1f < ( var_m) ) {
storage_map_x[ var_a] = 0x01 + ( var_m + ( var_m) ) ;
if ( ! var_m) {
if ( ! ( ( 0x20 + ( var_n) ) + ( var_o) ) > ( 0x20 + ( var_n) ) ) {
if ( ! ( keccak256( var_a) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_x[ var_a] ) ) - 0x01 ) & ( storage_map_x[ var_a] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_a) ) {
storage_map_w[ var_a] = var_p;
storage_map_t[ var_a] = var_q;
storage_map_u[ var_a] = var_r;
storage_map_v[ var_a] = ( var_s * 0x01 ) | ( uint248 ( storage_map_v[ var_a] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_c. length) {
emit Proposed( store_d, ( 0x20 + var_c) - var_c, var_c. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_c. length) ) ) ) - 0x01 ) ) & ( var_w) ) ;
return store_d;
emit Proposed( store_d, store_d, var_c. length) ;
return store_d;
}
}
}
}
}
}
}
}
}
/// @custom:selector 0x31c2bd0b
/// @custom:signature Unresolved_31c2bd0b(address arg0, uint256 arg1, uint256 arg2) public payable returns (uint256)
/// @param arg0 ["address", "uint160", "bytes20", "int160"]
/// @param arg1 ["uint256", "bytes32", "int256"]
/// @param arg2 ["uint256", "bytes32", "int256"]
function Unresolved_31c2bd0b( address arg0, uint256 arg1, uint256 arg2) public payable returns ( uint256 ) {
var_a = var_a + 0x20 ;
store_d = 0x01 + store_d;
var_k = store_d;
storage_map_ag[ var_k] = ( var_m * 0x01 ) | ( uint96 ( storage_map_ag[ var_k] ) ) ;
uint256 var_k = 0x01 + keccak256( var_k) ;
if ( 0x1f < ( var_n) ) {
storage_map_ah[ var_k] = 0x01 + ( var_n + ( var_n) ) ;
if ( ! var_n) {
if ( ! ( ( 0x20 + ( var_o) ) + ( var_p) ) > ( 0x20 + ( var_o) ) ) {
if ( ! ( keccak256( var_k) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_ah[ var_k] ) ) - 0x01 ) & ( storage_map_ah[ var_k] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_k) ) {
storage_map_ai[ var_k] = var_q;
storage_map_aj[ var_k] = var_r;
storage_map_ak[ var_k] = var_s;
storage_map_al[ var_k] = ( var_t * 0x01 ) | ( uint248 ( storage_map_al[ var_k] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_a. length) {
emit Proposed( store_d, ( 0x20 + var_a) - var_a, var_a. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_a. length) ) ) ) - 0x01 ) ) & ( var_x) ) ;
return store_d;
emit Proposed( store_d, store_d, var_a. length) ;
return store_d;
}
}
}
}
}
}
/// @custom:selector 0xa230c524
/// @custom:signature isMember(address arg0) public view returns (bool)
/// @param arg0 ["address", "uint160", "bytes20", "int160"]
function isMember( address arg0) public view returns ( bool ) {
address var_a = address ( arg0) ;
return ! ( ! bytes1 ( storage_map_y[ var_a] / 0x01 ) ) ;
}
/// @custom:selector 0xca6d56dc
/// @custom:signature Unresolved_ca6d56dc(address arg0, uint256 arg1, uint256 arg2) public payable returns (uint256)
/// @param arg0 ["address", "uint160", "bytes20", "int160"]
/// @param arg1 ["uint256", "bytes32", "int256"]
/// @param arg2 ["uint256", "bytes32", "int256"]
function Unresolved_ca6d56dc( address arg0, uint256 arg1, uint256 arg2) public payable returns ( uint256 ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
address var_b = address ( msg. sender) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: 0 ether } Unresolved_b7009613( var_b) ; // call
if ( ! msg. data. length) {
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( 0x31c2bd0b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_e = var_e + 0x20 ;
uint256 var_k = 0 ;
uint256 var_n = 0 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0x5a9b0b89 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return abi. encodePacked( getInfo, store_l, store_c, store_d) ;
if ( 0x7e1db2a1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
address var_ac = address ( msg. sender) ;
address var_ad = address ( this) ;
uint32 var_ae = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_k ether } canCall( var_ac, var_ad, var_ae) ; // call
if ( ! msg. data. length) {
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( 0x31c2bd0b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_e = var_e + 0x20 ;
uint256 var_ah = 0 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0x5a9b0b89 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return abi. encodePacked( getInfo, store_l, store_c, store_d) ;
if ( 0x7e1db2a1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
address var_aq = address ( msg. sender) ;
address var_ar = address ( this) ;
uint32 var_as = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_ah ether } canCall( var_aq, var_ar, var_as) ; // call
if ( ! msg. data. length) {
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( 0x31c2bd0b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0x5a9b0b89 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return abi. encodePacked( getInfo, store_l, store_c, store_d) ;
if ( 0x7e1db2a1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
address var_be = address ( msg. sender) ;
address var_bf = address ( this) ;
address var_bg = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_k ether } canCall( var_be, var_bf, var_bg) ; // call
if ( ! msg. data. length) {
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( 0x31c2bd0b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0x5a9b0b89 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return abi. encodePacked( getInfo, store_l, store_c, store_d) ;
if ( 0x7e1db2a1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
address var_bs = address ( msg. sender) ;
address var_bt = address ( this) ;
address var_bu = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_k ether } canCall( var_bs, var_bt, var_bu) ; // call
if ( ! msg. data. length) {
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( 0x31c2bd0b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0x5a9b0b89 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return abi. encodePacked( getInfo, store_l, store_c, store_d) ;
if ( 0x7e1db2a1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
address var_cg = address ( msg. sender) ;
address var_ch = address ( this) ;
address var_ci = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_k ether } canCall( var_cg, var_ch, var_ci) ; // call
if ( ! msg. data. length) {
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( 0x31c2bd0b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0x5a9b0b89 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return abi. encodePacked( getInfo, store_l, store_c, store_d) ;
if ( 0x7e1db2a1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
address var_cu = address ( msg. sender) ;
address var_cv = address ( this) ;
address var_cw = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_k ether } canCall( var_cu, var_cv, var_cw) ; // call
if ( ! msg. data. length) {
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( 0x31c2bd0b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0x5a9b0b89 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return abi. encodePacked( getInfo, store_l, store_c, store_d) ;
if ( 0x7e1db2a1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
uint32 var_di = address ( msg. sender) ;
uint32 var_dj = address ( this) ;
uint32 var_dk = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_n ether } canCall( var_di, var_dj, var_dk) ; // call
if ( ! msg. data. length) {
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( 0x31c2bd0b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0x5a9b0b89 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return abi. encodePacked( getInfo, store_l, store_c, store_d) ;
if ( 0x7e1db2a1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
uint32 var_dw = address ( msg. sender) ;
uint32 var_dx = address ( this) ;
uint32 var_dy = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_n ether } canCall( var_dw, var_dx, var_dy) ; // call
if ( ! msg. data. length) {
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( 0x31c2bd0b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0x5a9b0b89 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return abi. encodePacked( getInfo, store_l, store_c, store_d) ;
if ( 0x7e1db2a1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
uint256 var_ek = address ( msg. sender) ;
uint256 var_el = address ( this) ;
uint256 var_em = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_n ether } canCall( var_ek, var_el, var_em) ; // call
if ( ! msg. data. length) {
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( 0x31c2bd0b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0x5a9b0b89 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return abi. encodePacked( getInfo, store_l, store_c, store_d) ;
if ( 0x7e1db2a1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
uint256 var_ey = address ( msg. sender) ;
uint256 var_ez = address ( this) ;
address var_fa = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_n ether } canCall( var_ey, var_ez, var_fa) ; // call
if ( ! msg. data. length) {
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( 0x31c2bd0b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0x5a9b0b89 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return abi. encodePacked( getInfo, store_l, store_c, store_d) ;
if ( 0x7e1db2a1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
address var_fm = address ( msg. sender) ;
address var_fn = address ( this) ;
address var_fo = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_n ether } canCall( var_fm, var_fn, var_fo) ; // call
if ( ! msg. data. length) {
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( 0x31c2bd0b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0x5a9b0b89 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return abi. encodePacked( getInfo, store_l, store_c, store_d) ;
if ( 0x7e1db2a1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
address var_ga = address ( msg. sender) ;
address var_gb = address ( this) ;
uint32 var_gc = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_n ether } canCall( var_ga, var_gb, var_gc) ; // call
if ( ! msg. data. length) {
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( 0x31c2bd0b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0x5a9b0b89 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return abi. encodePacked( getInfo, store_l, store_c, store_d) ;
if ( 0x7e1db2a1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
address var_go = address ( msg. sender) ;
address var_gp = address ( this) ;
uint32 var_gq = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_n ether } canCall( var_go, var_gp, var_gq) ; // call
if ( ! msg. data. length) {
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( 0x31c2bd0b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_e = var_e + 0x20 ;
store_d = 0x01 + store_d;
var_f = store_d;
storage_map_e[ var_f] = ( var_q * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( var_r) ) {
storage_map_f[ var_f] = 0x01 + ( var_r + ( var_r) ) ;
if ( ! var_r) {
if ( ! ( ( 0x20 + ( var_s) ) + ( var_t) ) > ( 0x20 + ( var_s) ) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = var_u;
storage_map_h[ var_f] = var_v;
storage_map_i[ var_f] = var_w;
storage_map_j[ var_f] = ( var_x * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
emit Proposed( store_d, ( 0x20 + var_e) - var_e, var_e. length, ( ~ ( ( 0x0100 * * ( 0x20 - ( bytes1 ( var_e. length) ) ) ) - 0x01 ) ) & ( var_ab) ) ;
return store_d;
emit Proposed( store_d, store_d, var_e. length) ;
return store_d;
if ( 0x5a9b0b89 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return abi. encodePacked( getInfo, store_l, store_c, store_d) ;
if ( 0x7e1db2a1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( ! ( _authority / 0x01 ) = = 0 ) {
if ( ! ( _authority / 0x01 ) = = 0x01 ) {
uint256 var_hc = address ( msg. sender) ;
uint256 var_hd = address ( this) ;
uint256 var_he = uint32 ( msg. data[ 0 ] ) ;
( bool success, bytes memory ret0) = address ( _authority / 0x0100 ) . { gas: gasleft( ) - 0x61da , value: var_n ether } canCall( var_hc, var_hd, var_he) ; // call
var_e = 0x20 + ( 0x20 + ( 0x20 + ( 0x04 + var_e) ) ) ;
if ( ! msg. data. length) {
}
if ( ! var_e. length) {
_authority = ( arg0 * 0x0100 ) | ( uint96 ( _authority) ) ;
_authority = ( arg1 * 0x01 ) | ( uint248 ( _authority) ) ;
emit Event_b96a5204( address ( arg0) , arg1) ;
if ( 0xa230c524 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = address ( arg0) ;
return ! ( ! bytes1 ( storage_map_b[ var_f] / 0x01 ) ) ;
if ( 0xba0179b5 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( 0xc2205ee1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return address ( _authority / 0x0100 ) ;
if ( 0xc7d6faf1 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( 0xca6d56dc = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
if ( 0xd551f601 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
return bytes1 ( _authority / 0x01 ) ;
if ( 0xed684cc6 = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = arg0;
if ( ! ( storage_map_h[ var_f] ) < getInfo) {
if ( ! block. timestamp > ( storage_map_i[ var_f] ) ) {
if ( ! ( storage_map_j[ var_f] ) / 0x01 ) {
if ( ! ( address ( this) . balance) < ( storage_map_g[ var_f] ) ) {
storage_map_j[ var_f] = 0x01 | ( uint248 ( storage_map_j[ var_f] ) ) ;
var_e = var_e + ( 0x20 + ( ( ( 0x1f + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_f[ var_f] ) ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) * 0x20 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) ) / 0x02 ) {
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) {
var_f = 0x01 + keccak256( var_f) ;
if ( ( 0x20 + var_e) + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) > ( 0x20 + ( 0x20 + var_e) ) ) {
( bool success, bytes memory ret0) = address ( 0x04 ) . transfer( 0 ) ;
if ( ! var_e. length) {
( bool success, bytes memory ret0) = address ( storage_map_e[ var_f] / 0x01 ) . { gas: gasleft( ) - 0x8502 , value: storage_map_g[ var_f] } adfepixw( ) ; // call
var_f = arg0;
storage_map_e[ var_f] = ( address ( storage_map_m[ var_f] / 0x01 ) * 0x01 ) | ( uint96 ( storage_map_e[ var_f] ) ) ;
var_f = 0x01 + keccak256( var_f) ;
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) {
storage_map_f[ var_f] = 0x01 + ( ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_n[ var_f] ) ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) ) / 0x02 ) {
var_f = keccak256( var_f) + 0x01 ;
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_n[ var_f] ) ) - 0x01 ) & ( storage_map_n[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_f[ var_f] ) ) - 0x01 ) & ( storage_map_f[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
storage_map_g[ var_f] = storage_map_o[ var_f] ;
storage_map_h[ var_f] = storage_map_p[ var_f] ;
storage_map_i[ var_f] = storage_map_q[ var_f] ;
storage_map_j[ var_f] = ( bytes1 ( storage_map_r[ var_f] / 0x01 ) * 0x01 ) | ( uint248 ( storage_map_j[ var_f] ) ) ;
emit Triggered( arg0) ;
if ( 0xf6d5959b = = ( msg. data[ 0 ] / 0x0100000000000000000000000000000000000000000000000000000000 ) ) {
var_f = arg0;
return abi. encodePacked( storage_map_h[ var_f] , storage_map_i[ var_f] , ! ( ! bytes1 ( storage_map_j[ var_f] / 0x01 ) ) , address ( storage_map_e[ var_f] / 0x01 ) , storage_map_g[ var_f] ) ;
var_f = keccak256( var_f) ;
if ( 0x1f < msg. data. length) {
storage_map_b[ var_f] = 0x01 + ( msg. data. length + msg. data. length) ;
if ( ! msg. data. length) {
if ( ! ( keccak256( var_f) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_b[ var_f] ) ) - 0x01 ) & ( storage_map_b[ var_f] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_f) ) {
if ( ! ( 0 + msg. data. length) > 0 ) {
storage_map_b[ var_f] = msg. data[ 0 ] ;
if ( ! ( 0 + msg. data. length) > 0x20 ) {
}
if ( ! var_e. length) {
var_f = address ( arg0) ;
if ( ! storage_map_b[ var_f] / 0x01 ) {
var_f = address ( arg0) ;
storage_map_b[ var_f] = 0x01 | ( uint248 ( storage_map_b[ var_f] ) ) ;
emit MemberAdded( address ( arg0) ) ;
store_s = store_s - 0x01 ;
if ( ! store_s = = 0 ) {
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
/// @custom:selector 0xf6d5959b
/// @custom:signature getActionStatus(uint256 arg0) public view returns (bool)
/// @param arg0 ["uint256", "bytes32", "int256"]
function getActionStatus( uint256 arg0) public view returns ( bool ) {
uint256 var_a = arg0;
return abi. encodePacked( storage_map_t[ var_a] , storage_map_u[ var_a] , ! ( ! bytes1 ( storage_map_v[ var_a] / 0x01 ) ) , address ( storage_map_z[ var_a] / 0x01 ) , storage_map_w[ var_a] ) ;
}
/// @custom:selector 0xba0179b5
/// @custom:signature confirm(uint256 arg0) public payable returns (bool)
/// @param arg0 ["uint256", "bytes32", "int256"]
function confirm( uint256 arg0) public payable returns ( bool ) {
address var_a = address ( msg. sender) ;
if ( storage_map_y[ var_a] / 0x01 ) {
var_a = address ( msg. sender) ;
if ( ! storage_map_y[ var_a] / 0x01 ) {
if ( ! arg0 > store_d) {
var_a = arg0;
if ( ! block. timestamp > ( storage_map_u[ var_a] ) ) {
if ( ! ( storage_map_v[ var_a] ) / 0x01 ) {
var_a = address ( msg. sender) ;
storage_map_y[ var_a] = 0x01 | ( uint248 ( storage_map_y[ var_a] ) ) ;
storage_map_t[ var_a] = ( storage_map_t[ var_a] ) + 0x01 ;
var_a = arg0;
storage_map_z[ var_a] = ( address ( storage_map_aa[ var_a] / 0x01 ) * 0x01 ) | ( uint96 ( storage_map_z[ var_a] ) ) ;
var_a = 0x01 + keccak256( var_a) ;
if ( 0x1f < ( ( ( 0x0100 * ( ! storage_map_ab[ var_a] ) ) - 0x01 ) & ( storage_map_ab[ var_a] ) / 0x02 ) ) {
storage_map_x[ var_a] = 0x01 + ( ( ( ( 0x0100 * ( ! bytes1 ( storage_map_ab[ var_a] ) ) ) - 0x01 ) & ( storage_map_ab[ var_a] ) / 0x02 ) + ( ( ( 0x0100 * ( ! bytes1 ( storage_map_ab[ var_a] ) ) ) - 0x01 ) & ( storage_map_ab[ var_a] ) / 0x02 ) ) ;
if ( ! ( ( ( 0x0100 * ( ! storage_map_ab[ var_a] ) ) - 0x01 ) & ( storage_map_ab[ var_a] ) ) / 0x02 ) {
var_a = keccak256( var_a) + 0x01 ;
if ( ! ( keccak256( var_a) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_ab[ var_a] ) ) - 0x01 ) & ( storage_map_ab[ var_a] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_a) ) {
if ( ! ( keccak256( var_a) + ( ( 0x1f + ( ( ( 0x0100 * ( ! storage_map_x[ var_a] ) ) - 0x01 ) & ( storage_map_x[ var_a] ) / 0x02 ) ) / 0x20 ) ) > keccak256( var_a) ) {
storage_map_w[ var_a] = storage_map_ac[ var_a] ;
storage_map_t[ var_a] = storage_map_ad[ var_a] ;
storage_map_u[ var_a] = storage_map_ae[ var_a] ;
storage_map_v[ var_a] = ( bytes1 ( storage_map_af[ var_a] / 0x01 ) * 0x01 ) | ( uint248 ( storage_map_v[ var_a] ) ) ;
emit Confirmed( arg0, address ( msg. sender) ) ;
return 0 ;
}
}
}
}
}
}
}
}
}
}
}
ABI
[
{
"type": "function",
"name": "Unresolved_31c2bd0b",
"inputs": [
{
"name": "arg0",
"type": "address"
},
{
"name": "arg1",
"type": "uint256"
},
{
"name": "arg2",
"type": "uint256"
}
],
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"stateMutability": "payable"
},
{
"type": "function",
"name": "Unresolved_7e1db2a1",
"inputs": [
{
"name": "arg0",
"type": "address"
},
{
"name": "arg1",
"type": "uint256"
},
{
"name": "arg2",
"type": "uint256"
}
],
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"stateMutability": "payable"
},
{
"type": "function",
"name": "Unresolved_ca6d56dc",
"inputs": [
{
"name": "arg0",
"type": "address"
},
{
"name": "arg1",
"type": "uint256"
},
{
"name": "arg2",
"type": "uint256"
}
],
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"stateMutability": "payable"
},
{
"type": "function",
"name": "_auth_mode",
"inputs": [],
"outputs": [
{
"name": "",
"type": "bool"
}
],
"stateMutability": "view"
},
{
"type": "function",
"name": "_authority",
"inputs": [],
"outputs": [
{
"name": "",
"type": "address"
}
],
"stateMutability": "view"
},
{
"type": "function",
"name": "confirm",
"inputs": [
{
"name": "arg0",
"type": "uint256"
}
],
"outputs": [
{
"name": "",
"type": "bool"
}
],
"stateMutability": "payable"
},
{
"type": "function",
"name": "easyPropose",
"inputs": [
{
"name": "arg0",
"type": "address"
},
{
"name": "arg1",
"type": "uint256"
}
],
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"stateMutability": "payable"
},
{
"type": "function",
"name": "getActionStatus",
"inputs": [
{
"name": "arg0",
"type": "uint256"
}
],
"outputs": [
{
"name": "",
"type": "bool"
}
],
"stateMutability": "view"
},
{
"type": "function",
"name": "getInfo",
"inputs": [],
"outputs": [
{
"name": "",
"type": "bytes"
}
],
"stateMutability": "view"
},
{
"type": "function",
"name": "isMember",
"inputs": [
{
"name": "arg0",
"type": "address"
}
],
"outputs": [
{
"name": "",
"type": "bool"
}
],
"stateMutability": "view"
},
{
"type": "function",
"name": "trigger",
"inputs": [
{
"name": "arg0",
"type": "uint256"
}
],
"outputs": [],
"stateMutability": "payable"
},
{
"type": "event",
"name": "Confirmed",
"inputs": [
{
"name": "arg0",
"type": "uint256",
"indexed": false
},
{
"name": "arg1",
"type": "address",
"indexed": false
}
],
"anonymous": false
},
{
"type": "event",
"name": "Event_b96a5204da93e5d7ddd5b0c2616fd5f76322b9c383c5010b94fdc3df11b7be52",
"inputs": [],
"anonymous": false
},
{
"type": "event",
"name": "MemberAdded",
"inputs": [
{
"name": "arg0",
"type": "address",
"indexed": false
}
],
"anonymous": false
},
{
"type": "event",
"name": "Proposed",
"inputs": [
{
"name": "arg0",
"type": "uint256",
"indexed": false
},
{
"name": "arg1",
"type": "bytes",
"indexed": false
}
],
"anonymous": false
},
{
"type": "event",
"name": "Triggered",
"inputs": [
{
"name": "arg0",
"type": "uint256",
"indexed": false
}
],
"anonymous": false
}
]
