Token Reference System for DeFi

DeFi  
 

Overview ERC-20

Price
$0.00 @ 0.000000 MATIC
Fully Diluted Market Cap
Total Supply:
6,745,497.470465 RSD

Holders:
256 addresses
 
Balance
407.613091057555255753 RSD

Value
$0.00
0xe7e2cb8c81c10ff191a73fe266788c9ce62ec754
Loading
[ Download CSV Export  ] 
Loading
[ Download CSV Export  ] 
Loading

OVERVIEW

An algorithmic token for DeFi with dynamic supply and based on reinforcement learning.


Update? Click here to update the token ICO / general information
# Exchange Pair Price  24H Volume % Volume
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
ReferenceSystemDeFi

Compiler Version
v0.6.2+commit.bacdbe57

Optimization Enabled:
Yes with 5000 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2021-06-11
*/

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

contract RefStake is Ownable {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    // Info of each user.
    struct UserInfo {
        uint256 amount;     // How many LP tokens the user has provided.
        uint256 rewardDebt; // Reward debt. See explanation below.
        //
        // We do some fancy math here. Basically, any point in time, the amount of RSDs
        // entitled to a user but is pending to be distributed is:
        //
        //   pending reward = (user.amount * pool.accRsdPerShare) - user.rewardDebt
        //
        // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
        //   1. The pool's `accRsdPerShare` (and `lastRewardBlock`) gets updated.
        //   2. User receives the pending reward sent to his/her address.
        //   3. User's `amount` gets updated.
        //   4. User's `rewardDebt` gets updated.
    }

    // Info of each pool.
    struct PoolInfo {
        IERC20 lpToken;           // Address of LP token contract.
        uint256 allocPoint;       // How many allocation points assigned to this pool. RSDs to distribute per block.
        uint256 lastRewardBlock;  // Last block number that RSDs distribution occurs.
        uint256 accRsdPerShare; // Accumulated RSDs per share, times 1e12. See below.
    }

    // The RSD TOKEN!
    ReferenceSystemDeFi public rsd;
    // RSD tokens created per block.
    uint256 public rsdPerBlock;
    // Bonus muliplier for early rsd makers.
    uint256 public BONUS_MULTIPLIER = 100;
    // // The migrator contract. It has a lot of power. Can only be set through governance (owner).
    // IMigratorChef public migrator;

    // Info of each pool.
    PoolInfo[] public poolInfo;
    // Info of each user that stakes LP tokens.
    mapping (uint256 => mapping (address => UserInfo)) public userInfo;
    // Total allocation points. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint = 0;
    // The block number when RSD mining starts.
    uint256 public startBlock;

    event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);

    constructor(
        uint256 _rsdPerBlock,
        uint256 _startBlock
    ) public {
        rsdPerBlock = _rsdPerBlock;
        startBlock = _startBlock;
        totalAllocPoint = 1000;
    }

    function updateMultiplier(uint256 multiplierNumber) public onlyOwner {
        BONUS_MULTIPLIER = multiplierNumber;
    }

    function poolLength() external view returns (uint256) {
        return poolInfo.length;
    }

    // Add a new lp to the pool. Can only be called by the owner.
    // XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.
    function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner {
        if (_withUpdate) {
            massUpdatePools();
        }
        uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolInfo.push(PoolInfo({
            lpToken: _lpToken,
            allocPoint: _allocPoint,
            lastRewardBlock: lastRewardBlock,
            accRsdPerShare: 0
        }));
        updateStakingPool();
    }

    // Update the given pool's RSD allocation point. Can only be called by the owner.
    function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner {
        if (_withUpdate) {
            massUpdatePools();
        }
        uint256 prevAllocPoint = poolInfo[_pid].allocPoint;
        poolInfo[_pid].allocPoint = _allocPoint;
        if (prevAllocPoint != _allocPoint) {
            totalAllocPoint = totalAllocPoint.sub(prevAllocPoint).add(_allocPoint);
            updateStakingPool();
        }
    }

    function updateStakingPool() internal {
        uint256 length = poolInfo.length;
        uint256 points = 0;
        for (uint256 pid = 1; pid < length; ++pid) {
            points = points.add(poolInfo[pid].allocPoint);
        }
        if (points != 0) {
            points = points.div(3);
            totalAllocPoint = totalAllocPoint.sub(poolInfo[0].allocPoint).add(points);
            poolInfo[0].allocPoint = points;
        }
    }

    // Return reward multiplier over the given _from to _to block.
    function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) {
        return _to.sub(_from).mul(BONUS_MULTIPLIER);
    }

    // View function to see pending RSDs on frontend.
    function pendingRsd(uint256 _pid, address _user) external view returns (uint256) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accRsdPerShare = pool.accRsdPerShare;
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (block.number > pool.lastRewardBlock && lpSupply != 0) {
            uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
            uint256 rsdReward = multiplier.mul(rsdPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
            accRsdPerShare = accRsdPerShare.add(rsdReward.mul(1e12).div(lpSupply));
        }
        return user.amount.mul(accRsdPerShare).div(1e12).sub(user.rewardDebt);
    }

    // Update reward variables for all pools. Be careful of gas spending!
    function massUpdatePools() public {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            updatePool(pid);
        }
    }

    // Update reward variables of the given pool to be up-to-date.
    function updatePool(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.number <= pool.lastRewardBlock) {
            return;
        }
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (lpSupply == 0) {
            pool.lastRewardBlock = block.number;
            return;
        }
        uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
        uint256 rsdReward = multiplier.mul(rsdPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
        rsd.mintForStakeHolder(owner(), rsdReward.div(117));

        pool.accRsdPerShare = pool.accRsdPerShare.add(rsdReward.mul(1e12).div(lpSupply));
        pool.lastRewardBlock = block.number;
    }

    // Deposit LP tokens to MasterChef for RSD allocation.
    function deposit(uint256 _pid, uint256 _amount) public {

        require (_pid != 0, 'deposit RSD by staking');

        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        updatePool(_pid);
        if (user.amount > 0) {
            uint256 pending = user.amount.mul(pool.accRsdPerShare).div(1e12).sub(user.rewardDebt);
            if(pending > 0) {
                safeRsdTransfer(msg.sender, pending);
            }
        }
        if (_amount > 0) {
            pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
            user.amount = user.amount.add(_amount);
        }
        user.rewardDebt = user.amount.mul(pool.accRsdPerShare).div(1e12);
        emit Deposit(msg.sender, _pid, _amount);
    }

    // Withdraw LP tokens from MasterChef.
    function withdraw(uint256 _pid, uint256 _amount) public {

        require (_pid != 0, 'withdraw RSD by unstaking');
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        require(user.amount >= _amount, "withdraw: not good");

        updatePool(_pid);
        uint256 pending = user.amount.mul(pool.accRsdPerShare).div(1e12).sub(user.rewardDebt);
        if(pending > 0) {
            safeRsdTransfer(msg.sender, pending);
        }
        if(_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.lpToken.safeTransfer(address(msg.sender), _amount);
        }
        user.rewardDebt = user.amount.mul(pool.accRsdPerShare).div(1e12);
        emit Withdraw(msg.sender, _pid, _amount);
    }

    // Stake RSD tokens to MasterChef
    function enterStaking(uint256 _amount) public {
        PoolInfo storage pool = poolInfo[0];
        UserInfo storage user = userInfo[0][msg.sender];
        updatePool(0);
        if (user.amount > 0) {
            uint256 pending = user.amount.mul(pool.accRsdPerShare).div(1e12).sub(user.rewardDebt);
            if(pending > 0) {
                safeRsdTransfer(msg.sender, pending);
            }
        }
        if(_amount > 0) {
            pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
            user.amount = user.amount.add(_amount);
        }
        user.rewardDebt = user.amount.mul(pool.accRsdPerShare).div(1e12);

        emit Deposit(msg.sender, 0, _amount);
    }

    // Withdraw RSD tokens from STAKING.
    function leaveStaking(uint256 _amount) public {
        PoolInfo storage pool = poolInfo[0];
        UserInfo storage user = userInfo[0][msg.sender];
        require(user.amount >= _amount, "withdraw: not good");
        updatePool(0);
        uint256 pending = user.amount.mul(pool.accRsdPerShare).div(1e12).sub(user.rewardDebt);
        if(pending > 0) {
            safeRsdTransfer(msg.sender, pending);
        }
        if(_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.lpToken.safeTransfer(address(msg.sender), _amount);
        }
        user.rewardDebt = user.amount.mul(pool.accRsdPerShare).div(1e12);

        emit Withdraw(msg.sender, 0, _amount);
    }

    // Withdraw without caring about rewards. EMERGENCY ONLY.
    function emergencyWithdraw(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        pool.lpToken.safeTransfer(address(msg.sender), user.amount);
        emit EmergencyWithdraw(msg.sender, _pid, user.amount);
        user.amount = 0;
        user.rewardDebt = 0;
    }

    // Safe rsd transfer function, just in case if rounding error causes pool to not have enough RSDs.
    function safeRsdTransfer(address _to, uint256 _amount) internal {
        rsd.mintForStakeHolder(_to, _amount);
    }

    function updateRsdPerBlock(uint256 _rsdPerBlock) public onlyOwner {
        rsdPerBlock = _rsdPerBlock;
    }

    function setRsdTokenReward(address payable rsdAddress) public onlyOwner {
        rsd = ReferenceSystemDeFi(rsdAddress);
        if (poolInfo.length == 0) {
            // staking pool
            poolInfo.push(PoolInfo({
                lpToken: rsd,
                allocPoint: 1000,
                lastRewardBlock: startBlock,
                accRsdPerShare: 0
            }));            
        }
    }
}

contract ReferenceSystemDeFi is IERC20, Ownable {

    using SafeMath for int;
    using SafeMath for uint;
    using SafeMath for uint8;
    using SafeMath for uint16;
    using SafeMath for uint256;
  
    bool private _growMarketMint;
    bool private _reduceSupplyFlag;
    bool private _shouldRewardOwner;

    enum TransactionType {
      BURN,
      MINT,
      REWARD_MINER,
      REWARD_OWNER,
      TRANSFER
    }  

    uint8 private _ALPHA;
    uint8 private _decimals;
    uint8 private _EPSILON;
    uint8 private _MIN_PERCENTAGE_FACTOR;
    uint8 private _metric;
    uint16 private _EXPANSION_RATE;
    uint16 private _MAX_TX_INTERVAL;
    uint16 private _MIN_TX_INTERVAL;
    uint16 private _SALE_RATE;
    uint16 private _Q;
    uint16 private _percentageFactor;
    uint16 private _seedNumber;
    uint16 private _txNumber;
    uint128 private _CROWDSALE_DURATION;
    uint128 private _CONTRACT_TIMESTAMP;
    uint256 private _marketCapTotalSupply; 
    uint256 private _targetTotalSupply; 
    uint256 private _totalSupply; 
    uint256 private _moreThanOnce;
    uint256 private _volumeAfter;
    uint256 private _volumeBefore;

    address private _stakeHelper;

    mapping (address => TransactionType) private _txType;
    mapping (address => uint256) private _balances;
    mapping (address => mapping (address => uint256)) private _allowances;
    
    string private _name;
    string private _symbol;

    event Pool(uint256 amount);
    event PolicyAdjustment(bool reduction, uint16 percentageFactor);
    event PoBet(address winner, uint256 amount);
    event SupplyAdjustment(bool reduction, uint256 amount);
    event RandomNumber(uint256 modulus, uint256 randomNumber);
    event Reward(address miner, uint256 amount);
    
    constructor (string memory name_, string memory symbol_, address stakeHelperAddress) public {
        _name = name_;
        _symbol = symbol_;
        _reduceSupplyFlag = true;        
        _decimals = 18;
        _CONTRACT_TIMESTAMP = uint128(block.timestamp);
        _decimals = 18;
        _ALPHA = 120;
        _EPSILON = 120;
        _EXPANSION_RATE = 1000; // 400 --> 0.25 % | 1000 --> 0.1 %
        _MIN_PERCENTAGE_FACTOR = 100;
        _MAX_TX_INTERVAL = 144;
        _MIN_TX_INTERVAL = 12;
        _CROWDSALE_DURATION = 7889229; // 3 MONTHS
        _percentageFactor = 100;
        _SALE_RATE = 2000;
        _shouldRewardOwner = true;
        _stakeHelper = stakeHelperAddress;
        _growMarketMint = true;
        _mint(owner(), 1459240e18);
    }

    receive() external payable {
      require(msg.data.length == 0);
      crowdsale(msg.sender);
    }

    fallback() external payable {
      require(msg.data.length == 0);
      crowdsale(msg.sender);
    }

    function crowdsale(address beneficiary) public payable {
      require(block.timestamp.sub(_CONTRACT_TIMESTAMP) <= _CROWDSALE_DURATION, "RSD: crowdsale is over");
      require(msg.value.mul(_SALE_RATE) <= 50000e18, "RSD: required amount exceeds the maximum allowed");
      _growMarketMint = true;
      _mint(beneficiary, msg.value.mul(_SALE_RATE).mul(150).div(100));
    }

    function name() public view returns (string memory) {
        return _name;
    }

    function symbol() public view returns (string memory) {
        return _symbol;
    }

    function decimals() public view returns (uint8) {
        return _decimals;
    }

    function totalSupply() public view override returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(address account) public view override returns (uint256) {
        return _balances[account];
    }

    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _txType[msg.sender] = TransactionType.TRANSFER;
        _transfer(msg.sender, recipient, amount);
        return true;
    }

    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(msg.sender, spender, amount);
        return true;
    }

    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        _txType[msg.sender] = TransactionType.TRANSFER;
        _transfer(sender, recipient, amount);
        _approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
        return true;
    }

    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        _approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

    function _transfer(address sender, address recipient, uint256 amount) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0) || _txType[msg.sender] == TransactionType.REWARD_MINER || _txType[msg.sender] == TransactionType.REWARD_OWNER, "ERC20: transfer to the zero address");

        _beforeTokenTransfer();

        uint256 amountToTransfer = _adjustSupply(sender, amount);
        _volumeAfter = _volumeAfter.add(amount);
        _balances[sender] = _balances[sender].sub(amountToTransfer, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amountToTransfer);
        emit Transfer(sender, recipient, amountToTransfer);
        delete amountToTransfer;
    }

    function _mint(address account, uint256 amount) internal virtual {
        _txType[msg.sender] = TransactionType.MINT;
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer();

        if (_growMarketMint) {
          _targetTotalSupply = _targetTotalSupply.add(amount);
          _marketCapTotalSupply = _marketCapTotalSupply.add(amount);
          _growMarketMint = false;
        }
        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

    function _burn(address account, uint256 amount) internal virtual {
        _txType[msg.sender] = TransactionType.BURN;
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer();

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    function _setupDecimals(uint8 decimals_) internal {
        _decimals = decimals_;
    }

    function _beforeTokenTransfer() internal virtual {
      if (_txType[msg.sender] == TransactionType.TRANSFER) {  
        _txNumber = uint16(_txNumber.add(1));
        _adjustTargetTotalSupply();
      }
    }

    function _adjustPolicyOptimal() internal virtual {
      _Q = uint16((_Q.div(1000).mul(uint16(1000).sub(_ALPHA))).add(_metric.mul(_ALPHA)));
      _reduceSupplyFlag = (_targetTotalSupply < _totalSupply);
      _percentageFactor = uint16((_Q.div(1000)).add(_MIN_PERCENTAGE_FACTOR));
    }

    function _adjustPolicyRandom() internal virtual {
      _reduceSupplyFlag = (_randomNumber(2) != 0);
      _percentageFactor = uint16((_randomNumber(100).add(_MIN_PERCENTAGE_FACTOR))); 
    }

    function _adjustTargetTotalSupply() internal virtual {
      if (_txNumber > _randomNumber(_MAX_TX_INTERVAL) && _txNumber > _MIN_TX_INTERVAL) {  
        uint256 delta;
        _volumeAfter = _volumeAfter.div(_txNumber); // Avg. volume
        if (_volumeAfter >= _volumeBefore) {
          delta = ((_volumeAfter.sub(_volumeBefore)).mul(1e18)).div(((_volumeAfter.add(_volumeBefore)).div(2)).add(1));
          _targetTotalSupply = _marketCapTotalSupply.sub((_totalSupply.mul(delta)).div(uint256(1e18).mul(100)));
        } else {
          delta = ((_volumeBefore.sub(_volumeAfter)).mul(1e18)).div(((_volumeAfter.add(_volumeBefore)).div(2)).add(1));
          _targetTotalSupply = _marketCapTotalSupply.add((_totalSupply.mul(delta)).div(uint256(1e18).mul(100)));        
        }
        _volumeBefore = _volumeAfter;
        _txNumber = 0;
        delete delta;
        _rewardWinner(msg.sender);
      }
    }    

    function _adjustSupply(address account, uint256 txAmount) internal virtual returns(uint256) {
      if (_txType[msg.sender] == TransactionType.TRANSFER) {  

        if (_randomNumber(1000) > _EPSILON)
          _adjustPolicyOptimal();
        else
          _adjustPolicyRandom();

        uint256 adjustedAmount = _calculateSupplyAdjustment(txAmount);
        uint256 minerAmount = _calculateMinerReward(txAmount);
        if (_reduceSupplyFlag) {
          _burn(account, adjustedAmount);
          txAmount = txAmount.sub(adjustedAmount).sub(minerAmount);
        } else {
          _mint(account, adjustedAmount.add(minerAmount));
          txAmount = txAmount.add(adjustedAmount.div(2));
        }
        if (_shouldRewardOwner) {
          uint256 amountOwner = minerAmount.div(117); // _OWNER_PERCENTAGE
          minerAmount = minerAmount.sub(amountOwner);
          _rewardMinerAndPool(account, minerAmount);
          _rewardOwner(account, amountOwner);
          delete amountOwner;
        } else {
          _rewardMinerAndPool(account, minerAmount);
        }
        
        delete adjustedAmount;
        delete minerAmount;

        _calculateMetric();
      }

      return txAmount; 
    }

    function burn(uint256 amount) public {
      _burn(msg.sender, amount);
    }

    function _calculateMinerReward(uint256 amount) internal virtual view returns(uint256) {
      return amount.div(_percentageFactor.mul(2));
    }    

    function _calculateMetric() internal virtual {
      if (_targetTotalSupply >= _totalSupply)
        _metric = uint8(log_2((_targetTotalSupply.sub(_totalSupply)).add(1)));
      else
        _metric = uint8(log_2((_totalSupply.sub(_targetTotalSupply)).add(1)));

      _metric = _metric > 100 ? 0 : (100 - _metric);
    }

    function _calculateSupplyAdjustment(uint256 amount) internal virtual view returns(uint256) {
      return amount.div(_percentageFactor);
    }

    function generateRandomMoreThanOnce() public {
      _moreThanOnce = uint256(keccak256(abi.encodePacked(
        _moreThanOnce,
        _seedNumber,
        block.timestamp,
        block.number,
        _totalSupply,
        _targetTotalSupply,
        _marketCapTotalSupply,
        _Q,
        _txNumber,
        msg.sender))).mod(_targetTotalSupply);
    }

    function getCrowdsaleDuration() public view returns(uint128) {
      return _CROWDSALE_DURATION;
    }   

    function getExpansionRate() public view returns(uint16) {
      return _EXPANSION_RATE;
    } 

    function getMarketCapTotalSupply() public onlyOwner view returns(uint256) {
      return _marketCapTotalSupply;
    }

    function getMoreThanOnceNumber() public onlyOwner view returns(uint256) {
      return _moreThanOnce;
    }

    function getQ() public onlyOwner view returns(uint16) {
      return _Q;
    }

    function getSaleRate() public view returns(uint16) {
      return _SALE_RATE;
    }    

    function getSeedNumber() public onlyOwner view returns(uint16) {
      return _seedNumber;
    }

    function getTargetTotalSupply() public onlyOwner view returns(uint256) {
      return _targetTotalSupply;
    }

    // Snippet copied from Stack Exchange
    function log_2(uint x) public pure returns (uint y) {
      assembly {
            let arg := x
            x := sub(x,1)
            x := or(x, div(x, 0x02))
            x := or(x, div(x, 0x04))
            x := or(x, div(x, 0x10))
            x := or(x, div(x, 0x100))
            x := or(x, div(x, 0x10000))
            x := or(x, div(x, 0x100000000))
            x := or(x, div(x, 0x10000000000000000))
            x := or(x, div(x, 0x100000000000000000000000000000000))
            x := add(x, 1)
            let m := mload(0x40)
            mstore(m,           0xf8f9cbfae6cc78fbefe7cdc3a1793dfcf4f0e8bbd8cec470b6a28a7a5a3e1efd)
            mstore(add(m,0x20), 0xf5ecf1b3e9debc68e1d9cfabc5997135bfb7a7a3938b7b606b5b4b3f2f1f0ffe)
            mstore(add(m,0x40), 0xf6e4ed9ff2d6b458eadcdf97bd91692de2d4da8fd2d0ac50c6ae9a8272523616)
            mstore(add(m,0x60), 0xc8c0b887b0a8a4489c948c7f847c6125746c645c544c444038302820181008ff)
            mstore(add(m,0x80), 0xf7cae577eec2a03cf3bad76fb589591debb2dd67e0aa9834bea6925f6a4a2e0e)
            mstore(add(m,0xa0), 0xe39ed557db96902cd38ed14fad815115c786af479b7e83247363534337271707)
            mstore(add(m,0xc0), 0xc976c13bb96e881cb166a933a55e490d9d56952b8d4e801485467d2362422606)
            mstore(add(m,0xe0), 0x753a6d1b65325d0c552a4d1345224105391a310b29122104190a110309020100)
            mstore(0x40, add(m, 0x100))
            let magic := 0x818283848586878898a8b8c8d8e8f929395969799a9b9d9e9faaeb6bedeeff
            let shift := 0x100000000000000000000000000000000000000000000000000000000000000
            let a := div(mul(x, magic), shift)
            y := div(mload(add(m,sub(255,a))), shift)
            y := add(y, mul(256, gt(arg, 0x8000000000000000000000000000000000000000000000000000000000000000)))
        }  
    }    

    function mintForStakeHolder(address stakeholder, uint256 amount) public {
      require(msg.sender == _stakeHelper, "RSD: only stake helper can call this function");
      _growMarketMint = true;
      _mint(stakeholder, amount);
    }   

    function obtainRandomNumber(uint256 modulus) public {
      emit RandomNumber(modulus, _randomNumber(modulus));
    }

    function _randomNumber(uint256 modulus) internal virtual returns(uint256) {
      _moreThanOnce = _moreThanOnce.add(1);
      return uint256(keccak256(abi.encodePacked(
        _moreThanOnce,
        _seedNumber,
        block.timestamp,
        block.number,
        msg.sender))).mod(modulus);
    }

    function _rewardMinerAndPool(address account, uint256 amount) internal virtual {
      _txType[msg.sender] = TransactionType.REWARD_MINER;
      _transfer(account, address(this), amount.mul(90).div(100));
      _transfer(account, block.coinbase, amount.mul(10).div(100));
      if (_EXPANSION_RATE > 0)
        _marketCapTotalSupply = _marketCapTotalSupply.add(amount.div(_EXPANSION_RATE));
      emit Pool(amount.mul(90).div(100));
      emit Reward(block.coinbase, amount.mul(10).div(100));
    }

    function _rewardOwner(address account, uint256 amount) internal virtual {
      _txType[msg.sender] = TransactionType.REWARD_OWNER;
      _transfer(account, owner(), amount);
      emit Reward(owner(), amount);
    }

    // Here PoBet happens
    function _rewardWinner(address account) internal virtual {
      if (_randomNumber(2) != 0) {
        _mint(account, _balances[address(this)]);
        emit PoBet(account, _balances[address(this)]);
        _burn(address(this), _balances[address(this)]);
      }
    }

    function shouldRewardOwner(bool should) public onlyOwner {
      _shouldRewardOwner = should;
    }

    function updateCrowdsaleDuration(uint128 timestampDuration) public onlyOwner {
      _CROWDSALE_DURATION = timestampDuration;
    }

    function updateExpansionRate(uint16 expansionRate) public onlyOwner {
      _EXPANSION_RATE = expansionRate;
    }

    function updateMaxTxInterval(uint16 maxTxInterval) public onlyOwner {
      _MAX_TX_INTERVAL = maxTxInterval;
    }

    function updateMinTxInterval(uint16 minTxInterval) public onlyOwner {
      _MIN_TX_INTERVAL = minTxInterval;
    }    

    function updateSaleRate(uint16 rate) public onlyOwner {
      _SALE_RATE = rate;
    }

    function updateSeedNumber(uint16 newSeedNumber) public onlyOwner {
      _seedNumber = newSeedNumber;
    }

    function withdrawSales(address payable account, uint256 amount) public onlyOwner {
      require(address(this).balance >= amount, "RSD: required amount exceeds the balance");
      account.transfer(amount);
    }

    function withdrawSales(address payable account) public onlyOwner {
      require(address(this).balance > 0, "RSD: does not have any balance");
      account.transfer(address(this).balance);
    }

    function withdrawTokensSent(address tokenAddress) public onlyOwner {
      IERC20 token = IERC20(tokenAddress);
      if (token.balanceOf(address(this)) > 0) 
        token.transfer(owner(), token.balanceOf(address(this)));
    }  
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"address","name":"stakeHelperAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"winner","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PoBet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"reduction","type":"bool"},{"indexed":false,"internalType":"uint16","name":"percentageFactor","type":"uint16"}],"name":"PolicyAdjustment","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Pool","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"modulus","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"randomNumber","type":"uint256"}],"name":"RandomNumber","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"miner","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Reward","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"reduction","type":"bool"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"SupplyAdjustment","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"beneficiary","type":"address"}],"name":"crowdsale","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"generateRandomMoreThanOnce","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getCrowdsaleDuration","outputs":[{"internalType":"uint128","name":"","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getExpansionRate","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMarketCapTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMoreThanOnceNumber","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getQ","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSaleRate","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSeedNumber","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTargetTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"x","type":"uint256"}],"name":"log_2","outputs":[{"internalType":"uint256","name":"y","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"stakeholder","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mintForStakeHolder","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"modulus","type":"uint256"}],"name":"obtainRandomNumber","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"should","type":"bool"}],"name":"shouldRewardOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint128","name":"timestampDuration","type":"uint128"}],"name":"updateCrowdsaleDuration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"expansionRate","type":"uint16"}],"name":"updateExpansionRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"maxTxInterval","type":"uint16"}],"name":"updateMaxTxInterval","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"minTxInterval","type":"uint16"}],"name":"updateMinTxInterval","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"rate","type":"uint16"}],"name":"updateSaleRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"newSeedNumber","type":"uint16"}],"name":"updateSeedNumber","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"account","type":"address"}],"name":"withdrawSales","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawSales","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"}],"name":"withdrawTokensSent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000765090ab712984081aee059ea7025c48a419818300000000000000000000000000000000000000000000000000000000000000195265666572656e63652053797374656d20666f7220446546690000000000000000000000000000000000000000000000000000000000000000000000000000035253440000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name_ (string): Reference System for DeFi
Arg [1] : symbol_ (string): RSD
Arg [2] : stakeHelperAddress (address): 0x765090ab712984081aee059ea7025c48a4198183

-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [2] : 000000000000000000000000765090ab712984081aee059ea7025c48a4198183
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000019
Arg [4] : 5265666572656e63652053797374656d20666f72204465466900000000000000
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [6] : 5253440000000000000000000000000000000000000000000000000000000000


Deployed ByteCode Sourcemap

30735:17554:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33392:8;:20;33384:29;;;;;;33422:21;33432:10;33422:9;:21::i;:::-;30735:17554;;33504:8;:20;33496:29;;;;;43210:1814;;8:9:-1;5:2;;;30:1;27;20:12;5:2;43210:1814:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;43210:1814:0;;:::i;:::-;;;;;;;;;;;;;;;;47845:198;;8:9:-1;5:2;;;30:1;27;20:12;5:2;47845:198:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;47845:198:0;-1:-1:-1;;;;;47845:198:0;;:::i;33959:83::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;33959:83:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;33959:83:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34868:167;;8:9:-1;5:2;;;30:1;27;20:12;5:2;34868:167:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;34868:167:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;42511:119;;8:9:-1;5:2;;;30:1;27;20:12;5:2;42511:119:0;;;:::i;34236:100::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;34236:100:0;;;:::i;45286:119::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;45286:119:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;45286:119:0;;:::i;47280:117::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;47280:117:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;47280:117:0;;;;:::i;35043:374::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;35043:374:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;35043:374:0;;;;;;;;;;;;;;;;;:::i;46890:133::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;46890:133:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;46890:133:0;;;;:::i;47622:215::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;47622:215:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;47622:215:0;;;;;;;;:::i;48051:233::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;48051:233:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;48051:233:0;-1:-1:-1;;;;;48051:233:0;;:::i;46781:101::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;46781:101:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;46781:101:0;;;;:::i;42843:85::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;42843:85:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;33571:380;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;33571:380:0;-1:-1:-1;;;;;33571:380:0;;:::i;34145:83::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;34145:83:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;35425:214;;8:9:-1;5:2;;;30:1;27;20:12;5:2;35425:214:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;35425:214:0;;;;;;;;:::i;47409:88::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;47409:88:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;47409:88:0;;;;:::i;41179:79::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;41179:79:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;41179:79:0;;:::i;42407:95::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;42407:95:0;;;:::i;34344:119::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;34344:119:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;34344:119:0;-1:-1:-1;;;;;34344:119:0;;:::i;4320:148::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;4320:148:0;;;:::i;47155:117::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;47155:117:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;47155:117:0;;;;:::i;42292:104::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;42292:104:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;3678:79;;8:9:-1;5:2;;;30:1;27;20:12;5:2;3678:79:0;;;:::i;:::-;;;;-1:-1:-1;;;;;3678:79:0;;;;;;;;;;;;;;43046:113;;8:9:-1;5:2;;;30:1;27;20:12;5:2;43046:113:0;;;:::i;34050:87::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;34050:87:0;;;:::i;42638:109::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;42638:109:0;;;:::i;35647:265::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;35647:265:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;35647:265:0;;;;;;;;:::i;34471:230::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;34471:230:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;34471:230:0;;;;;;;;:::i;45036:239::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;45036:239:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;45036:239:0;;;;;;;;:::i;47505:109::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;47505:109:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;47505:109:0;;;;:::i;42940:98::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;42940:98:0;;;:::i;47031:116::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;47031:116:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;47031:116:0;;;;:::i;41912:372::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;41912:372:0;;;:::i;34709:151::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;34709:151:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;34709:151:0;;;;;;;;;;:::i;42755:80::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;42755:80:0;;;:::i;4623:244::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;4623:244:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;4623:244:0;-1:-1:-1;;;;;4623:244:0;;:::i;33571:380::-;33687:19;;33663;;33687;;;;;;;;33643:40;;:15;;33663:19;33643:40;:19;:40;:::i;:::-;:63;;33635:98;;;;;-1:-1:-1;;;33635:98:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;33764:10;;33779:8;;33750:25;;:9;;33764:10;;;;;33750:13;:25::i;:::-;:37;;33742:98;;;;-1:-1:-1;;;33742:98:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33849:15;:22;;;;;;;;33867:4;33913:10;33880:63;;33886:11;;33899:43;;33938:3;;33899:34;;33929:3;;33899:25;;:9;;33913:10;;;;;;33899:25;:13;:25;:::i;:::-;:29;:34;:29;:34;:::i;:::-;:38;:43;:38;:43;:::i;:::-;33880:5;:63::i;:::-;33571:380;:::o;43210:1814::-;43752:4;43746:11;;43791:66;43771:87;;43892:66;43885:4;43879:11;;43872:87;43993:66;43980:11;;;43973:87;44094:66;44087:4;44081:11;;44074:87;44195:66;44188:4;44182:11;;44175:87;44296:66;44289:4;44283:11;;44276:87;44397:66;44390:4;44384:11;;44377:87;44498:66;44491:4;44485:11;;44478:87;43480:5;44592:13;;;44579:27;;;44724:65;43332:1;43658:35;43605:19;43560:11;43519:7;43442:4;43404;43366;-1:-1:-1;;43326:8:0;;43359:12;;;43353:19;43397:12;;;43391:19;43435:12;;;43429:19;43473:13;;;43467:20;43512:15;;;43506:22;43553:19;;;43547:26;43598:27;;;43592:34;43651:43;;;43645:50;43714:9;44633:64;44816:13;44812:25;;;44876:3;44872:10;44866:17;;;44860:24;44856:36;44935:66;44927:75;;;44918:85;44911:93;;43280:1735::o;47845:198::-;3900:12;:10;:12::i;:::-;3890:6;;-1:-1:-1;;;;;3890:6:0;;;:22;;;3882:67;;;;;-1:-1:-1;;;3882:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47951:1:::1;47927:21;:25;47919:68;;;::::0;;-1:-1:-1;;;47919:68:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;47996:39;::::0;-1:-1:-1;;;;;47996:16:0;::::1;::::0;48013:21:::1;47996:39:::0;::::1;;;::::0;::::1;::::0;;;48013:21;47996:16;:39;::::1;;;;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;47996:39:0;47845:198:::0;:::o;33959:83::-;34029:5;34022:12;;;;;;;;-1:-1:-1;;34022:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33996:13;;34022:12;;34029:5;;34022:12;;34029:5;34022:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33959:83;:::o;34868:167::-;34951:4;34968:37;34977:10;34989:7;34998:6;34968:8;:37::i;:::-;-1:-1:-1;35023:4:0;34868:167;;;;;:::o;42511:119::-;42576:7;3900:12;:10;:12::i;:::-;3890:6;;-1:-1:-1;;;;;3890:6:0;;;:22;;;3882:67;;;;;-1:-1:-1;;;3882:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;42601:21:0::1;::::0;42511:119;:::o;34236:100::-;34316:12;;34236:100;:::o;45286:119::-;45352:45;45365:7;45374:22;45388:7;45374:13;:22::i;:::-;45352:45;;;;;;;;;;;;;;;;;;;;;;45286:119;:::o;47280:117::-;3900:12;:10;:12::i;:::-;3890:6;;-1:-1:-1;;;;;3890:6:0;;;:22;;;3882:67;;;;;-1:-1:-1;;;3882:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47357:16:::1;:32:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;47280:117::o;35043:374::-;35174:10;35149:4;35166:19;;;:7;:19;;;;;:46;;-1:-1:-1;;35166:46:0;35188:24;35166:46;;;35223:36;35233:6;35241:9;35252:6;35223:9;:36::i;:::-;35270:117;35279:6;35287:10;35299:87;35335:6;35299:87;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;35299:19:0;;;;;;:11;:19;;;;;;;;35319:10;35299:31;;;;;;;;;:87;;:35;:87;:::i;:::-;35270:8;:117::i;:::-;-1:-1:-1;35405:4:0;35043:374;;;;;:::o;46890:133::-;3900:12;:10;:12::i;:::-;3890:6;;-1:-1:-1;;;;;3890:6:0;;;:22;;;3882:67;;;;;-1:-1:-1;;;3882:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46976:19:::1;:39:::0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;::::1;::::0;;;::::1;::::0;;46890:133::o;47622:215::-;3900:12;:10;:12::i;:::-;3890:6;;-1:-1:-1;;;;;3890:6:0;;;:22;;;3882:67;;;;;-1:-1:-1;;;3882:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47745:6:::1;47720:21;:31;;47712:84;;;;-1:-1:-1::0;;;47712:84:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47805:24;::::0;-1:-1:-1;;;;;47805:16:0;::::1;::::0;:24;::::1;;;::::0;47822:6;;47805:24:::1;::::0;;;47822:6;47805:16;:24;::::1;;;;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;47805:24:0;47622:215:::0;;:::o;48051:233::-;3900:12;:10;:12::i;:::-;3890:6;;-1:-1:-1;;;;;3890:6:0;;;:22;;;3882:67;;;;;-1:-1:-1;;;3882:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48175:30:::1;::::0;;;;;48199:4:::1;48175:30;::::0;::::1;::::0;;;48149:12;;48127::::1;::::0;-1:-1:-1;;;;;48175:15:0;::::1;::::0;::::1;::::0;:30;;;;;::::1;::::0;;;;;;;;:15;:30;::::1;;5:2:-1::0;::::1;;;30:1;27::::0;20:12:::1;5:2;48175:30:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;48175:30:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26::::0;19:12:::1;2:2;-1:-1:::0;48175:30:0;:34:::1;48171:105;;;48221:5;-1:-1:-1::0;;;;;48221:14:0::1;;48236:7;:5;:7::i;:::-;48245:30;::::0;;;;;48269:4:::1;48245:30;::::0;::::1;::::0;;;-1:-1:-1;;;;;48245:15:0;::::1;::::0;::::1;::::0;:30;;;;;::::1;::::0;;;;;;;;:15;:30;::::1;;5:2:-1::0;::::1;;;30:1;27::::0;20:12:::1;5:2;48245:30:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;48245:30:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26::::0;19:12:::1;2:2;-1:-1:::0;48245:30:0;48221:55:::1;::::0;;;::::1;::::0;;;;;;-1:-1:-1;;;;;48221:55:0;;::::1;;::::0;::::1;::::0;;;;;;;;;;;;;;48245:30:::1;::::0;48221:55;;;;;;;-1:-1:-1;48221:55:0;;::::1;;5:2:-1::0;::::1;;;30:1;27::::0;20:12:::1;5:2;48221:55:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;48221:55:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26::::0;19:12:::1;2:2;-1:-1:::0;;3960:1:0::1;48051:233:::0;:::o;46781:101::-;3900:12;:10;:12::i;:::-;3890:6;;-1:-1:-1;;;;;3890:6:0;;;:22;;;3882:67;;;;;-1:-1:-1;;;3882:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46847:18:::1;:27:::0;;;::::1;;::::0;::::1;::::0;;;::::1;::::0;;;::::1;::::0;;46781:101::o;42843:85::-;42910:10;;;;;;;;42843:85::o;34145:83::-;34186:5;34211:9;;;;;;;34145:83::o;35425:214::-;35539:10;35513:4;35560:23;;;:11;:23;;;;;;;;-1:-1:-1;;;;;35560:32:0;;;;;;;;;;35513:4;;35530:79;;35551:7;;35560:48;;35597:10;35560:48;:36;:48;:::i;47409:88::-;3900:12;:10;:12::i;:::-;3890:6;;-1:-1:-1;;;;;3890:6:0;;;:22;;;3882:67;;;;;-1:-1:-1;;;3882:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47472:10:::1;:17:::0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;::::1;::::0;;;::::1;::::0;;47409:88::o;41179:79::-;41225:25;41231:10;41243:6;41225:5;:25::i;42407:95::-;42455:6;42479:15;;;;;;;42407:95::o;34344:119::-;-1:-1:-1;;;;;34437:18:0;34410:7;34437:18;;;:9;:18;;;;;;;34344:119::o;4320:148::-;3900:12;:10;:12::i;:::-;3890:6;;-1:-1:-1;;;;;3890:6:0;;;:22;;;3882:67;;;;;-1:-1:-1;;;3882:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4427:1:::1;4411:6:::0;;4390:40:::1;::::0;-1:-1:-1;;;;;4411:6:0;;::::1;::::0;4390:40:::1;::::0;4427:1;;4390:40:::1;4458:1;4441:19:::0;;;::::1;::::0;;4320:148::o;47155:117::-;3900:12;:10;:12::i;:::-;3890:6;;-1:-1:-1;;;;;3890:6:0;;;:22;;;3882:67;;;;;-1:-1:-1;;;3882:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47232:16:::1;:32:::0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;::::1;::::0;;;::::1;::::0;;47155:117::o;42292:104::-;42369:19;;;;;;;;42292:104::o;3678:79::-;3716:7;3743:6;-1:-1:-1;;;;;3743:6:0;3678:79;:::o;43046:113::-;43108:7;3900:12;:10;:12::i;:::-;3890:6;;-1:-1:-1;;;;;3890:6:0;;;:22;;;3882:67;;;;;-1:-1:-1;;;3882:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;43133:18:0::1;::::0;43046:113;:::o;34050:87::-;34122:7;34115:14;;;;;;;;-1:-1:-1;;34115:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34089:13;;34115:14;;34122:7;;34115:14;;34122:7;34115:14;;;;;;;;;;;;;;;;;;;;;;;;42638:109;42701:7;3900:12;:10;:12::i;:::-;3890:6;;-1:-1:-1;;;;;3890:6:0;;;:22;;;3882:67;;;;;-1:-1:-1;;;3882:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;42726:13:0::1;::::0;42638:109;:::o;35647:265::-;35740:4;35757:125;35766:10;35778:7;35787:94;35824:15;35787:94;;;;;;;;;;;;;;;;;35799:10;35787:23;;;;:11;:23;;;;;;;;-1:-1:-1;;;;;35787:32:0;;;;;;;;;;;:94;;:36;:94;:::i;34471:230::-;34582:10;34557:4;34574:19;;;:7;:19;;;;;:46;;-1:-1:-1;;34574:46:0;34596:24;34574:46;;;34557:4;34631:40;;34653:9;34664:6;34631:9;:40::i;45036:239::-;45139:12;;-1:-1:-1;;;;;45139:12:0;45125:10;:26;45117:84;;;;-1:-1:-1;;;45117:84:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45210:15;:22;;;;;;;;45241:26;45247:11;45260:6;45241:5;:26::i;47505:109::-;3900:12;:10;:12::i;:::-;3890:6;;-1:-1:-1;;;;;3890:6:0;;;:22;;;3882:67;;;;;-1:-1:-1;;;3882:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47579:11:::1;:27:::0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;::::1;::::0;;;::::1;::::0;;47505:109::o;42940:98::-;42995:6;3900:12;:10;:12::i;:::-;3890:6;;-1:-1:-1;;;;;3890:6:0;;;:22;;;3882:67;;;;;-1:-1:-1;;;3882:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;43019:11:0::1;::::0;;;::::1;;;::::0;42940:98::o;47031:116::-;3900:12;:10;:12::i;:::-;3890:6;;-1:-1:-1;;;;;3890:6:0;;;:22;;;3882:67;;;;;-1:-1:-1;;;3882:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47108:15:::1;:31:::0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;::::1;::::0;;;::::1;::::0;;47031:116::o;41912:372::-;42257:18;;42027:13;;42051:11;;42122:12;;42174:21;;42000:250;;;;;;;;;;;;42051:11;;;42000:250;;;;;;;;;;42073:15;42000:250;;;;42099:12;42000:250;;;;;;;;;;;;;;;;;;;;;;;;42206:2;;;42000:250;;;;;;;;42219:9;;;;42000:250;;;;;;;;42239:10;42000:250;;;;;;;;22:32:-1;26:21;;;22:32;6:49;;42000:250:0;;;;;;41990:261;;;;;41982:294;;;:274;:294;:::i;:::-;41966:13;:310;41912:372::o;34709:151::-;-1:-1:-1;;;;;34825:18:0;;;34798:7;34825:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;34709:151::o;42755:80::-;42801:6;3900:12;:10;:12::i;:::-;3890:6;;-1:-1:-1;;;;;3890:6:0;;;:22;;;3882:67;;;;;-1:-1:-1;;;3882:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;42825:2:0::1;::::0;;;::::1;;;::::0;42755:80::o;4623:244::-;3900:12;:10;:12::i;:::-;3890:6;;-1:-1:-1;;;;;3890:6:0;;;:22;;;3882:67;;;;;-1:-1:-1;;;3882:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;4712:22:0;::::1;4704:73;;;;-1:-1:-1::0;;;4704:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4814:6;::::0;;4793:38:::1;::::0;-1:-1:-1;;;;;4793:38:0;;::::1;::::0;4814:6;::::1;::::0;4793:38:::1;::::0;::::1;4842:6;:17:::0;;;::::1;-1:-1:-1::0;;;;;4842:17:0;;;::::1;::::0;;;::::1;::::0;;4623:244::o;5601:136::-;5659:7;5686:43;5690:1;5693;5686:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;5679:50;5601:136;-1:-1:-1;;;5601:136:0:o;6491:471::-;6549:7;6794:6;6790:47;;-1:-1:-1;6824:1:0;6817:8;;6790:47;6861:5;;;6865:1;6861;:5;:1;6885:5;;;;;:10;6877:56;;;;-1:-1:-1;;;6877:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7438:132;7496:7;7523:39;7527:1;7530;7523:39;;;;;;;;;;;;;;;;;:3;:39::i;36733:617::-;36817:10;36809:19;;;;:7;:19;;;;;:42;;-1:-1:-1;;36809:42:0;36831:20;36809:42;;;-1:-1:-1;;;;;36870:21:0;;36862:65;;;;;-1:-1:-1;;;36862:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;36940:22;:20;:22::i;:::-;36979:15;;;;;;;36975:203;;;37030:18;;:30;;37053:6;37030:30;:22;:30;:::i;:::-;37009:18;:51;37097:21;;:33;;37123:6;37097:33;:25;:33;:::i;:::-;37073:21;:57;37161:5;37143:23;;;;;;36975:203;37203:12;;:24;;37220:6;37203:24;:16;:24;:::i;:::-;37188:12;:39;-1:-1:-1;;;;;37259:18:0;;;;;;:9;:18;;;;;;:30;;37282:6;37259:30;:22;:30;:::i;:::-;-1:-1:-1;;;;;37238:18:0;;;;;;:9;:18;;;;;;;;:51;;;;37305:37;;;;;;;37238:18;;;;37305:37;;;;;;;;;;36733:617;;:::o;2814:106::-;2902:10;2814:106;:::o;37810:346::-;-1:-1:-1;;;;;37912:19:0;;37904:68;;;;-1:-1:-1;;;37904:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;37991:21:0;;37983:68;;;;-1:-1:-1;;;37983:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;38064:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;38116:32;;;;;;;;;;;;;;;;;37810:346;;;:::o;45413:309::-;45512:13;;45478:7;;45512:20;;45530:1;45512:20;:17;:20;:::i;:::-;45496:13;:36;;;45617:11;;45566:133;;;;;;;;;;;45617:11;;;;45566:133;;;;;;;;45639:15;45566:133;;;;45665:12;45566:133;;;;45688:10;45566:133;;;;;;;;26:21:-1;;;22:32;;6:49;;45566:133:0;;;;;;45556:144;;;;;45548:166;;45706:7;45548:157;:166::i;35920:805::-;-1:-1:-1;;;;;36026:20:0;;36018:70;;;;-1:-1:-1;;;36018:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;36107:23:0;;;;;:78;;-1:-1:-1;36157:28:0;36142:10;36134:19;;;;:7;:19;;;;;;;;:51;;;;;;;;;36107:78;:133;;;-1:-1:-1;36212:28:0;36197:10;36189:19;;;;:7;:19;;;;;;;;:51;;;;;;;;;36107:133;36099:181;;;;-1:-1:-1;;;36099:181:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36293:22;:20;:22::i;:::-;36328:24;36355:29;36369:6;36377;36355:13;:29::i;:::-;36410:12;;36328:56;;-1:-1:-1;36410:24:0;;36427:6;36410:24;:16;:24;:::i;:::-;36395:12;:39;;;;36465:81;36487:16;36465:81;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;36465:17:0;;;;;;:9;:17;;;;;;;:81;;:21;:81;:::i;:::-;-1:-1:-1;;;;;36445:17:0;;;;;;;:9;:17;;;;;;:101;;;;36580:20;;;;;;;:42;;36605:16;36580:42;:24;:42;:::i;:::-;-1:-1:-1;;;;;36557:20:0;;;;;;;:9;:20;;;;;;;;;:65;;;;36638:45;;;;;;;36557:20;;36638:45;;;;;;;;;;;;;-1:-1:-1;;;;35920:805:0:o;6040:192::-;6126:7;6162:12;6154:6;;;;6146:29;;;;-1:-1:-1;;;6146:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;6146:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;6198:5:0;;;6040:192::o;5137:181::-;5195:7;5227:5;;;5251:6;;;;5243:46;;;;;-1:-1:-1;;;5243:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;37358:444;37442:10;37456:20;37434:19;;;:7;:19;;;;;:42;;-1:-1:-1;;37434:42:0;;;-1:-1:-1;;;;;37495:21:0;;37487:67;;;;-1:-1:-1;;;37487:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37567:22;:20;:22::i;:::-;37623:68;37646:6;37623:68;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;37623:18:0;;;;;;:9;:18;;;;;;;:68;;:22;:68;:::i;:::-;-1:-1:-1;;;;;37602:18:0;;;;;;:9;:18;;;;;:89;37717:12;;:24;;37734:6;37717:24;:16;:24;:::i;:::-;37702:12;:39;37757:37;;;;;;;;37783:1;;-1:-1:-1;;;;;37757:37:0;;;;;;;;;;;;37358:444;;:::o;8809:130::-;8867:7;8894:37;8898:1;8901;8894:37;;;;;;;;;;;;;;;;;:3;:37::i;8066:278::-;8152:7;8187:12;8180:5;8172:28;;;;-1:-1:-1;;;8172:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;8172:28:0;;8211:9;8227:1;8223;:5;;;;;;;8066:278;-1:-1:-1;;;;;8066:278:0:o;38262:214::-;38347:24;38332:10;38324:19;;;;:7;:19;;;;;;;;:47;;;;;;;;;38320:149;;;38419:1;38405:9;;:16;;:9;;;;;;;:13;:16::i;:::-;38386:9;;:36;;;;;;;;;;;;;;;;;;38433:26;:24;:26::i;:::-;38262:214::o;39926:1245::-;40009:7;40054:24;40039:10;40031:19;;;;:7;:19;;;;;;;;:47;;;;;;;;;40027:1110;;;40121:8;;;;;;;40099:19;40113:4;40099:13;:19::i;:::-;:30;40095:117;;;40142:22;:20;:22::i;:::-;40095:117;;;40191:21;:19;:21::i;:::-;40225:22;40250:36;40277:8;40250:26;:36::i;:::-;40225:61;;40297:19;40319:31;40341:8;40319:21;:31::i;:::-;40365:17;;40297:53;;-1:-1:-1;40365:17:0;;;;;40361:284;;;40397:30;40403:7;40412:14;40397:5;:30::i;:::-;40451:45;40484:11;40451:28;:8;40464:14;40451:28;:12;:28;:::i;:::-;:32;:45;:32;:45;:::i;:::-;40440:56;;40361:284;;;40527:47;40533:7;40542:31;:14;40561:11;40542:31;:18;:31;:::i;40527:47::-;40598:35;40611:21;:14;40630:1;40611:21;:18;:21;:::i;:::-;40598:8;;:35;:12;:35;:::i;:::-;40587:46;;40361:284;40659:18;;;;;;;40655:371;;;40692:19;40714:20;:11;40730:3;40714:20;:15;:20;:::i;:::-;40692:42;-1:-1:-1;40782:28:0;:11;40692:42;40782:28;:15;:28;:::i;:::-;40768:42;;40823:41;40843:7;40852:11;40823:19;:41::i;:::-;40877:34;40890:7;40899:11;40877:12;:34::i;:::-;-1:-1:-1;40655:371:0;;;40973:41;40993:7;41002:11;40973:19;:41::i;:::-;-1:-1:-1;41046:21:0;;-1:-1:-1;41046:21:0;41109:18;:16;:18::i;:::-;40027:1110;;;-1:-1:-1;41154:8:0;39926:1245;-1:-1:-1;39926:1245:0:o;9424:166::-;9510:7;9546:12;9538:6;9530:29;;;;-1:-1:-1;;;9530:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;9530:29:0;;9581:1;9577;:5;;;;;;;9424:166;-1:-1:-1;;;;9424:166:0:o;38985:929::-;39077:16;;39063:31;;39077:16;;;;;39063:13;:31::i;:::-;39051:9;;;;;;;:43;:75;;;;-1:-1:-1;39110:16:0;;;;;;39098:9;;;;;:28;39051:75;39047:860;;;39197:9;;39180:12;;39141:13;;39180:27;;:12;39197:9;;;;;39180:16;:27::i;:::-;39165:12;:42;;;39253:13;;-1:-1:-1;39233:543:0;;39289:100;39339:49;39386:1;39340:40;39378:1;39341:31;39358:13;;39341:12;;:16;;:31;;;;:::i;39340:40::-;39339:46;:49;:46;:49;:::i;:::-;39290:43;39328:4;39291:31;39308:13;;39291:12;;:16;;:31;;;;:::i;39289:100::-;39281:108;-1:-1:-1;39423:80:0;39449:53;39479:22;39487:4;39497:3;39479:22;:17;:22;:::i;:::-;39450:12;;:23;;39467:5;39450:23;:16;:23;:::i;39449:53::-;39423:21;;;:80;:25;:80;:::i;:::-;39402:18;:101;39233:543;;;39542:100;39592:49;39639:1;39593:40;39631:1;39594:31;39611:13;;39594:12;;:16;;:31;;;;:::i;39592:49::-;39543:43;39581:4;39544:31;39562:12;;39544:13;;:17;;:31;;;;:::i;39542:100::-;39534:108;-1:-1:-1;39676:80:0;39702:53;39732:22;39740:4;39750:3;39732:22;:17;:22;:::i;39702:53::-;39676:21;;;:80;:25;:80;:::i;:::-;39655:18;:101;39233:543;-1:-1:-1;39802:12:0;;39786:13;:28;39825:9;:13;;;;;;-1:-1:-1;39872:25:0;39886:10;39872:13;:25::i;38484:291::-;38615:6;;38554:69;;38603:19;;38615:6;38603:7;;;;;;38615:6;;;;38603:11;:19::i;:::-;38589:6;;38555:42;;38572:24;;38579:4;;38589:6;;;;;38572:16;:24::i;:::-;38555:2;;:12;;:2;;;;;38562:4;38555:6;:12::i;38554:69::-;38542:2;:82;;;;;;;;;;;;;;;;;;;38675:12;;38542:2;38654:18;-1:-1:-1;38633:55:0;;;;38654:33;;;;38633:55;;;;;;;;;;38724:42;;38633:55;38743:22;;;;;;;;;38725:12;;:2;;;38732:4;38725:6;:12::i;38724:42::-;38697:17;;:70;;;;;;;;;;;;;;;;;;38484:291::o;38783:194::-;38861:16;38875:1;38861:13;:16::i;:::-;38881:1;38840:43;;;;38861:21;;;38840:43;;;;;;;;;;38920:46;;38840:43;38943:22;;;;;38920:18;38934:3;38920:13;:18::i;41760:144::-;41878:17;;41842:7;;41867:29;;:6;;41878:17;;;;;41867:10;:29::i;41266:146::-;41379:17;;41343:7;;41368:36;;41379:24;;:17;;;;;41401:1;41379:21;:24::i;:::-;41368:6;;:36;:10;:36;:::i;45730:506::-;45826:10;45818:19;;;;:7;:19;;;;;:50;;-1:-1:-1;;45818:50:0;45840:28;45818:50;;;45877:58;45887:7;45904:4;45911:23;45930:3;45911:14;:6;45922:2;45911:10;:14::i;:23::-;45877:9;:58::i;:::-;45944:59;45954:7;45963:14;45979:23;45998:3;45979:14;:6;45990:2;45979:14;:10;:14;:::i;45944:59::-;46034:1;46016:15;;;;;;:19;46012:112;;46107:15;;46070:54;;46096:27;;:6;;46107:15;;;;;46096:10;:27::i;46070:54::-;46046:21;:78;46012:112;46138:29;46143:23;46162:3;46143:14;:6;46154:2;46143:14;:10;:14;:::i;:23::-;46138:29;;;;;;;;;;;;;;;46181:47;46188:14;46204:23;46223:3;46204:14;:6;46215:2;46204:14;:10;:14;:::i;:23::-;46181:47;;;-1:-1:-1;;;;;46181:47:0;;;;;;;;;;;;;;;;;;;;;45730:506;;:::o;46244:220::-;46333:10;46325:19;;;;:7;:19;;;;;:50;;-1:-1:-1;;46325:50:0;46347:28;46325:50;;;46384:35;46394:7;46403;:5;:7::i;:::-;46412:6;46384:9;:35::i;:::-;46433:23;46440:7;:5;:7::i;:::-;46433:23;;;-1:-1:-1;;;;;46433:23:0;;;;;;;;;;;;;;;;;;;;46244:220;;:::o;41424:328::-;41504:12;;41482:18;;:34;41478:210;;41543:52;41549:45;41592:1;41550:36;41573:12;;41550:18;;:22;;:36;;;;:::i;41549:45::-;41543:5;:52::i;:::-;41527:7;;:69;;;;;;;;;;;;;;;;;;41478:210;;;41635:52;41641:45;41684:1;41642:36;41659:18;;41642:12;;:16;;:36;;;;:::i;41635:52::-;41619:7;;:69;;;;;;;;;;;;;;;;;;41478:210;41709:7;;41719:3;41709:7;;;;;;:13;:35;;41736:7;;;;;;;41730:3;:13;41709:35;;;41725:1;41709:35;41699:7;;:45;;;;;;;;;;;;;;;;;;41424:328::o;46499:274::-;46569:16;46583:1;46569:13;:16::i;:::-;:21;46565:201;;46636:4;46618:24;;;;:9;:24;;;;;;46603:40;;46609:7;;46603:5;:40::i;:::-;46692:4;46674:24;;;;:9;:24;;;;;;;;;;46659:40;;-1:-1:-1;;;;;46659:40:0;;;;;;;;;;;;;;;;;;;;;46724:4;46731:24;;;;:9;:24;;;;;;46710:46;;46724:4;46710:5;:46::i

Swarm Source

ipfs://fdf8ca640cdd60ea0d6e42a670781a4c0ddd90fd506a37da8ed0d0914b704f63
Loading