Contract 0xeff8B733f12Ae6902409047c44AD3ee0Bf58f201

 

Contract Overview

Balance:
0 BNB

BNB Value:
$0.00

Token:
Txn Hash
Block
From
To
Value [Txn Fee]
0x71276efbdfb5953be78e145f03a81713a74d46665579e1d8892399a4e04237fc52474092021-02-27 15:43:51107 days 10 hrs agoBelt Finance: Deployer IN  Contract Creation0 BNB0.00508339
[ Download CSV Export 
Latest 25 internal transaction
Parent Txn Hash Block From To Value
0x1296cd57b0cf81edb64b1ebf711a2323991c8cf0e45bfaaf3426f444d389327454674922021-03-07 8:47:3399 days 17 hrs ago 0xeff8b733f12ae6902409047c44ad3ee0bf58f201 0x86afa7ff694ab8c985b79733745662760e4541690 BNB
0x1296cd57b0cf81edb64b1ebf711a2323991c8cf0e45bfaaf3426f444d389327454674922021-03-07 8:47:3399 days 17 hrs ago 0xeff8b733f12ae6902409047c44ad3ee0bf58f201 0x86afa7ff694ab8c985b79733745662760e4541690 BNB
0x1296cd57b0cf81edb64b1ebf711a2323991c8cf0e45bfaaf3426f444d389327454674922021-03-07 8:47:3399 days 17 hrs ago 0xd4bbc80b9b102b77b21a06cb77e954049605e6c1 0xeff8b733f12ae6902409047c44ad3ee0bf58f2010 BNB
0x1296cd57b0cf81edb64b1ebf711a2323991c8cf0e45bfaaf3426f444d389327454674922021-03-07 8:47:3399 days 17 hrs ago 0xd4bbc80b9b102b77b21a06cb77e954049605e6c1 0xeff8b733f12ae6902409047c44ad3ee0bf58f2010 BNB
0x1296cd57b0cf81edb64b1ebf711a2323991c8cf0e45bfaaf3426f444d389327454674922021-03-07 8:47:3399 days 17 hrs ago 0xd4bbc80b9b102b77b21a06cb77e954049605e6c1 0xeff8b733f12ae6902409047c44ad3ee0bf58f2010 BNB
0xf394910f44ba176a03464fa596320cdf83f02c0387f9827a5e3bba829706e52854672002021-03-07 8:32:5799 days 18 hrs ago 0xeff8b733f12ae6902409047c44ad3ee0bf58f201 0x86afa7ff694ab8c985b79733745662760e4541690 BNB
0xf394910f44ba176a03464fa596320cdf83f02c0387f9827a5e3bba829706e52854672002021-03-07 8:32:5799 days 18 hrs ago 0xd4bbc80b9b102b77b21a06cb77e954049605e6c1 0xeff8b733f12ae6902409047c44ad3ee0bf58f2010 BNB
0xd638bfb81a5d426b5f89e38ae377570995fd06d070748925e4faf18bf7c96aae54653992021-03-07 7:02:5499 days 19 hrs ago 0xeff8b733f12ae6902409047c44ad3ee0bf58f201 0x86afa7ff694ab8c985b79733745662760e4541690 BNB
0xd638bfb81a5d426b5f89e38ae377570995fd06d070748925e4faf18bf7c96aae54653992021-03-07 7:02:5499 days 19 hrs ago 0xeff8b733f12ae6902409047c44ad3ee0bf58f201 0x86afa7ff694ab8c985b79733745662760e4541690 BNB
0xd638bfb81a5d426b5f89e38ae377570995fd06d070748925e4faf18bf7c96aae54653992021-03-07 7:02:5499 days 19 hrs ago 0xd4bbc80b9b102b77b21a06cb77e954049605e6c1 0xeff8b733f12ae6902409047c44ad3ee0bf58f2010 BNB
0xd638bfb81a5d426b5f89e38ae377570995fd06d070748925e4faf18bf7c96aae54653992021-03-07 7:02:5499 days 19 hrs ago 0xd4bbc80b9b102b77b21a06cb77e954049605e6c1 0xeff8b733f12ae6902409047c44ad3ee0bf58f2010 BNB
0xd638bfb81a5d426b5f89e38ae377570995fd06d070748925e4faf18bf7c96aae54653992021-03-07 7:02:5499 days 19 hrs ago 0xd4bbc80b9b102b77b21a06cb77e954049605e6c1 0xeff8b733f12ae6902409047c44ad3ee0bf58f2010 BNB
0x89eae582076c196575651f5167272adc955a81a064b162b2e65b68c82f8d0b3154646942021-03-07 6:27:3999 days 20 hrs ago 0xeff8b733f12ae6902409047c44ad3ee0bf58f201 0x86afa7ff694ab8c985b79733745662760e4541690 BNB
0x89eae582076c196575651f5167272adc955a81a064b162b2e65b68c82f8d0b3154646942021-03-07 6:27:3999 days 20 hrs ago 0xeff8b733f12ae6902409047c44ad3ee0bf58f201 0x86afa7ff694ab8c985b79733745662760e4541690 BNB
0x89eae582076c196575651f5167272adc955a81a064b162b2e65b68c82f8d0b3154646942021-03-07 6:27:3999 days 20 hrs ago 0xd4bbc80b9b102b77b21a06cb77e954049605e6c1 0xeff8b733f12ae6902409047c44ad3ee0bf58f2010 BNB
0x89eae582076c196575651f5167272adc955a81a064b162b2e65b68c82f8d0b3154646942021-03-07 6:27:3999 days 20 hrs ago 0xd4bbc80b9b102b77b21a06cb77e954049605e6c1 0xeff8b733f12ae6902409047c44ad3ee0bf58f2010 BNB
0x89eae582076c196575651f5167272adc955a81a064b162b2e65b68c82f8d0b3154646942021-03-07 6:27:3999 days 20 hrs ago 0xd4bbc80b9b102b77b21a06cb77e954049605e6c1 0xeff8b733f12ae6902409047c44ad3ee0bf58f2010 BNB
0x14a11d99326dd418eef92bb8de44492f66e565d7dacd33c4093750bba67573ce54624082021-03-07 4:33:1199 days 22 hrs ago 0xeff8b733f12ae6902409047c44ad3ee0bf58f201 0x86afa7ff694ab8c985b79733745662760e4541690 BNB
0x14a11d99326dd418eef92bb8de44492f66e565d7dacd33c4093750bba67573ce54624082021-03-07 4:33:1199 days 22 hrs ago 0xd4bbc80b9b102b77b21a06cb77e954049605e6c1 0xeff8b733f12ae6902409047c44ad3ee0bf58f2010 BNB
0x98a22706f3b25023a423cacd88c4efab845ea9230272b0b230d5b60590a6f5ac54623282021-03-07 4:29:1199 days 22 hrs ago 0xeff8b733f12ae6902409047c44ad3ee0bf58f201 0x86afa7ff694ab8c985b79733745662760e4541690 BNB
0x98a22706f3b25023a423cacd88c4efab845ea9230272b0b230d5b60590a6f5ac54623282021-03-07 4:29:1199 days 22 hrs ago 0xd4bbc80b9b102b77b21a06cb77e954049605e6c1 0xeff8b733f12ae6902409047c44ad3ee0bf58f2010 BNB
0x066cc22552d1daead89e218f9b8dfeb42e8f78530042a9a554462801c762a8f754621992021-03-07 4:22:4499 days 22 hrs ago 0xeff8b733f12ae6902409047c44ad3ee0bf58f201 0x86afa7ff694ab8c985b79733745662760e4541690 BNB
0x066cc22552d1daead89e218f9b8dfeb42e8f78530042a9a554462801c762a8f754621992021-03-07 4:22:4499 days 22 hrs ago 0xd4bbc80b9b102b77b21a06cb77e954049605e6c1 0xeff8b733f12ae6902409047c44ad3ee0bf58f2010 BNB
0x061fb3e207512ab4b15f9134d6361717b78d5a922d8e744b1b72535ef86fc7f354600572021-03-07 2:35:3899 days 23 hrs ago 0xd4bbc80b9b102b77b21a06cb77e954049605e6c1 0xeff8b733f12ae6902409047c44ad3ee0bf58f2010 BNB
0x061fb3e207512ab4b15f9134d6361717b78d5a922d8e744b1b72535ef86fc7f354600572021-03-07 2:35:3899 days 23 hrs ago 0xd4bbc80b9b102b77b21a06cb77e954049605e6c1 0xeff8b733f12ae6902409047c44ad3ee0bf58f2010 BNB
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
VaultBPool

Compiler Version
v0.6.12+commit.27d51765

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, None license

Contract Source Code (Solidity)

/**
 *Submitted for verification at BscScan.com on 2021-03-03
*/

pragma solidity 0.6.12;


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

    function _msgData() internal view virtual returns (bytes memory) {
        this;
        return msg.data;
    }
}

library SafeMath {

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

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

        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        return c;
    }


    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

interface IERC20 {

    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function transfer(address recipient, uint256 amount)
    external
    returns (bool);

    function allowance(address owner, address spender)
    external
    view
    returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);

    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
}

contract ERC20 is Context, IERC20 {
    using SafeMath for uint256;

    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;

    constructor(string memory name_, string memory symbol_) public {
        _name = name_;
        _symbol = symbol_;
        _decimals = 18;
    }

    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)
    {
        _transfer(_msgSender(), 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(_msgSender(), spender, amount);
        return true;
    }

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

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

    function decreaseAllowance(address spender, uint256 subtractedValue)
    public
    virtual
    returns (bool)
    {
        _approve(
            _msgSender(),
            spender,
            _allowances[_msgSender()][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), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

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

    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        _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(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

library Address {

    function isContract(address account) internal view returns (bool) {

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    function sendValue(address payable recipient, uint256 amount) internal {
        require(
            address(this).balance >= amount,
            "Address: insufficient balance"
        );

        (bool success, ) = recipient.call{value: amount}("");
        require(
            success,
            "Address: unable to send value, recipient may have reverted"
        );
    }

    function functionCall(address target, bytes memory data)
    internal
    returns (bytes memory)
    {
        return functionCall(target, data, "Address: low-level call failed");
    }

    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    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"
        );
    }

    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");

        (bool success, bytes memory returndata) =
        target.call{value: value}(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function functionStaticCall(address target, bytes memory data)
    internal
    view
    returns (bytes memory)
    {
        return
        functionStaticCall(
            target,
            data,
            "Address: low-level static call failed"
        );
    }

    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function functionDelegateCall(address target, bytes memory data)
    internal
    returns (bytes memory)
    {
        return
        functionDelegateCall(
            target,
            data,
            "Address: low-level delegate call failed"
        );
    }

    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(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 {
            if (returndata.length > 0) {
                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)
        );
    }

    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        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
            )
        );
    }

    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        bytes memory returndata =
        address(token).functionCall(
            data,
            "SafeERC20: low-level call failed"
        );
        if (returndata.length > 0) {
            require(
                abi.decode(returndata, (bool)),
                "SafeERC20: ERC20 operation did not succeed"
            );
        }
    }
}

library EnumerableSet {

    struct Set {
        bytes32[] _values;
        mapping(bytes32 => uint256) _indexes;
    }


    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);

            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }


    function _remove(Set storage set, bytes32 value) private returns (bool) {
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            bytes32 lastvalue = set._values[lastIndex];

            set._values[toDeleteIndex] = lastvalue;
            set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based

            set._values.pop();

            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }


    function _contains(Set storage set, bytes32 value)
    private
    view
    returns (bool)
    {
        return set._indexes[value] != 0;
    }


    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    function _at(Set storage set, uint256 index)
    private
    view
    returns (bytes32)
    {
        require(
            set._values.length > index,
            "EnumerableSet: index out of bounds"
        );
        return set._values[index];
    }



    struct Bytes32Set {
        Set _inner;
    }

    function add(Bytes32Set storage set, bytes32 value)
    internal
    returns (bool)
    {
        return _add(set._inner, value);
    }

    function remove(Bytes32Set storage set, bytes32 value)
    internal
    returns (bool)
    {
        return _remove(set._inner, value);
    }

    function contains(Bytes32Set storage set, bytes32 value)
    internal
    view
    returns (bool)
    {
        return _contains(set._inner, value);
    }

    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    function at(Bytes32Set storage set, uint256 index)
    internal
    view
    returns (bytes32)
    {
        return _at(set._inner, index);
    }


    struct AddressSet {
        Set _inner;
    }

    function add(AddressSet storage set, address value)
    internal
    returns (bool)
    {
        return _add(set._inner, bytes32(uint256(value)));
    }

    function remove(AddressSet storage set, address value)
    internal
    returns (bool)
    {
        return _remove(set._inner, bytes32(uint256(value)));
    }

    function contains(AddressSet storage set, address value)
    internal
    view
    returns (bool)
    {
        return _contains(set._inner, bytes32(uint256(value)));
    }

    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    function at(AddressSet storage set, uint256 index)
    internal
    view
    returns (address)
    {
        return address(uint256(_at(set._inner, index)));
    }


    struct UintSet {
        Set _inner;
    }

    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    function remove(UintSet storage set, uint256 value)
    internal
    returns (bool)
    {
        return _remove(set._inner, bytes32(value));
    }

    function contains(UintSet storage set, uint256 value)
    internal
    view
    returns (bool)
    {
        return _contains(set._inner, bytes32(value));
    }

    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    function at(UintSet storage set, uint256 index)
    internal
    view
    returns (uint256)
    {
        return uint256(_at(set._inner, index));
    }
}

abstract contract Ownable is Context {
    address private _owner;

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


    constructor() internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }


    function owner() public view returns (address) {
        return _owner;
    }


    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }


    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }


    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(
            newOwner != address(0),
            "Ownable: new owner is the zero address"
        );
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

interface IPancakeswapFarm {
    function poolLength() external view returns (uint256);

    function userInfo() external view returns (uint256);

    function getMultiplier(uint256 _from, uint256 _to)
    external
    view
    returns (uint256);

    function pendingCake(uint256 _pid, address _user)
    external
    view
    returns (uint256);

    function deposit(uint256 _pid, uint256 _amount) external;

    function withdraw(uint256 _pid, uint256 _amount) external;

    function enterStaking(uint256 _amount) external;

    function leaveStaking(uint256 _amount) external;

    function emergencyWithdraw(uint256 _pid) external;
}

interface IPancakeRouter01 {
    function factory() external pure returns (address);

    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    )
    external
    returns (
        uint256 amountA,
        uint256 amountB,
        uint256 liquidity
    );

    function addLiquidityETH(
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    )
    external
    payable
    returns (
        uint256 amountToken,
        uint256 amountETH,
        uint256 liquidity
    );

    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountA, uint256 amountB);

    function removeLiquidityETH(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountToken, uint256 amountETH);

    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountA, uint256 amountB);

    function removeLiquidityETHWithPermit(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountToken, uint256 amountETH);

    function swapExactTokensForTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapTokensForExactTokens(
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapExactETHForTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

    function swapTokensForExactETH(
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapExactTokensForETH(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapETHForExactTokens(
        uint256 amountOut,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

    function quote(
        uint256 amountA,
        uint256 reserveA,
        uint256 reserveB
    ) external pure returns (uint256 amountB);

    function getAmountOut(
        uint256 amountIn,
        uint256 reserveIn,
        uint256 reserveOut
    ) external pure returns (uint256 amountOut);

    function getAmountIn(
        uint256 amountOut,
        uint256 reserveIn,
        uint256 reserveOut
    ) external pure returns (uint256 amountIn);

    function getAmountsOut(uint256 amountIn, address[] calldata path)
    external
    view
    returns (uint256[] memory amounts);

    function getAmountsIn(uint256 amountOut, address[] calldata path)
    external
    view
    returns (uint256[] memory amounts);
}

interface IPancakeRouter02 is IPancakeRouter01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountETH);

    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;

    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable;

    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;
}

abstract contract ReentrancyGuard {

    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() internal {
        _status = _NOT_ENTERED;
    }


    modifier nonReentrant() {
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        _status = _ENTERED;

        _;

        _status = _NOT_ENTERED;
    }
}

contract Pausable is Context {

    event Paused(address account);

    event Unpaused(address account);

    bool private _paused;

    constructor() internal {
        _paused = false;
    }


    function paused() public view returns (bool) {
        return _paused;
    }


    modifier whenNotPaused() {
        require(!_paused, "Pausable: paused");
        _;
    }


    modifier whenPaused() {
        require(_paused, "Pausable: not paused");
        _;
    }

    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

contract VaultBPool is Ownable, ReentrancyGuard, Pausable {

    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    address public wantAddress;
    address public masterBeltAddress;

    address public govAddress;
    bool public onlyGov = true;

    uint256 public wantLockedTotal = 0;
    uint256 public sharesTotal = 0;

    constructor(
        address _masterBeltAddress,
        address _wantAddress
    ) public {
        govAddress = msg.sender;
        wantAddress = _wantAddress;
        masterBeltAddress = _masterBeltAddress;
        transferOwnership(_masterBeltAddress);
    }

    function deposit(address _userAddress, uint256 _wantAmt)
    public
    onlyOwner
    whenNotPaused
    returns (uint256)
    {
        IERC20(wantAddress).safeTransferFrom(
            address(msg.sender),
            address(this),
            _wantAmt
        );

        uint256 sharesAdded = _wantAmt;
        sharesTotal = sharesTotal.add(sharesAdded);
        wantLockedTotal = wantLockedTotal.add(_wantAmt);

        return sharesAdded;
    }

    function withdraw(address _userAddress, uint256 _wantAmt)
    public
    onlyOwner
    nonReentrant
    returns (uint256)
    {
        require(_wantAmt > 0, "_wantAmt <= 0");

        uint256 wantAmt = IERC20(wantAddress).balanceOf(address(this));
        if (_wantAmt > wantAmt) {
            _wantAmt = wantAmt;
        }

        if (wantLockedTotal < _wantAmt) {
            _wantAmt = wantLockedTotal;
        }

        uint256 sharesRemoved = _wantAmt;
        if (sharesRemoved > sharesTotal) {
            sharesRemoved = sharesTotal;
        }
        sharesTotal = sharesTotal.sub(sharesRemoved);
        wantLockedTotal = wantLockedTotal.sub(_wantAmt);

        IERC20(wantAddress).safeTransfer(masterBeltAddress, _wantAmt);

        return sharesRemoved;
    }

    function pause() public {
        require(msg.sender == govAddress, "Not authorised");
        _pause();
    }

    function unpause() external {
        require(msg.sender == govAddress, "Not authorised");
        _unpause();
    }

    function setGov(address _govAddress) public {
        require(msg.sender == govAddress, "!gov");
        govAddress = _govAddress;
    }

    function setOnlyGov(bool _onlyGov) public {
        require(msg.sender == govAddress, "!gov");
        onlyGov = _onlyGov;
    }
}

Contract ABI

[{"inputs":[{"internalType":"address","name":"_masterBeltAddress","type":"address"},{"internalType":"address","name":"_wantAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"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":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[{"internalType":"address","name":"_userAddress","type":"address"},{"internalType":"uint256","name":"_wantAmt","type":"uint256"}],"name":"deposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"govAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"masterBeltAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"onlyGov","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_govAddress","type":"address"}],"name":"setGov","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_onlyGov","type":"bool"}],"name":"setOnlyGov","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sharesTotal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"wantAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"wantLockedTotal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_userAddress","type":"address"},{"internalType":"uint256","name":"_wantAmt","type":"uint256"}],"name":"withdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"}]

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

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

000000000000000000000000d4bbc80b9b102b77b21a06cb77e954049605e6c100000000000000000000000086afa7ff694ab8c985b79733745662760e454169

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000d4bbc80b9b102b77b21a06cb77e954049605e6c1
Arg [1] : 00000000000000000000000086afa7ff694ab8c985b79733745662760e454169


Deployed ByteCode Sourcemap

26485:2447:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28798:131;;;;;;;;;;;;;;;;-1:-1:-1;28798:131:0;;;;:::i;:::-;;26726:26;;;:::i;:::-;;;;;;;;;;;;;;;;;;28524:119;;;:::i;26761:34::-;;;:::i;:::-;;;;;;;;;;;;;;;;26802:30;;;:::i;26694:25::-;;;:::i;:::-;;;;-1:-1:-1;;;;;26694:25:0;;;;;;;;;;;;;;27119:467;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;27119:467:0;;;;;;;;:::i;25940:78::-;;;:::i;18595:148::-;;;:::i;28403:113::-;;;:::i;18377:79::-;;;:::i;28651:139::-;;;;;;;;;;;;;;;;-1:-1:-1;28651:139:0;-1:-1:-1;;;;;28651:139:0;;:::i;26653:32::-;;;:::i;26620:26::-;;;:::i;18753:281::-;;;;;;;;;;;;;;;;-1:-1:-1;18753:281:0;-1:-1:-1;;;;;18753:281:0;;:::i;27594:801::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;27594:801:0;;;;;;;;:::i;28798:131::-;28873:10;;-1:-1:-1;;;;;28873:10:0;28859;:24;28851:41;;;;;-1:-1:-1;;;28851:41:0;;;;;;;;;;;;;;;-1:-1:-1;;;28851:41:0;;;;;;;;;;;;;;;28903:7;:18;;;;;-1:-1:-1;;;28903:18:0;-1:-1:-1;;;;28903:18:0;;;;;;;;;28798:131::o;26726:26::-;;;-1:-1:-1;;;26726:26:0;;;;;:::o;28524:119::-;28585:10;;-1:-1:-1;;;;;28585:10:0;28571;:24;28563:51;;;;;-1:-1:-1;;;28563:51:0;;;;;;;;;;;;-1:-1:-1;;;28563:51:0;;;;;;;;;;;;;;;28625:10;:8;:10::i;:::-;28524:119::o;26761:34::-;;;;:::o;26802:30::-;;;;:::o;26694:25::-;;;-1:-1:-1;;;;;26694:25:0;;:::o;27119:467::-;27236:7;18516:12;:10;:12::i;:::-;18506:6;;-1:-1:-1;;;;;18506:6:0;;;:22;;;18498:67;;;;;-1:-1:-1;;;18498:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;18498:67:0;;;;;;;;;;;;;;;26073:7:::1;::::0;::::1;;26072:8;26064:37;;;::::0;;-1:-1:-1;;;26064:37:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;26064:37:0;;;;;;;;;;;;;::::1;;27268:11:::2;::::0;27261:132:::2;::::0;27268:11:::2;::::0;::::2;-1:-1:-1::0;;;;;27268:11:0::2;27320:10;27354:4;27374:8:::0;27261:36:::2;:132::i;:::-;27461:11;::::0;27428:8;;27461:28:::2;::::0;27428:8;27461:15:::2;:28::i;:::-;27447:11;:42:::0;27518:15:::2;::::0;:29:::2;::::0;27538:8;27518:19:::2;:29::i;:::-;27500:15;:47:::0;27567:11;27119:467;-1:-1:-1;;;27119:467:0:o;25940:78::-;26003:7;;;;25940:78;:::o;18595:148::-;18516:12;:10;:12::i;:::-;18506:6;;-1:-1:-1;;;;;18506:6:0;;;:22;;;18498:67;;;;;-1:-1:-1;;;18498:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;18498:67:0;;;;;;;;;;;;;;;18702:1:::1;18686:6:::0;;18665:40:::1;::::0;-1:-1:-1;;;;;18686:6:0;;::::1;::::0;18665:40:::1;::::0;18702:1;;18665:40:::1;18733:1;18716:19:::0;;-1:-1:-1;;;;;;18716:19:0::1;::::0;;18595:148::o;28403:113::-;28460:10;;-1:-1:-1;;;;;28460:10:0;28446;:24;28438:51;;;;;-1:-1:-1;;;28438:51:0;;;;;;;;;;;;-1:-1:-1;;;28438:51:0;;;;;;;;;;;;;;;28500:8;:6;:8::i;18377:79::-;18415:7;18442:6;-1:-1:-1;;;;;18442:6:0;18377:79;:::o;28651:139::-;28728:10;;-1:-1:-1;;;;;28728:10:0;28714;:24;28706:41;;;;;-1:-1:-1;;;28706:41:0;;;;;;;;;;;;;;;-1:-1:-1;;;28706:41:0;;;;;;;;;;;;;;;28758:10;:24;;-1:-1:-1;;;;;;28758:24:0;-1:-1:-1;;;;;28758:24:0;;;;;;;;;;28651:139::o;26653:32::-;;;-1:-1:-1;;;;;26653:32:0;;:::o;26620:26::-;;;;;;-1:-1:-1;;;;;26620:26:0;;:::o;18753:281::-;18516:12;:10;:12::i;:::-;18506:6;;-1:-1:-1;;;;;18506:6:0;;;:22;;;18498:67;;;;;-1:-1:-1;;;18498:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;18498:67:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;18856:22:0;::::1;18834:110;;;;-1:-1:-1::0;;;18834:110:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18981:6;::::0;;18960:38:::1;::::0;-1:-1:-1;;;;;18960:38:0;;::::1;::::0;18981:6;::::1;::::0;18960:38:::1;::::0;::::1;19009:6;:17:::0;;-1:-1:-1;;;;;;19009:17:0::1;-1:-1:-1::0;;;;;19009:17:0;;;::::1;::::0;;;::::1;::::0;;18753:281::o;27594:801::-;27711:7;18516:12;:10;:12::i;:::-;18506:6;;-1:-1:-1;;;;;18506:6:0;;;:22;;;18498:67;;;;;-1:-1:-1;;;18498:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;18498:67:0;;;;;;;;;;;;;;;25419:1:::1;25578:7;;:19;;25570:63;;;::::0;;-1:-1:-1;;;25570:63:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;25419:1;25646:7;:18:::0;27744:12;27736:38:::2;;;::::0;;-1:-1:-1;;;27736:38:0;;::::2;;::::0;::::2;::::0;::::2;::::0;;;;-1:-1:-1;;;27736:38:0;;;;;;;;;;;;;::::2;;27812:11;::::0;27805:44:::2;::::0;;-1:-1:-1;;;27805:44:0;;27843:4:::2;27805:44;::::0;::::2;::::0;;;-1:-1:-1;;27812:11:0::2;::::0;::::2;-1:-1:-1::0;;;;;27812:11:0::2;::::0;27805:29:::2;::::0;:44;;;;;::::2;::::0;;;;;;;;27812:11;27805:44;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;27805:44:0;;-1:-1:-1;27864:18:0;;::::2;27860:69;;;27910:7;27899:18;;27860:69;27963:8;27945:15;;:26;27941:85;;;27999:15;;27988:26;;27941:85;28101:11;::::0;28062:8;;28085:27;::::2;28081:87;;;-1:-1:-1::0;28145:11:0::2;::::0;28081:87:::2;28192:11;::::0;:30:::2;::::0;28208:13;28192:15:::2;:30::i;:::-;28178:11;:44:::0;28251:15:::2;::::0;:29:::2;::::0;28271:8;28251:19:::2;:29::i;:::-;28233:15;:47:::0;28326:17:::2;::::0;28300:11:::2;::::0;28293:61:::2;::::0;-1:-1:-1;;;;;28326:17:0::2;28300:11:::0;;::::2;::::0;::::2;::::0;28326:17:::2;28345:8:::0;28293:32:::2;:61::i;:::-;25375:1:::1;25691:22:::0;;28374:13;27594:801;-1:-1:-1;;;;27594:801:0:o;26358:120::-;26172:7;;;;26164:40;;;;;-1:-1:-1;;;26164:40:0;;;;;;;;;;;;-1:-1:-1;;;26164:40:0;;;;;;;;;;;;;;;26417:7:::1;:15:::0;;-1:-1:-1;;26417:15:0::1;::::0;;26448:22:::1;26457:12;:10;:12::i;:::-;26448:22;::::0;;-1:-1:-1;;;;;26448:22:0;;::::1;::::0;;;;;;;::::1;::::0;;::::1;26358:120::o:0;62:106::-;150:10;62:106;:::o;11741:285::-;11939:68;;;-1:-1:-1;;;;;11939:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;11939:68:0;-1:-1:-1;;;11939:68:0;;;11885:133;;11919:5;;11885:19;:133::i;:::-;11741:285;;;;:::o;323:181::-;381:7;413:5;;;437:6;;;;429:46;;;;;-1:-1:-1;;;429:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;495:1;323:181;-1:-1:-1;;;323:181:0:o;26232:118::-;26073:7;;;;26072:8;26064:37;;;;;-1:-1:-1;;;26064:37:0;;;;;;;;;;;;-1:-1:-1;;;26064:37:0;;;;;;;;;;;;;;;26292:7:::1;:14:::0;;-1:-1:-1;;26292:14:0::1;26302:4;26292:14;::::0;;26322:20:::1;26329:12;:10;:12::i;512:136::-:0;570:7;597:43;601:1;604;597:43;;;;;;;;;;;;;;;;;:3;:43::i;11485:248::-;11656:58;;;-1:-1:-1;;;;;11656:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;11656:58:0;-1:-1:-1;;;11656:58:0;;;11602:123;;11636:5;;11602:19;:123::i;:::-;11485:248;;;:::o;13437:428::-;13518:23;13553:106;13595:4;13553:106;;;;;;;;;;;;;;;;;13561:5;-1:-1:-1;;;;;13553:27:0;;;:106;;;;;:::i;:::-;13674:17;;13518:141;;-1:-1:-1;13674:21:0;13670:188;;13749:10;13738:30;;;;;;;;;;;;;;;-1:-1:-1;13738:30:0;13712:134;;;;-1:-1:-1;;;13712:134:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;656:226;776:7;812:12;804:6;;;;796:29;;;;-1:-1:-1;;;796:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;848:5:0;;;656:226::o;8317:229::-;8454:12;8486:52;8508:6;8516:4;8522:1;8525:12;8486:21;:52::i;:::-;8479:59;8317:229;-1:-1:-1;;;;8317:229:0:o;8894:557::-;9064:12;9136:5;9111:21;:30;;9089:118;;;;-1:-1:-1;;;9089:118:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9226:18;9237:6;9226:10;:18::i;:::-;9218:60;;;;;-1:-1:-1;;;9218:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;9292:12;9306:23;9342:6;-1:-1:-1;;;;;9342:11:0;9361:5;9368:4;9342:31;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;9342:31:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9291:82;;;;9391:52;9409:7;9418:10;9430:12;9391:17;:52::i;:::-;9384:59;8894:557;-1:-1:-1;;;;;;;8894:557:0:o;7514:198::-;7648:20;7696:8;;;7514:198::o;10836:550::-;10986:12;11015:7;11011:368;;;-1:-1:-1;11046:10:0;11039:17;;11011:368;11093:17;;:21;11089:279;;11196:10;11190:17;11257:15;11244:10;11240:2;11236:19;11229:44;11144:148;11332:20;;-1:-1:-1;;;11332:20:0;;;;;;;;;;;;;;;;;11339:12;;11332:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Swarm Source

ipfs://33c27cc147ec52def31d53c97cd72544e570ee1841c1bcadd960e645d0100889
Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.