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 {
uint256 public constant token = 748247308373868745455821895259004260061793951259 ;
uint256 public constant lp = 362289216806686193953545679814728331551329098647 ;
uint256 public constant nft = 387070716848421123292522524676095356053026830797 ;
mapping ( bytes32 = > bytes32 ) storage_map_ax;
mapping ( bytes32 = > bytes32 ) storage_map_f;
mapping ( bytes32 = > bytes32 ) storage_map_w;
mapping ( bytes32 = > bytes32 ) storage_map_ay;
mapping ( bytes32 = > bytes32 ) storage_map_ao;
uint256 public totalEthDistributed;
mapping ( bytes32 = > bytes32 ) storage_map_am;
mapping ( bytes32 = > bytes32 ) storage_map_ak;
uint256 storage_map_as[ storage_map_c[ var_e] * 0x09 ] ;
mapping ( bytes32 = > bytes32 ) storage_map_af;
uint256 storage_map_bg[ ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ) + keccak256( var_e) ] ;
mapping ( bytes32 = > bytes32 ) storage_map_ac;
uint256 storage_map_bh[ ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ) + keccak256( var_e) ] ;
mapping ( bytes32 = > bytes32 ) storage_map_bh;
mapping ( bytes32 = > bytes32 ) storage_map_ar;
uint256 storage_map_av[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ;
mapping ( bytes32 = > bytes32 ) storage_map_i;
uint256 storage_map_e[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ;
uint256 storage_map_br[ ( 0x09 * ( ( storage_map_bp[ var_x] + 0x01 ) - 0x01 ) ) + keccak256( var_x) ] ;
uint256 public BID_FEE_P;
mapping ( bytes32 = > bytes32 ) storage_map_bq;
uint256 public accETHperGFARM;
uint256 storage_map_n[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ;
mapping ( bytes32 = > bytes32 ) storage_map_bm;
mapping ( bytes32 = > bytes32 ) storage_map_bs;
uint256 public HIGHEST_BID_FEE_P;
uint256 storage_map_bw[ ( 0x09 * ( ( storage_map_bp[ var_x] + 0x01 ) - 0x01 ) ) + keccak256( var_x) ] ;
mapping ( bytes32 = > bytes32 ) storage_map_ca;
mapping ( bytes32 = > bytes32 ) storage_map_ah;
mapping ( bytes32 = > bytes32 ) storage_map_au;
mapping ( bytes32 = > bytes32 ) storage_map_d;
uint256 storage_map_i[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ;
uint256 storage_map_bk[ ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ) + keccak256( var_e) ] ;
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_aq;
uint256 storage_map_bx[ ( 0x09 * ( ( storage_map_bp[ var_x] + 0x01 ) - 0x01 ) ) + keccak256( var_x) ] ;
mapping ( bytes32 = > bytes32 ) storage_map_aa;
mapping ( bytes32 = > bytes32 ) storage_map_ai;
uint256 storage_map_m[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ;
mapping ( bytes32 = > bytes32 ) storage_map_y;
uint256 storage_map_by[ ( 0x09 * ( ( storage_map_bp[ var_x] + 0x01 ) - 0x01 ) ) + keccak256( var_x) ] ;
mapping ( bytes32 = > bytes32 ) storage_map_bi;
mapping ( bytes32 = > bytes32 ) storage_map_m;
mapping ( bytes32 = > bytes32 ) storage_map_ag;
mapping ( bytes32 = > bytes32 ) storage_map_bl;
uint256 storage_map_bm[ ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ) + keccak256( var_e) ] ;
mapping ( bytes32 = > bytes32 ) storage_map_bd;
mapping ( bytes32 = > bytes32 ) storage_map_aj;
mapping ( bytes32 = > bytes32 ) storage_map_bc;
mapping ( bytes32 = > bytes32 ) storage_map_be;
mapping ( bytes32 = > bytes32 ) storage_map_bv;
mapping ( bytes32 = > bytes32 ) storage_map_bz;
mapping ( bytes32 = > bytes32 ) storage_map_c;
mapping ( bytes32 = > bytes32 ) storage_map_bu;
mapping ( bytes32 = > bytes32 ) storage_map_bo;
mapping ( bytes32 = > bytes32 ) storage_map_bf;
mapping ( bytes32 = > bytes32 ) storage_map_cb;
mapping ( bytes32 = > bytes32 ) storage_map_by;
mapping ( bytes32 = > bytes32 ) storage_map_q;
mapping ( bytes32 = > bytes32 ) storage_map_av;
mapping ( bytes32 = > bytes32 ) storage_map_al;
mapping ( bytes32 = > bytes32 ) storage_map_bb;
mapping ( bytes32 = > bytes32 ) storage_map_aw;
mapping ( bytes32 = > bytes32 ) storage_map_az;
mapping ( bytes32 = > bytes32 ) storage_map_ap;
mapping ( bytes32 = > bytes32 ) storage_map_j;
uint256 storage_map_bj[ ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ) + keccak256( var_e) ] ;
address public GOV;
uint256 storage_map_j[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ;
mapping ( bytes32 = > bytes32 ) storage_map_k;
mapping ( bytes32 = > bytes32 ) storage_map_an;
uint256 storage_map_bt[ ( 0x09 * ( ( storage_map_bp[ var_x] + 0x01 ) - 0x01 ) ) + keccak256( var_x) ] ;
mapping ( bytes32 = > bytes32 ) storage_map_bt;
uint256 storage_map_ay[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ;
mapping ( bytes32 = > bytes32 ) storage_map_br;
mapping ( bytes32 = > bytes32 ) storage_map_x;
uint256 storage_map_bl[ ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ) + keccak256( var_e) ] ;
mapping ( bytes32 = > bytes32 ) storage_map_e;
mapping ( bytes32 = > bytes32 ) storage_map_n;
mapping ( bytes32 = > bytes32 ) storage_map_ae;
uint256 storage_map_bd[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ;
mapping ( bytes32 = > bytes32 ) storage_map_at;
uint256 storage_map_f[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ;
mapping ( bytes32 = > bytes32 ) storage_map_z;
uint256 storage_map_bq[ ( 0x09 * ( ( storage_map_bp[ var_x] + 0x01 ) - 0x01 ) ) + keccak256( var_x) ] ;
mapping ( bytes32 = > bytes32 ) storage_map_bk;
mapping ( bytes32 = > bytes32 ) storage_map_ba;
mapping ( bytes32 = > bytes32 ) storage_map_ab;
mapping ( bytes32 = > bytes32 ) storage_map_bj;
mapping ( bytes32 = > bytes32 ) storage_map_a;
mapping ( bytes32 = > bytes32 ) storage_map_as;
mapping ( bytes32 = > bytes32 ) storage_map_bn;
mapping ( bytes32 = > bytes32 ) storage_map_r;
uint256 storage_map_bi[ ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ) + keccak256( var_e) ] ;
mapping ( bytes32 = > bytes32 ) storage_map_bg;
mapping ( bytes32 = > bytes32 ) storage_map_bp;
uint256 storage_map_bs[ ( 0x09 * ( ( storage_map_bp[ var_x] + 0x01 ) - 0x01 ) ) + keccak256( var_x) ] ;
uint256 storage_map_bu[ ( 0x09 * ( ( storage_map_bp[ var_x] + 0x01 ) - 0x01 ) ) + keccak256( var_x) ] ;
uint256 storage_map_bv[ ( 0x09 * ( ( storage_map_bp[ var_x] + 0x01 ) - 0x01 ) ) + keccak256( var_x) ] ;
mapping ( bytes32 = > bytes32 ) storage_map_bx;
mapping ( bytes32 = > bytes32 ) storage_map_p;
mapping ( bytes32 = > bytes32 ) storage_map_bw;
mapping ( bytes32 = > bytes32 ) storage_map_u;
uint256 storage_map_bn[ ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ) + keccak256( var_e) ] ;
uint256 storage_map_bf[ ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ] ;
event NewBid( address , address , uint256 , uint256 , uint256 ) ;
event NewBidding( address , uint256 , uint256 , uint256 , uint256 ) ;
/// @custom:selector 0x83579a63
/// @custom:signature idToBiddingsByLeverageIndex(uint256 arg0) public view returns (uint256)
/// @param arg0 ["uint256", "bytes32", "int256"]
function idToBiddingsByLeverageIndex( uint256 arg0) public view returns ( uint256 ) {
uint256 var_b = arg0;
return storage_map_a[ var_b] ;
}
/// @custom:selector 0x5d453d29
/// @custom:signature set_GOV(address arg0) public
/// @param arg0 ["address", "uint160", "bytes20", "int160"]
function set_GOV( address arg0) public {
require ( msg. sender = = ( address ( GOV) ) ) ;
GOV = ( address ( arg0) ) | ( uint96 ( GOV) ) ;
}
/// @custom:selector 0x454a2ab3
/// @custom:signature bid(uint256 arg0) public payable
/// @param arg0 ["uint256", "bytes32", "int256"]
function bid( uint256 arg0) public payable {
require ( msg. sender = = tx. origin, "Contracts not allowed." ) ;
uint256 var_b = arg0;
require ( address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . code. length) ;
( bool success, bytes memory ret0) = address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . Unresolved_e4214ec0( var_b) ; // staticcall
require ( ! ret0. length < 0x20 ) ;
uint256 var_e = bytes1 ( var_f. length) ;
require ( ! storage_map_c[ var_e] > 0 ) ;
var_b = arg0;
require ( address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . code. length) ;
( bool success, bytes memory ret0) = address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . Unresolved_e4214ec0( var_b) ; // staticcall
require ( ! ( ret0. length < 0x20 ) , "This NFT isn't listed." ) ;
var_e = arg0;
require ( storage_map_c[ var_e] < storage_map_c[ var_e] , "This NFT isn't listed." ) ;
var_e = keccak256( var_e) ;
require ( storage_map_d[ ( 0x09 * storage_map_c[ var_e] ) + keccak256( var_e) ] = = arg0, "This NFT isn't listed." ) ;
var_b = arg0;
require ( address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . code. length) ;
( bool success, bytes memory ret0) = address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . Unresolved_e4214ec0( var_b) ; // staticcall
require ( ! ( ret0. length < 0x20 ) , "SafeMath: addition overflow" ) ;
var_e = arg0;
var_g = 0x01 ;
require ( storage_map_c[ var_e] < storage_map_c[ var_e] , "SafeMath: addition overflow" ) ;
var_e = keccak256( var_e) ;
require ( ! ( msg. sender = = ( address ( storage_map_e[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ) ) ) , "SafeMath: addition overflow" ) ;
require ( ! ( storage_map_f[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] + ( storage_map_g[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ) < ( storage_map_g[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ) ) , "SafeMath: addition overflow" ) ;
require ( block. number < ( storage_map_f[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] + ( storage_map_g[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ) ) , "You must bid higher than the min bid and the highest bid." ) ;
require ( ! ( ! msg. value < ( storage_map_h[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ) ) , "You must bid higher than the min bid and the highest bid." ) ;
require ( ! ( msg. value < ( storage_map_h[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ) ) , "You must bid higher than the min bid and the highest bid." ) ;
require ( ! address ( storage_map_i[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ) ) ;
require ( ! storage_map_j[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ) ;
( bool success, bytes memory ret0) = address ( storage_map_i[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ) . transfer( storage_map_k[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ) ;
require ( msg. value, "SafeMath: multiplication overflow" ) ;
require ( msg. value, "SafeMath: multiplication overflow" ) ;
require ( ( ( BID_FEE_P * msg. value) / msg. value) = = BID_FEE_P, "SafeMath: multiplication overflow" ) ;
uint256 var_f = 0x40 + var_f;
require ( 0x64 , " " ) ;
require ( ! ( bytes1 ( var_f. length) ) , " " ) ;
if ( 0x64 ) {
storage_map_j[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] = msg. value;
var_f = 0x40 + var_f;
require ( 0x64 , "SafeMath: addition overflow" ) ;
require ( ! ( ( ( BID_FEE_P * msg. value) / 0x64 ) > msg. value) , "SafeMath: addition overflow" ) ;
}
storage_map_m[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] = storage_map_j[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] - ( ( BID_FEE_P * msg. value) / 0x64 ) ;
storage_map_i[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] = msg. sender | ( uint96 ( storage_map_i[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ) ) ;
require ( ! ( ( 0x01 + ( storage_map_n[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ) ) < ( storage_map_n[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ) ) , "SafeMath: addition overflow" ) ;
storage_map_n[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] = var_g + ( storage_map_n[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ) ;
var_l = address ( this) ;
require ( address ( 0x831091da075665168e01898c6dac004a867f1e1b ) . code. length) ;
( bool success, bytes memory ret0) = address ( 0x831091da075665168e01898c6dac004a867f1e1b ) . Unresolved_70a08231( var_l) ; // staticcall
require ( ! ( ret0. length < 0x20 ) , "SafeMath: addition overflow" ) ;
require ( ! var_f. length, "SafeMath: addition overflow" ) ;
require ( ! ( ( ( ( BID_FEE_P * msg. value) / 0x64 ) + totalEthDistributed) < totalEthDistributed) , "SafeMath: addition overflow" ) ;
totalEthDistributed = ( ( BID_FEE_P * msg. value) / 0x64 ) + totalEthDistributed;
emit NewBid( address ( storage_map_e[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ) , msg. sender, arg0, bytes1 ( var_f. length) , msg. value) ;
require ( ( BID_FEE_P * msg. value) / 0x64 , " " ) ;
require ( ( BID_FEE_P * msg. value) / 0x64 , " " ) ;
require ( ( 0x0de0b6b3a7640000 * ( ( BID_FEE_P * msg. value) / 0x64 ) ) / ( ( BID_FEE_P * msg. value) / 0x64 ) = = 0x0de0b6b3a7640000 , " " ) ;
var_f = 0x40 + var_f;
require ( var_f. length, " " ) ;
require ( ! ( bytes1 ( var_f. length) ) , " " ) ;
require ( var_f. length, "SafeMath: multiplication overflow" ) ;
require ( msg. value > ( storage_map_p[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ) , "You must bid higher than the min bid and the highest bid." ) ;
require ( storage_map_c[ var_e] > 0 , "This NFT isn't listed." ) ;
}
/// @custom:selector 0x4641257d
/// @custom:signature harvest() public
function harvest( ) public {
require ( msg. sender = = tx. origin, "Contracts not allowed." ) ;
address var_g = msg. sender;
var_e = 0x40 + var_e;
require ( storage_map_q[ var_g] , "SafeMath: multiplication overflow" ) ;
require ( storage_map_q[ var_g] , "SafeMath: multiplication overflow" ) ;
require ( ( accETHperGFARM * storage_map_q[ var_g] ) / storage_map_q[ var_g] = = accETHperGFARM, "SafeMath: multiplication overflow" ) ;
var_e = 0x40 + var_e;
require ( 0x0de0b6b3a7640000 , " " ) ;
require ( ! ( bytes1 ( var_e. length) ) , " " ) ;
if ( 0x0de0b6b3a7640000 ) {
var_e = 0x40 + var_e;
require ( 0x0de0b6b3a7640000 , "SafeMath: multiplication overflow" ) ;
require ( ! ( storage_map_r[ var_g] > ( ( accETHperGFARM * storage_map_q[ var_g] ) / 0x0de0b6b3a7640000 ) ) , "SafeMath: multiplication overflow" ) ;
}
require ( ( ( accETHperGFARM * storage_map_q[ var_g] ) / 0x0de0b6b3a7640000 ) - ( storage_map_r[ var_g] ) , "SafeMath: multiplication overflow" ) ;
var_g = msg. sender;
var_e = 0x40 + var_e;
require ( storage_map_q[ var_g] , "SafeMath: multiplication overflow" ) ;
require ( storage_map_q[ var_g] , "SafeMath: multiplication overflow" ) ;
require ( ( accETHperGFARM * storage_map_q[ var_g] ) / storage_map_q[ var_g] = = accETHperGFARM, "SafeMath: multiplication overflow" ) ;
var_e = 0x40 + var_e;
require ( 0x0de0b6b3a7640000 , " " ) ;
require ( ! ( bytes1 ( var_e. length) ) , " " ) ;
if ( 0x0de0b6b3a7640000 ) {
var_e = 0x40 + var_e;
require ( 0x0de0b6b3a7640000 ) ;
require ( ! ( storage_map_r[ var_g] ) > ( ( accETHperGFARM * storage_map_q[ var_g] ) / 0x0de0b6b3a7640000 ) ) ;
}
( bool success, bytes memory ret0) = address ( msg. sender) . transfer( ( ( accETHperGFARM * storage_map_q[ var_g] ) / 0x0de0b6b3a7640000 ) - ( storage_map_r[ var_g] ) ) ;
}
/// @custom:selector 0x2e17de78
/// @custom:signature unstake(uint256 arg0) public
/// @param arg0 ["uint256", "bytes32", "int256"]
function unstake( uint256 arg0) public {
require ( msg. sender = = tx. origin, "Contracts not allowed." ) ;
address var_e = msg. sender;
require ( ! ( arg0 > storage_map_c[ var_e] ) , "Unstaking more than provided." ) ;
var_e = msg. sender;
var_g = 0x40 + var_g;
require ( storage_map_c[ var_e] , "SafeMath: multiplication overflow" ) ;
require ( storage_map_c[ var_e] , "SafeMath: multiplication overflow" ) ;
require ( ( accETHperGFARM * storage_map_c[ var_e] ) / storage_map_c[ var_e] = = accETHperGFARM, "SafeMath: multiplication overflow" ) ;
var_g = 0x40 + var_g;
require ( 0x0de0b6b3a7640000 , " " ) ;
require ( ! ( bytes1 ( var_g. length) ) , " " ) ;
if ( 0x0de0b6b3a7640000 ) {
var_g = 0x40 + var_g;
require ( 0x0de0b6b3a7640000 , "SafeMath: multiplication overflow" ) ;
require ( ! ( storage_map_t[ var_e] > ( ( accETHperGFARM * storage_map_c[ var_e] ) / 0x0de0b6b3a7640000 ) ) , "SafeMath: multiplication overflow" ) ;
}
require ( ! ( ( ( accETHperGFARM * storage_map_c[ var_e] ) / 0x0de0b6b3a7640000 ) - ( storage_map_t[ var_e] ) ) , "SafeMath: multiplication overflow" ) ;
var_e = msg. sender;
var_g = 0x40 + var_g;
require ( storage_map_c[ var_e] , "SafeMath: multiplication overflow" ) ;
require ( storage_map_c[ var_e] , "SafeMath: multiplication overflow" ) ;
require ( ( accETHperGFARM * storage_map_c[ var_e] ) / storage_map_c[ var_e] = = accETHperGFARM, "SafeMath: multiplication overflow" ) ;
var_g = 0x40 + var_g;
require ( 0x0de0b6b3a7640000 , " " ) ;
require ( ! ( bytes1 ( var_g. length) ) , " " ) ;
if ( 0x0de0b6b3a7640000 ) {
var_g = 0x40 + var_g;
require ( 0x0de0b6b3a7640000 ) ;
require ( ! ( storage_map_t[ var_e] ) > ( ( accETHperGFARM * storage_map_c[ var_e] ) / 0x0de0b6b3a7640000 ) ) ;
}
( bool success, bytes memory ret0) = address ( msg. sender) . transfer( ( ( accETHperGFARM * storage_map_c[ var_e] ) / 0x0de0b6b3a7640000 ) - ( storage_map_t[ var_e] ) ) ;
}
/// @custom:selector 0xa87430ba
/// @custom:signature users(address arg0) public view returns (bytes memory)
/// @param arg0 ["address", "uint160", "bytes20", "int160"]
function users( address arg0) public view returns ( bytes memory ) {
address var_b = address ( arg0) ;
return abi. encodePacked( storage_map_a[ var_b] , storage_map_u[ var_b] ) ;
}
/// @custom:selector 0xa694fc3a
/// @custom:signature stake(uint256 arg0) public
/// @param arg0 ["uint256", "bytes32", "int256"]
function stake( uint256 arg0) public {
require ( msg. sender = = tx. origin, "Contracts not allowed." ) ;
address var_b = msg. sender;
require ( address ( 0x831091da075665168e01898c6dac004a867f1e1b ) . code. length) ;
( bool success, bytes memory ret0) = address ( 0x831091da075665168e01898c6dac004a867f1e1b ) . { value: 0 ether } Unresolved_23b872dd( var_b) ; // call
require ( ! ( ret0. length < 0x20 ) , "SafeMath: multiplication overflow" ) ;
address var_g = msg. sender;
var_e = 0x40 + var_e;
require ( storage_map_q[ var_g] , "SafeMath: multiplication overflow" ) ;
require ( storage_map_q[ var_g] , "SafeMath: multiplication overflow" ) ;
require ( ( accETHperGFARM * storage_map_q[ var_g] ) / storage_map_q[ var_g] = = accETHperGFARM, "SafeMath: multiplication overflow" ) ;
var_e = 0x40 + var_e;
require ( 0x0de0b6b3a7640000 , " " ) ;
require ( ! ( bytes1 ( var_e. length) ) , " " ) ;
if ( 0x0de0b6b3a7640000 ) {
var_e = 0x40 + var_e;
require ( 0x0de0b6b3a7640000 , "SafeMath: multiplication overflow" ) ;
require ( ! ( storage_map_r[ var_g] > ( ( accETHperGFARM * storage_map_q[ var_g] ) / 0x0de0b6b3a7640000 ) ) , "SafeMath: multiplication overflow" ) ;
}
require ( ! ( ( ( accETHperGFARM * storage_map_q[ var_g] ) / 0x0de0b6b3a7640000 ) - ( storage_map_r[ var_g] ) ) , "SafeMath: multiplication overflow" ) ;
var_g = msg. sender;
var_e = 0x40 + var_e;
require ( storage_map_q[ var_g] , "SafeMath: multiplication overflow" ) ;
require ( storage_map_q[ var_g] , "SafeMath: multiplication overflow" ) ;
require ( ( accETHperGFARM * storage_map_q[ var_g] ) / storage_map_q[ var_g] = = accETHperGFARM, "SafeMath: multiplication overflow" ) ;
var_e = 0x40 + var_e;
require ( 0x0de0b6b3a7640000 , " " ) ;
require ( ! ( bytes1 ( var_e. length) ) , " " ) ;
if ( 0x0de0b6b3a7640000 ) {
var_e = 0x40 + var_e;
require ( 0x0de0b6b3a7640000 ) ;
require ( ! ( storage_map_r[ var_g] ) > ( ( accETHperGFARM * storage_map_q[ var_g] ) / 0x0de0b6b3a7640000 ) ) ;
}
( bool success, bytes memory ret0) = address ( msg. sender) . transfer( ( ( accETHperGFARM * storage_map_q[ var_g] ) / 0x0de0b6b3a7640000 ) - ( storage_map_r[ var_g] ) ) ;
var_g = msg. sender;
require ( ! ( ( arg0 + storage_map_q[ var_g] ) < storage_map_q[ var_g] ) , "SafeMath: addition overflow" ) ;
}
/// @custom:selector 0x0eebed92
/// @custom:signature set_BID_FEE_P(uint256 arg0) public
/// @param arg0 ["uint256", "bytes32", "int256"]
function set_BID_FEE_P( uint256 arg0) public {
require ( msg. sender = = ( address ( GOV) ) ) ;
BID_FEE_P = arg0;
}
/// @custom:selector 0x0480c899
/// @custom:signature set_HIGHEST_BID_FEE_P(uint256 arg0) public
/// @param arg0 ["uint256", "bytes32", "int256"]
function set_HIGHEST_BID_FEE_P( uint256 arg0) public {
require ( msg. sender = = ( address ( GOV) ) ) ;
HIGHEST_BID_FEE_P = arg0;
}
/// @custom:selector 0x336b2969
/// @custom:signature biddingsByLeverage(uint256 arg0, uint256 arg1) public view returns (bytes memory)
/// @param arg0 ["uint256", "bytes32", "int256"]
/// @param arg1 ["uint256", "bytes32", "int256"]
function biddingsByLeverage( uint256 arg0, uint256 arg1) public view returns ( bytes memory ) {
uint256 var_b = arg0;
require ( arg1 < storage_map_a[ var_b] ) ;
var_b = keccak256( var_b) ;
return abi. encodePacked( storage_map_w[ arg1 * 0x09 ] , address ( storage_map_x[ ( arg1 * 0x09 ) + keccak256( var_b) ] ) , storage_map_y[ ( arg1 * 0x09 ) + keccak256( var_b) ] , storage_map_z[ ( arg1 * 0x09 ) + keccak256( var_b) ] , storage_map_aa[ ( arg1 * 0x09 ) + keccak256( var_b) ] , storage_map_ab[ ( arg1 * 0x09 ) + keccak256( var_b) ] , storage_map_ac[ ( arg1 * 0x09 ) + keccak256( var_b) ] , address ( storage_map_ad[ ( arg1 * 0x09 ) + keccak256( var_b) ] ) , storage_map_ae[ ( arg1 * 0x09 ) + keccak256( var_b) ] ) ;
}
/// @custom:selector 0xfcce4883
/// @custom:signature isListed(uint256 arg0) public returns (bool)
/// @param arg0 ["uint256", "bytes32", "int256"]
function isListed( uint256 arg0) public returns ( bool ) {
uint256 var_b = arg0;
require ( address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . code. length) ;
( bool success, bytes memory ret0) = address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . Unresolved_e4214ec0( var_b) ; // staticcall
require ( ! ret0. length < 0x20 ) ;
uint256 var_c = bytes1 ( var_d. length) ;
require ( ! storage_map_af[ var_c] > 0 ) ;
var_b = arg0;
require ( address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . code. length) ;
( bool success, bytes memory ret0) = address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . Unresolved_e4214ec0( var_b) ; // staticcall
require ( ! ret0. length < 0x20 ) ;
var_c = arg0;
require ( storage_map_af[ var_c] < storage_map_af[ var_c] ) ;
var_c = keccak256( var_c) ;
return ! ( ! ( storage_map_ag[ ( 0x09 * storage_map_af[ var_c] ) + keccak256( var_c) ] ) = = arg0) ;
return ! ( ! storage_map_af[ var_c] > 0 ) ;
}
/// @custom:selector 0x379607f5
/// @custom:signature claim(uint256 arg0) public
/// @param arg0 ["uint256", "bytes32", "int256"]
function claim( uint256 arg0) public {
require ( msg. sender = = tx. origin, "Contracts not allowed." ) ;
uint256 var_b = arg0;
require ( address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . code. length) ;
( bool success, bytes memory ret0) = address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . Unresolved_e4214ec0( var_b) ; // staticcall
require ( ! ret0. length < 0x20 ) ;
uint256 var_e = bytes1 ( var_f. length) ;
require ( ! storage_map_c[ var_e] > 0 ) ;
var_b = arg0;
require ( address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . code. length) ;
( bool success, bytes memory ret0) = address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . Unresolved_e4214ec0( var_b) ; // staticcall
require ( ! ( ret0. length < 0x20 ) , "This NFT isn't listed." ) ;
var_e = arg0;
require ( storage_map_c[ var_e] < storage_map_c[ var_e] , "This NFT isn't listed." ) ;
var_e = keccak256( var_e) ;
require ( storage_map_d[ ( 0x09 * storage_map_c[ var_e] ) + keccak256( var_e) ] = = arg0, "This NFT isn't listed." ) ;
uint256 var_f = 0x0120 + var_f;
uint256 var_k = 0 ;
uint256 var_q = arg0;
require ( address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . code. length) ;
( bool success, bytes memory ret0) = address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . Unresolved_e4214ec0( var_q) ; // staticcall
require ( ! ( ret0. length < 0x20 ) , "SafeMath: addition overflow" ) ;
var_e = arg0;
require ( storage_map_c[ var_e] < storage_map_c[ var_e] , "SafeMath: addition overflow" ) ;
var_e = keccak256( var_e) ;
var_f = var_f + 0x0120 ;
require ( ! ( storage_map_ak[ keccak256( var_e) + ( storage_map_c[ var_e] * 0x09 ) ] + ( storage_map_aq[ keccak256( var_e) + ( storage_map_c[ var_e] * 0x09 ) ] ) < ( storage_map_aq[ keccak256( var_e) + ( storage_map_c[ var_e] * 0x09 ) ] ) ) , "SafeMath: addition overflow" ) ;
require ( ! ( block. number < ( storage_map_ak[ keccak256( var_e) + ( storage_map_c[ var_e] * 0x09 ) ] + ( storage_map_aq[ keccak256( var_e) + ( storage_map_c[ var_e] * 0x09 ) ] ) ) ) , "Bidding hasn't ended." ) ;
require ( var_ad > 0 , "SafeMath: multiplication overflow" ) ;
require ( var_ae, "SafeMath: multiplication overflow" ) ;
require ( var_ae, "SafeMath: multiplication overflow" ) ;
require ( ( HIGHEST_BID_FEE_P * ( var_ae) ) / ( var_ae) = = HIGHEST_BID_FEE_P, "SafeMath: multiplication overflow" ) ;
var_f = 0x40 + var_f;
require ( 0x64 , " " ) ;
require ( ! ( bytes1 ( var_f. length) ) , " " ) ;
require ( 0x64 , " " ) ;
var_f = 0x40 + var_f;
require ( ! ( ( ( HIGHEST_BID_FEE_P * ( var_ae) ) / 0x64 ) > ( var_ae) ) , " " ) ;
require ( ! var_f. length, " " ) ;
require ( ! ( bytes1 ( var_f. length) ) , " " ) ;
( bool success, bytes memory ret0) = address ( var_as) . transfer( var_ae - ( ( HIGHEST_BID_FEE_P * ( var_ae) ) / 0x64 ) ) ;
var_aj = address ( this) ;
require ( address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . code. length) ;
( bool success, bytes memory ret0) = address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . { value: var_k ether } Unresolved_23b872dd( var_aj) ; // call
var_aj = arg0;
require ( address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . code. length) ;
( bool success, bytes memory ret0) = address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . Unresolved_e4214ec0( var_aj) ; // staticcall
require ( ! ret0. length < 0x20 ) ;
var_e = arg0;
require ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) < storage_map_c[ var_e] ) ;
var_e = storage_map_ar[ var_e] ;
storage_map_c[ var_e] = storage_map_c[ var_e] ;
require ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) < storage_map_c[ var_e] ) ;
var_e = arg0;
require ( storage_map_c[ var_e] < storage_map_c[ var_e] ) ;
var_e = keccak256( var_e) ;
storage_map_as[ storage_map_c[ var_e] * 0x09 ] = storage_map_at[ 0x09 * ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) ] ;
storage_map_e[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] = ( uint96 ( storage_map_e[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ) ) | ( address ( storage_map_au[ ( 0x09 * ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) ) + keccak256( var_e) ] ) ) ;
storage_map_av[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] = storage_map_aw[ ( 0x09 * ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) ) + keccak256( var_e) ] ;
storage_map_f[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] = storage_map_ax[ ( 0x09 * ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) ) + keccak256( var_e) ] ;
storage_map_ay[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] = storage_map_az[ ( 0x09 * ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) ) + keccak256( var_e) ] ;
storage_map_j[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] = storage_map_ba[ ( 0x09 * ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) ) + keccak256( var_e) ] ;
storage_map_m[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] = storage_map_bb[ ( 0x09 * ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) ) + keccak256( var_e) ] ;
storage_map_i[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] = ( uint96 ( storage_map_i[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ) ) | ( address ( storage_map_bc[ ( 0x09 * ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) ) + keccak256( var_e) ] ) ) ;
storage_map_bd[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] = storage_map_be[ ( 0x09 * ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) ) + keccak256( var_e) ] ;
require ( storage_map_c[ var_e] ) ;
var_e = keccak256( var_e) ;
storage_map_bf[ ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ] = 0 ;
storage_map_bg[ ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ) + keccak256( var_e) ] = uint96 ( storage_map_bg[ ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ) + keccak256( var_e) ] ) ;
storage_map_bh[ ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ) + keccak256( var_e) ] = 0 ;
storage_map_bi[ ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ) + keccak256( var_e) ] = 0 ;
storage_map_bj[ ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ) + keccak256( var_e) ] = 0 ;
storage_map_bk[ ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ) + keccak256( var_e) ] = 0 ;
storage_map_bl[ ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ) + keccak256( var_e) ] = 0 ;
storage_map_bm[ ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ) + keccak256( var_e) ] = uint96 ( storage_map_bm[ ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ) + keccak256( var_e) ] ) ;
storage_map_bn[ ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ) + keccak256( var_e) ] = 0 ;
storage_map_c[ var_e] = storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ;
var_e = arg0;
storage_map_c[ var_e] = 0 ;
var_aj = address ( this) ;
require ( address ( 0x831091da075665168e01898c6dac004a867f1e1b ) . code. length) ;
( bool success, bytes memory ret0) = address ( 0x831091da075665168e01898c6dac004a867f1e1b ) . Unresolved_70a08231( var_aj) ; // staticcall
require ( ! ( ret0. length < 0x20 ) , "SafeMath: addition overflow" ) ;
require ( ! var_f. length, "SafeMath: addition overflow" ) ;
require ( ! ( ( ( ( HIGHEST_BID_FEE_P * ( var_ae) ) / 0x64 ) + totalEthDistributed) < totalEthDistributed) , "SafeMath: addition overflow" ) ;
totalEthDistributed = ( ( HIGHEST_BID_FEE_P * ( var_ae) ) / 0x64 ) + totalEthDistributed;
require ( ( HIGHEST_BID_FEE_P * ( var_ae) ) / 0x64 , "SafeMath: multiplication overflow" ) ;
require ( ( HIGHEST_BID_FEE_P * ( var_ae) ) / 0x64 , "SafeMath: multiplication overflow" ) ;
require ( ( 0x0de0b6b3a7640000 * ( ( HIGHEST_BID_FEE_P * ( var_ae) ) / 0x64 ) ) / ( ( HIGHEST_BID_FEE_P * ( var_ae) ) / 0x64 ) = = 0x0de0b6b3a7640000 , "SafeMath: multiplication overflow" ) ;
var_f = 0x40 + var_f;
require ( var_f. length, "SafeMath: multiplication overflow" ) ;
require ( var_f. length, "SafeMath: multiplication overflow" ) ;
require ( storage_map_c[ var_e] > 0 , "This NFT isn't listed." ) ;
}
/// @custom:selector 0x7d529d72
/// @custom:signature claimBack(uint256 arg0) public
/// @param arg0 ["uint256", "bytes32", "int256"]
function claimBack( uint256 arg0) public {
require ( msg. sender = = tx. origin, "Contracts not allowed." ) ;
uint256 var_b = arg0;
require ( address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . code. length) ;
( bool success, bytes memory ret0) = address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . Unresolved_e4214ec0( var_b) ; // staticcall
require ( ! ret0. length < 0x20 ) ;
uint256 var_e = bytes1 ( var_f. length) ;
require ( ! storage_map_c[ var_e] > 0 ) ;
var_b = arg0;
require ( address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . code. length) ;
( bool success, bytes memory ret0) = address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . Unresolved_e4214ec0( var_b) ; // staticcall
require ( ! ( ret0. length < 0x20 ) , "This NFT isn't listed." ) ;
var_e = arg0;
require ( storage_map_c[ var_e] < storage_map_c[ var_e] , "This NFT isn't listed." ) ;
var_e = keccak256( var_e) ;
require ( storage_map_d[ ( 0x09 * storage_map_c[ var_e] ) + keccak256( var_e) ] = = arg0, "This NFT isn't listed." ) ;
uint256 var_f = 0x0120 + var_f;
uint256 var_k = 0 ;
uint256 var_q = arg0;
require ( address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . code. length) ;
( bool success, bytes memory ret0) = address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . Unresolved_e4214ec0( var_q) ; // staticcall
require ( ! ( ret0. length < 0x20 ) , "Bids were made." ) ;
var_e = arg0;
require ( storage_map_c[ var_e] < storage_map_c[ var_e] , "Bids were made." ) ;
var_e = keccak256( var_e) ;
var_f = var_f + 0x0120 ;
require ( ! ( storage_map_bo[ keccak256( var_e) + ( storage_map_c[ var_e] * 0x09 ) ] ) , "Bids were made." ) ;
require ( ! ( var_ad + ( var_ae) < ( var_ae) ) , "SafeMath: addition overflow" ) ;
require ( ! ( block. number < ( var_ad + ( var_ae) ) ) , "Bidding hasn't ended." ) ;
var_aa = address ( this) ;
require ( address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . code. length) ;
( bool success, bytes memory ret0) = address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . { value: var_k ether } Unresolved_23b872dd( var_aa) ; // call
var_aa = arg0;
require ( address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . code. length) ;
( bool success, bytes memory ret0) = address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . Unresolved_e4214ec0( var_aa) ; // staticcall
require ( ! ret0. length < 0x20 ) ;
var_e = arg0;
require ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) < storage_map_c[ var_e] ) ;
var_e = storage_map_ar[ var_e] ;
storage_map_c[ var_e] = storage_map_c[ var_e] ;
require ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) < storage_map_c[ var_e] ) ;
var_e = arg0;
require ( storage_map_c[ var_e] < storage_map_c[ var_e] ) ;
var_e = keccak256( var_e) ;
storage_map_as[ storage_map_c[ var_e] * 0x09 ] = storage_map_at[ 0x09 * ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) ] ;
storage_map_e[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] = ( uint96 ( storage_map_e[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ) ) | ( address ( storage_map_au[ ( 0x09 * ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) ) + keccak256( var_e) ] ) ) ;
storage_map_av[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] = storage_map_aw[ ( 0x09 * ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) ) + keccak256( var_e) ] ;
storage_map_f[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] = storage_map_ax[ ( 0x09 * ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) ) + keccak256( var_e) ] ;
storage_map_ay[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] = storage_map_az[ ( 0x09 * ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) ) + keccak256( var_e) ] ;
storage_map_j[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] = storage_map_ba[ ( 0x09 * ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) ) + keccak256( var_e) ] ;
storage_map_m[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] = storage_map_bb[ ( 0x09 * ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) ) + keccak256( var_e) ] ;
storage_map_i[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] = ( uint96 ( storage_map_i[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] ) ) | ( address ( storage_map_bc[ ( 0x09 * ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) ) + keccak256( var_e) ] ) ) ;
storage_map_bd[ ( storage_map_c[ var_e] * 0x09 ) + keccak256( var_e) ] = storage_map_be[ ( 0x09 * ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) ) + keccak256( var_e) ] ;
require ( storage_map_c[ var_e] ) ;
var_e = keccak256( var_e) ;
storage_map_bf[ ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ] = 0 ;
storage_map_bg[ ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ) + keccak256( var_e) ] = uint96 ( storage_map_bg[ ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ) + keccak256( var_e) ] ) ;
storage_map_bh[ ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ) + keccak256( var_e) ] = 0 ;
storage_map_bi[ ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ) + keccak256( var_e) ] = 0 ;
storage_map_bj[ ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ) + keccak256( var_e) ] = 0 ;
storage_map_bk[ ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ) + keccak256( var_e) ] = 0 ;
storage_map_bl[ ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ) + keccak256( var_e) ] = 0 ;
storage_map_bm[ ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ) + keccak256( var_e) ] = uint96 ( storage_map_bm[ ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ) + keccak256( var_e) ] ) ;
storage_map_bn[ ( ( storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ) * 0x09 ) + keccak256( var_e) ] = 0 ;
storage_map_c[ var_e] = storage_map_c[ var_e] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ;
var_e = arg0;
storage_map_c[ var_e] = 0 ;
require ( storage_map_c[ var_e] > 0 , "This NFT isn't listed." ) ;
}
/// @custom:selector 0xd3c9727c
/// @custom:signature sell(uint256 arg0, uint256 arg1, uint256 arg2) public
/// @param arg0 ["uint256", "bytes32", "int256"]
/// @param arg1 ["uint256", "bytes32", "int256"]
/// @param arg2 ["uint256", "bytes32", "int256"]
function sell( uint256 arg0, uint256 arg1, uint256 arg2) public {
require ( msg. sender = = tx. origin, "Contracts not allowed." ) ;
require ( ! ( ! arg2 < 0x64 ) , "Bidding duration should be between 100 and 100k blocks." ) ;
require ( ! ( arg2 > 0x0186a0 ) , "Bidding duration should be between 100 and 100k blocks." ) ;
var_b = msg. sender;
require ( address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . code. length) ;
( bool success, bytes memory ret0) = address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . { value: 0 ether } Unresolved_23b872dd( var_b) ; // call
var_b = arg0;
require ( address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . code. length) ;
( bool success, bytes memory ret0) = address ( 0x43ccd9ea8f64b8918267f7ee4a071d3e9168f9cd ) . Unresolved_e4214ec0( var_b) ; // staticcall
require ( ! ret0. length < 0x20 ) ;
var_e = 0x0120 + var_e;
uint256 var_x = bytes1 ( var_e. length) ;
storage_map_bp[ var_x] = storage_map_bp[ var_x] + 0x01 ;
var_x = keccak256( var_x) ;
storage_map_bq[ ( 0x09 * ( ( storage_map_bp[ var_x] + 0x01 ) - 0x01 ) ) + keccak256( var_x) ] = var_z;
storage_map_br[ ( 0x09 * ( ( storage_map_bp[ var_x] + 0x01 ) - 0x01 ) ) + keccak256( var_x) ] = ( address ( var_aa) * 0x01 ) | ( uint96 ( storage_map_br[ ( 0x09 * ( ( storage_map_bp[ var_x] + 0x01 ) - 0x01 ) ) + keccak256( var_x) ] ) ) ;
storage_map_bs[ ( 0x09 * ( ( storage_map_bp[ var_x] + 0x01 ) - 0x01 ) ) + keccak256( var_x) ] = var_ab;
storage_map_bt[ ( 0x09 * ( ( storage_map_bp[ var_x] + 0x01 ) - 0x01 ) ) + keccak256( var_x) ] = var_ac;
storage_map_bu[ ( 0x09 * ( ( storage_map_bp[ var_x] + 0x01 ) - 0x01 ) ) + keccak256( var_x) ] = var_ad;
storage_map_bv[ ( 0x09 * ( ( storage_map_bp[ var_x] + 0x01 ) - 0x01 ) ) + keccak256( var_x) ] = var_ae;
storage_map_bw[ ( 0x09 * ( ( storage_map_bp[ var_x] + 0x01 ) - 0x01 ) ) + keccak256( var_x) ] = var_af;
storage_map_bx[ ( 0x09 * ( ( storage_map_bp[ var_x] + 0x01 ) - 0x01 ) ) + keccak256( var_x) ] = ( address ( var_ag) * 0x01 ) | ( uint96 ( storage_map_bx[ ( 0x09 * ( ( storage_map_bp[ var_x] + 0x01 ) - 0x01 ) ) + keccak256( var_x) ] ) ) ;
storage_map_by[ ( 0x09 * ( ( storage_map_bp[ var_x] + 0x01 ) - 0x01 ) ) + keccak256( var_x) ] = var_ah;
var_x = arg0;
storage_map_bp[ var_x] = storage_map_bp[ var_x] - 0x01 ;
emit NewBidding( address ( msg. sender) , arg0, bytes1 ( var_e. length) , arg2, arg1) ;
require ( ! ( arg2 < 0x64 ) , "Bidding duration should be between 100 and 100k blocks." ) ;
}
/// @custom:selector 0xde73465e
/// @custom:signature biddingsCountLeverage(uint256 arg0) public view returns (uint256)
/// @param arg0 ["uint256", "bytes32", "int256"]
function biddingsCountLeverage( uint256 arg0) public view returns ( uint256 ) {
uint256 var_a = arg0;
return storage_map_bz[ var_a] ;
}
/// @custom:selector 0xedaf2d2e
/// @custom:signature TVL() public
function TVL( ) public {
require ( address ( 0xb4e16d0168e52d35cacd2c6185b44281ec28c9dc ) . code. length) ;
( bool success, bytes memory ret0) = address ( 0xb4e16d0168e52d35cacd2c6185b44281ec28c9dc ) . getReserves( ) ; // staticcall
require ( ! ret0. length < 0x60 ) ;
require ( address ( 0xb4e16d0168e52d35cacd2c6185b44281ec28c9dc ) . code. length) ;
( bool success, bytes memory ret0) = address ( 0xb4e16d0168e52d35cacd2c6185b44281ec28c9dc ) . token0( ) ; // staticcall
require ( ! ( ret0. length < 0x20 ) , "SafeMath: multiplication overflow" ) ;
require ( ! ( 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 = = ( address ( var_b. length) ) ) , "SafeMath: multiplication overflow" ) ;
require ( uint112( var_c) , "SafeMath: multiplication overflow" ) ;
require ( uint112( var_c) , "SafeMath: multiplication overflow" ) ;
require ( ( 0xe8d4a51000 * ( uint112( var_c) ) ) / ( uint112( var_c) ) = = 0xe8d4a51000 , "SafeMath: multiplication overflow" ) ;
}
}
ABI
[
{
"type": "function",
"name": "BID_FEE_P",
"inputs": [],
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"stateMutability": "view"
},
{
"type": "function",
"name": "GOV",
"inputs": [],
"outputs": [
{
"name": "",
"type": "address"
}
],
"stateMutability": "view"
},
{
"type": "function",
"name": "HIGHEST_BID_FEE_P",
"inputs": [],
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"stateMutability": "view"
},
{
"type": "function",
"name": "TVL",
"inputs": [],
"outputs": [],
"stateMutability": "nonpayable"
},
{
"type": "function",
"name": "accETHperGFARM",
"inputs": [],
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"stateMutability": "view"
},
{
"type": "function",
"name": "bid",
"inputs": [
{
"name": "arg0",
"type": "uint256"
}
],
"outputs": [],
"stateMutability": "payable"
},
{
"type": "function",
"name": "biddingsByLeverage",
"inputs": [
{
"name": "arg0",
"type": "uint256"
},
{
"name": "arg1",
"type": "uint256"
}
],
"outputs": [
{
"name": "",
"type": "bytes"
}
],
"stateMutability": "view"
},
{
"type": "function",
"name": "biddingsCountLeverage",
"inputs": [
{
"name": "arg0",
"type": "uint256"
}
],
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"stateMutability": "view"
},
{
"type": "function",
"name": "claim",
"inputs": [
{
"name": "arg0",
"type": "uint256"
}
],
"outputs": [],
"stateMutability": "nonpayable"
},
{
"type": "function",
"name": "claimBack",
"inputs": [
{
"name": "arg0",
"type": "uint256"
}
],
"outputs": [],
"stateMutability": "nonpayable"
},
{
"type": "function",
"name": "harvest",
"inputs": [],
"outputs": [],
"stateMutability": "nonpayable"
},
{
"type": "function",
"name": "idToBiddingsByLeverageIndex",
"inputs": [
{
"name": "arg0",
"type": "uint256"
}
],
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"stateMutability": "view"
},
{
"type": "function",
"name": "isListed",
"inputs": [
{
"name": "arg0",
"type": "uint256"
}
],
"outputs": [
{
"name": "",
"type": "bool"
}
],
"stateMutability": "nonpayable"
},
{
"type": "function",
"name": "lp",
"inputs": [],
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"stateMutability": "pure"
},
{
"type": "function",
"name": "nft",
"inputs": [],
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"stateMutability": "pure"
},
{
"type": "function",
"name": "pendingReward",
"inputs": [],
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"stateMutability": "view"
},
{
"type": "function",
"name": "sell",
"inputs": [
{
"name": "arg0",
"type": "uint256"
},
{
"name": "arg1",
"type": "uint256"
},
{
"name": "arg2",
"type": "uint256"
}
],
"outputs": [],
"stateMutability": "nonpayable"
},
{
"type": "function",
"name": "set_BID_FEE_P",
"inputs": [
{
"name": "arg0",
"type": "uint256"
}
],
"outputs": [],
"stateMutability": "nonpayable"
},
{
"type": "function",
"name": "set_GOV",
"inputs": [
{
"name": "arg0",
"type": "address"
}
],
"outputs": [],
"stateMutability": "nonpayable"
},
{
"type": "function",
"name": "set_HIGHEST_BID_FEE_P",
"inputs": [
{
"name": "arg0",
"type": "uint256"
}
],
"outputs": [],
"stateMutability": "nonpayable"
},
{
"type": "function",
"name": "stake",
"inputs": [
{
"name": "arg0",
"type": "uint256"
}
],
"outputs": [],
"stateMutability": "nonpayable"
},
{
"type": "function",
"name": "token",
"inputs": [],
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"stateMutability": "pure"
},
{
"type": "function",
"name": "totalEthDistributed",
"inputs": [],
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"stateMutability": "view"
},
{
"type": "function",
"name": "unstake",
"inputs": [
{
"name": "arg0",
"type": "uint256"
}
],
"outputs": [],
"stateMutability": "nonpayable"
},
{
"type": "function",
"name": "users",
"inputs": [
{
"name": "arg0",
"type": "address"
}
],
"outputs": [
{
"name": "",
"type": "bytes"
}
],
"stateMutability": "view"
},
{
"type": "event",
"name": "NewBid",
"inputs": [
{
"name": "arg0",
"type": "address",
"indexed": false
},
{
"name": "arg1",
"type": "address",
"indexed": false
},
{
"name": "arg2",
"type": "uint256",
"indexed": false
},
{
"name": "arg3",
"type": "uint256",
"indexed": false
},
{
"name": "arg4",
"type": "uint256",
"indexed": false
}
],
"anonymous": false
},
{
"type": "event",
"name": "NewBidding",
"inputs": [
{
"name": "arg0",
"type": "address",
"indexed": false
},
{
"name": "arg1",
"type": "uint256",
"indexed": false
},
{
"name": "arg2",
"type": "uint256",
"indexed": false
},
{
"name": "arg3",
"type": "uint256",
"indexed": false
},
{
"name": "arg4",
"type": "uint256",
"indexed": false
}
],
"anonymous": false
}
]
