Contract 0xfd2ede6c009ed305fe01a3410f945b580aebc37b

 
Txn Hash
Block
From
To
Value [Txn Fee]
0x89a183869c787826fc184b7ef1b476f5329c8088e29cf2994102cf75a19cbb5383161432021-06-15 10:41:585 days 4 hrs ago0x60ec9cf15a51269785bec8ca1f9e3e230ec52164 IN  0xfd2ede6c009ed305fe01a3410f945b580aebc37b0 BNB0.00007231
0x08af679244a807f3b1ce0e1b086d4a4f6fdd88a9fda1c95f2b8656a7f1c7e25981566002021-06-09 20:43:0210 days 18 hrs ago0x1e8a2087ccd95dc85a089fc6fc2559326cc991d3 IN  0xfd2ede6c009ed305fe01a3410f945b580aebc37b0 BNB0.00022154
0xa664793ae2ac6f82accb18eae88eeb6a499eec8ee66aa68aeca82f8c01d8605880946972021-06-07 16:59:0112 days 22 hrs agoBudz Finance: Deployer IN  0xfd2ede6c009ed305fe01a3410f945b580aebc37b0 BNB0.00018498
0xab16d7973d0bc4065d97e8c6f86118217f45b05602b1b7340f02db532b18e9b880442072021-06-05 22:50:0314 days 16 hrs agoBudz Finance: Deployer IN  0xfd2ede6c009ed305fe01a3410f945b580aebc37b0 BNB0.000432405
0x450808f712ee997ded5e76b8c46d72205a17192b3b7085c62002127fe27b42b080442042021-06-05 22:49:5414 days 16 hrs agoBudz Finance: Deployer IN  0xfd2ede6c009ed305fe01a3410f945b580aebc37b0 BNB0.000432405
0x11ed6e7622d51922a9b5be8e824500302098bb6876b81e2224611ae38ceecf6580399442021-06-05 19:16:2714 days 19 hrs ago0x217335630cbef77b1035210336e393f01daf97d1 IN  0xfd2ede6c009ed305fe01a3410f945b580aebc37b0 BNB0.00022154
0x6203e46f48978e48da94197350a685540ed198c3ca8d6fd5b7ebb45eebe1599c75920132021-05-21 4:27:0130 days 10 hrs ago0xc9917b5bd63a1a57318e075c1cd6776ad19e6445 IN  0xfd2ede6c009ed305fe01a3410f945b580aebc37b0 BNB0.00022154
0x04c5da3fe778a00306fc803310a13ce7abf75b00cdeeea5c2a738cf1b3056ec375872912021-05-21 0:29:0730 days 14 hrs ago0x75dd3965e54cabc30c2cb2f321df296eea8f0f7a IN  0xfd2ede6c009ed305fe01a3410f945b580aebc37b0 BNB0.00022154
0xcb434e977d29427e29016b032b1e64cf0fc83e74cb26760d0b2c1d9ec1fdc2f375854122021-05-20 22:53:5330 days 16 hrs ago0x478b9371be4445e46dfa67e5ee9426857e4d291c IN  0xfd2ede6c009ed305fe01a3410f945b580aebc37b0 BNB0.00022154
0x0770c4b5a3e2abf017a5effd472e88b82486c7d34cf343a675ee6474ec997b2475819732021-05-20 20:01:5630 days 19 hrs ago0x30efcf75240acda8a8fd516e44539820aa06ceb5 IN  0xfd2ede6c009ed305fe01a3410f945b580aebc37b0 BNB0.00022154
0x712c0723da2160f62a431c8642e0b93393de8056fb4e5f7db72190cf7f6cae8b75436672021-05-19 11:54:5632 days 3 hrs ago0xb64386dce7464039a6727687cc41416bb23bf996 IN  0xfd2ede6c009ed305fe01a3410f945b580aebc37b0 BNB0.00088616
0xffa68fe08044da075c8870e64ad652aab49e1f7c8543fa2e4892c15ab69e9f9d75273292021-05-18 22:00:1332 days 17 hrs agoBudz Finance: Deployer IN  0xfd2ede6c009ed305fe01a3410f945b580aebc37b0 BNB0.000432285
0xfa141702a6e2ce866d4b3bfe7d7dd61e2ea574876ebd20b53be2c532e61dd1ea75272872021-05-18 21:58:0732 days 17 hrs agoBudz Finance: Deployer IN  0xfd2ede6c009ed305fe01a3410f945b580aebc37b0 BNB0.000432285
0x98888746f47ce40b17dd19b53e27e71b201278e0f5756fab54696847ebeb9d8175272852021-05-18 21:58:0132 days 17 hrs agoBudz Finance: Deployer IN  0xfd2ede6c009ed305fe01a3410f945b580aebc37b0 BNB0.000432285
0x75ba52daca39f06643a5915a16d887ec93dd8e3968f43cf74ac5ef435cef988075272782021-05-18 21:57:4032 days 17 hrs agoBudz Finance: Deployer IN  0xfd2ede6c009ed305fe01a3410f945b580aebc37b0 BNB0.000432285
0xead427282909049bf96fe42a83198aca654651ec2902b76b7641aca814f165c874747562021-05-17 1:30:3534 days 13 hrs agoBudz Finance: Deployer IN  0xfd2ede6c009ed305fe01a3410f945b580aebc37b0 BNB0.000432285
0xdb6fc875412230efc5a6a3d8cdcaa8ba2e5125f187d6bd46877746ac606cdc4074747532021-05-17 1:30:2634 days 13 hrs agoBudz Finance: Deployer IN  0xfd2ede6c009ed305fe01a3410f945b580aebc37b0 BNB0.000371425
0xd7b65f06a3b3c52437ba97b98c2b33e9df4bd070aec96c45525d9d6ed8fcff0d74747502021-05-17 1:30:1734 days 13 hrs agoBudz Finance: Deployer IN  0xfd2ede6c009ed305fe01a3410f945b580aebc37b0 BNB0.000432285
0x604cd27fb4bd55f9f39d01dc812b8d68c3011ff2fa07c0732afd846140e019a974465852021-05-16 1:42:5335 days 13 hrs agoBudz Finance: Deployer IN  0xfd2ede6c009ed305fe01a3410f945b580aebc37b0 BNB0.000432285
0x38feb5b224a4c387cb28b3aa0beac59a1bf463a7b5ea2958856d830b4aab343a74465122021-05-16 1:39:1435 days 13 hrs agoBudz Finance: Deployer IN  0xfd2ede6c009ed305fe01a3410f945b580aebc37b0 BNB0.000432285
0x8f26e5f17f2e9f3063bcbe7eb9a56092ae49f469501bef6d89865c632b2b905474465112021-05-16 1:39:1135 days 13 hrs agoBudz Finance: Deployer IN  0xfd2ede6c009ed305fe01a3410f945b580aebc37b0 BNB0.000371425
0x556ec48a791e9a49321b1291f886ebdf75e248c619a773dc58ce7847f37fae8a74465102021-05-16 1:39:0835 days 13 hrs agoBudz Finance: Deployer IN  0xfd2ede6c009ed305fe01a3410f945b580aebc37b0 BNB0.000371425
0x043cb6e9ab865a24f0a0e998b05f833fda3ca5724a6483c9ddb4794f68646dfa74465092021-05-16 1:39:0535 days 13 hrs agoBudz Finance: Deployer IN  0xfd2ede6c009ed305fe01a3410f945b580aebc37b0 BNB0.000371425
0x35f0307dba09436172d81218d3b1acab4f4e2742af1f39e5eb223ba4c088b44174465072021-05-16 1:38:5935 days 13 hrs agoBudz Finance: Deployer IN  0xfd2ede6c009ed305fe01a3410f945b580aebc37b0 BNB0.000432285
0x4e5d95e81d7cf01dea18859643d3cf53075e88736ca7172f911b675875dfe51574465062021-05-16 1:38:5635 days 13 hrs agoBudz Finance: Deployer IN  0xfd2ede6c009ed305fe01a3410f945b580aebc37b0 BNB0.000371425
[ Download CSV Export 
Latest 1 internal transaction
Parent Txn Hash Block From To Value
0xf680ad3d8739d393e8868512a39b2edd7cbe4774b86706198ebb8e4f5251020369525922021-04-28 7:35:0853 days 7 hrs ago 0xfd2ede6c009ed305fe01a3410f945b580aebc37bBudz Finance: Deployer0.001 BNB
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
NUGZ

Compiler Version
v0.6.4+commit.1dca32f3

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, None license

Contract Source Code (Solidity Multiple files format)

File 1 of 4: Nugz.sol
//███╗░░██╗██╗░░░██╗░██████╗░███████╗
//████╗░██║██║░░░██║██╔════╝░╚════██║
//██╔██╗██║██║░░░██║██║░░██╗░░░███╔═╝
//██║╚████║██║░░░██║██║░░╚██╗██╔══╝░░
//██║░╚███║╚██████╔╝╚██████╔╝███████╗
//╚═╝░░╚══╝░╚═════╝░░╚═════╝░╚══════╝

pragma solidity ^0.6.4;

import "./IERC20.sol";
import "./SafeMath.sol";
import "./Address.sol";



interface IUniswapV2Pair {
  event Approval(address indexed owner, address indexed spender, uint value);
  event Transfer(address indexed from, address indexed to, uint value);

  function name() external pure returns (string memory);
  function symbol() external pure returns (string memory);
  function decimals() external pure returns (uint8);
  function totalSupply() external view returns (uint);
  function balanceOf(address owner) external view returns (uint);
  function allowance(address owner, address spender) external view returns (uint);

  function approve(address spender, uint value) external returns (bool);
  function transfer(address to, uint value) external returns (bool);
  function transferFrom(address from, address to, uint value) external returns (bool);

  function DOMAIN_SEPARATOR() external view returns (bytes32);
  function PERMIT_TYPEHASH() external pure returns (bytes32);
  function nonces(address owner) external view returns (uint);

  function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;

  event Mint(address indexed sender, uint amount0, uint amount1);
  event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
  event Swap(
      address indexed sender,
      uint amount0In,
      uint amount1In,
      uint amount0Out,
      uint amount1Out,
      address indexed to
  );
  event Sync(uint112 reserve0, uint112 reserve1);

  function MINIMUM_LIQUIDITY() external pure returns (uint);
  function factory() external view returns (address);
  function token0() external view returns (address);
  function token1() external view returns (address);
  function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
  function price0CumulativeLast() external view returns (uint);
  function price1CumulativeLast() external view returns (uint);
  function kLast() external view returns (uint);

  function mint(address to) external returns (uint liquidity);
  function burn(address to) external returns (uint amount0, uint amount1);
  function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
  function skim(address to) external;
  function sync() external;
}

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */

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

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

    /**
     * @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.

        // A Solidity high level call has three parts:
        //  1. The target address is checked to verify it contains contract code
        //  2. The call itself is made, and success asserted
        //  3. The return value is decoded, which in turn checks the size of the returned data.
        // solhint-disable-next-line max-line-length
        require(address(token).isContract(), "SafeERC20: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = address(token).call(data);
        require(success, "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");
        }
    }
}


/**
 * @title Standard ERC20 token
 *
 * @dev Implementation of the basic standard token.
 * https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
 * Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
 */
contract NUGZ is IERC20 {
  using SafeMath for uint256;
  using SafeERC20 for NUGZ;
    
  mapping (address => uint256) private _balances;

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

  uint256 private _totalSupply;
  string public constant name = "nugz.finance";
  string public constant symbol = "NUGZ";
  uint8 public constant decimals = 18;
  bool private sync;
  bool public burnPoolSet;
  address private admin;
  
  address public cakeNUGZBurn = address(0);
  
  modifier onlyAdmin(){
      require(msg.sender == admin, "not an admin");
      _;
  }

  modifier onlyOnce(){
      require(!burnPoolSet, "burn pool already set");
      _;
      burnPoolSet = true;
  }
  
  //protects against potential reentrancy
  modifier synchronized {
      require(!sync, "Sync lock");
      sync = true;
      _;
      sync = false;
  }
  
  //when a user burns tokens
  event TokenBurn(
      address indexed user,
      uint value
  );
    
  /**
  * @dev Total number of tokens in existence
  */
  function totalSupply() public override view returns (uint256) {
    return _totalSupply;
  }

  /**
  * @dev Gets the balance of the specified address.
  * @param owner The address to query the balance of.
  * @return An uint256 representing the amount owned by the passed address.
  */
  function balanceOf(address owner) public override view returns (uint256) {
    return _balances[owner];
  }

  /**
   * @dev Function to check the amount of tokens that an owner allowed to a spender.
   * @param owner address The address which owns the funds.
   * @param spender address The address which will spend the funds.
   * @return A uint256 specifying the amount of tokens still available for the spender.
   */
  function allowance(
    address owner,
    address spender
   )
    public
    override
    view
    returns (uint256)
  {
    return _allowed[owner][spender];
  }

  /**
  * @dev Transfer token for a specified address
  * @param to The address to transfer to.
  * @param value The amount to be transferred.
  */
  function transfer(address to, uint256 value) public override returns (bool) {
    require(value <= _balances[msg.sender]);
    require(to != address(0));
    require(to != address(this));
    _balances[msg.sender] = _balances[msg.sender].sub(value);
    _balances[to] = _balances[to].add(value);
    emit Transfer(msg.sender, to, value);
    return true;
  }

  /**
   * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
   * 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
   * @param spender The address which will spend the funds.
   * @param value The amount of tokens to be spent.
   */
  function approve(address spender, uint256 value) public override returns (bool) {
    require(spender != address(0));

    _allowed[msg.sender][spender] = value;
    emit Approval(msg.sender, spender, value);
    return true;
  }

  /**
   * @dev Transfer tokens from one address to another
   * @param from address The address which you want to send tokens from
   * @param to address The address which you want to transfer to
   * @param value uint256 the amount of tokens to be transferred
   */
  function transferFrom(
    address from,
    address to,
    uint256 value
  )
    public
    override
    returns (bool)
  {
    require(value <= _balances[from]);
    require(value <= _allowed[from][msg.sender]);
    require(to != address(0));

    _balances[from] = _balances[from].sub(value);
    _balances[to] = _balances[to].add(value);
    _allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
    emit Transfer(from, to, value);
    return true;
  }

  /**
   * @dev Increase the amount of tokens that an owner allowed to a spender.
   * approve should be called when allowed_[_spender] == 0. To increment
   * allowed value is better to use this function to avoid 2 calls (and wait until
   * the first transaction is mined)
   * From MonolithDAO Token.sol
   * @param spender The address which will spend the funds.
   * @param addedValue The amount of tokens to increase the allowance by.
   */
  function increaseAllowance(
    address spender,
    uint256 addedValue
  )
    public
    returns (bool)
  {
    require(spender != address(0));

    _allowed[msg.sender][spender] = (
      _allowed[msg.sender][spender].add(addedValue));
    emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
    return true;
  }

  /**
   * @dev Decrease the amount of tokens that an owner allowed to a spender.
   * approve should be called when allowed_[_spender] == 0. To decrement
   * allowed value is better to use this function to avoid 2 calls (and wait until
   * the first transaction is mined)
   * From MonolithDAO Token.sol
   * @param spender The address which will spend the funds.
   * @param subtractedValue The amount of tokens to decrease the allowance by.
   */
  function decreaseAllowance(
    address spender,
    uint256 subtractedValue
  )
    public
    returns (bool)
  {
    require(spender != address(0));

    _allowed[msg.sender][spender] = (
      _allowed[msg.sender][spender].sub(subtractedValue));
    emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
    return true;
  }

  /**
   * @dev Internal function that mints an amount of the token and assigns it to
   * an account. This encapsulates the modification of balances such that the
   * proper events are emitted.
   * @param account The account that will receive the created tokens.
   * @param amount The amount that will be created.
   */
  function _mint(address account, uint256 amount) internal {
    require(account != address(0));
    _totalSupply = _totalSupply.add(amount);
    _balances[account] = _balances[account].add(amount);
    emit Transfer(address(0), account, amount);
  }

  /**
   * @dev Internal function that burns an amount of the token of a given
   * account.
   * @param account The account whose tokens will be burnt.
   * @param amount The amount that will be burnt.
   */
  function _burn(address account, uint256 amount) internal {
    require(account != address(0));
    require(amount <= _balances[account]);

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

  /**
   * @dev Internal function that burns an amount of the token of a given
   * account, deducting from the sender's allowance for said account. Uses the
   * internal burn function.
   * @param account The account whose tokens will be burnt.
   * @param amount The amount that will be burnt.
   */
  function _burnFrom(address account, uint256 amount) internal {
    require(amount <= _allowed[account][msg.sender]);

    // Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
    // this function needs to emit an event with the updated approval.
    _allowed[account][msg.sender] = _allowed[account][msg.sender].sub(
      amount);
    _burn(account, amount);
  }

  receive() external payable{
      donate();
  }

  constructor(uint256 initialTokens) public {
        //set admin
        admin = msg.sender;
        //mint total supply
        _mint(msg.sender, initialTokens);
  }
  
    ///////////////////////////////
    ////////PUBLIC FACING//////////////
    ///////////////////////////////
    
  function BurnNugz(uint amt)
      external
      synchronized
  {
      require(amt > 0, "value must be greater than 0");
      require(balanceOf(msg.sender) >= amt, "balance too low");
      //burn tokens of user
      _burn(msg.sender, amt);
      //burn tokens of pancake swap - pamp it
      _balances[cakeNUGZBurn] = _balances[cakeNUGZBurn].sub(amt, "ERC20: burn amount exceeds balance");
      _totalSupply = _totalSupply.sub(amt);
      IUniswapV2Pair(cakeNUGZBurn).sync();
      emit TokenBurn(msg.sender, amt);
  }
  
    ///////////////////////////////
    ////////ADMIN ONLY//////////////
    ///////////////////////////////
    
    function setNugzBurnPool(address _lpAddress)
        external
        onlyAdmin
        onlyOnce
    {
        cakeNUGZBurn = _lpAddress;
    }
  
      //distribute any arbitrary token stuck in the contract via address
    function distributeTokens(address _tokenAddress) 
        external
        onlyAdmin
    {
        //create contract
        IERC20 _token = IERC20(_tokenAddress);
        //distribute
        _token.transfer(admin,  _token.balanceOf(address(this)));
    }
    
    function donate() public payable {
        require(msg.value > 0);
        bool success = false;
        //distribute
        (success, ) =  admin.call{value:msg.value}{gas:21000}('');
        require(success, "Transfer failed");
    }
}

File 2 of 4: Address.sol
pragma solidity 0.6.4;

/**
 * @dev Collection of functions related to the address type
 */
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) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }

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

File 3 of 4: IERC20.sol
pragma solidity 0.6.4;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP. Does not include
 * the optional functions; to access them see {ERC20Detailed}.
 */

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);//from address(0) for minting

    /**
     * @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);
}

File 4 of 4: SafeMath.sol
pragma solidity 0.6.4;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
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.
     *
     * _Available since v2.4.0._
     */
    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.
     *
     * _Available since v2.4.0._
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        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.
     *
     * _Available since v2.4.0._
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

Contract ABI

[{"inputs":[{"internalType":"uint256","name":"initialTokens","type":"uint256"}],"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":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TokenBurn","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"},{"inputs":[{"internalType":"uint256","name":"amt","type":"uint256"}],"name":"BurnNugz","outputs":[],"stateMutability":"nonpayable","type":"function"},{"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":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"burnPoolSet","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cakeNUGZBurn","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","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":[{"internalType":"address","name":"_tokenAddress","type":"address"}],"name":"distributeTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"donate","outputs":[],"stateMutability":"payable","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":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_lpAddress","type":"address"}],"name":"setNugzBurnPool","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":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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)

0000000000000000000000000000000000000000000008e4d316827686400000

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000008e4d316827686400000


Deployed ByteCode Sourcemap

6070:9360:2:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13694:8;:6;:8::i;:::-;6070:9360;;12:1:-1;9;2:12;6324:44:2;;5:9:-1;2:2;;;27:1;24;17:12;2:2;6324:44:2;;;:::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;6324:44:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9196:235;;5:9:-1;2:2;;;27:1;24;17:12;2:2;9196:235:2;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;9196:235:2;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;7139:94;;5:9:-1;2:2;;;27:1;24;17:12;2:2;7139:94:2;;;:::i;:::-;;;;;;;;;;;;;;;;9711:489;;5:9:-1;2:2;;;27:1;24;17:12;2:2;9711:489:2;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;9711:489:2;;;;;;;;;;;;;;;;;:::i;6416:35::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;6416:35:2;;;:::i;:::-;;;;;;;;;;;;;;;;;;;10662:343;;5:9:-1;2:2;;;27:1;24;17:12;2:2;10662:343:2;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;10662:343:2;;;;;;;;:::i;14013:536::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;14013:536:2;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;14013:536:2;;:::i;7437:109::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;7437:109:2;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;7437:109:2;-1:-1:-1;;;;;7437:109:2;;:::i;6373:38::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;6373:38:2;;;:::i;11472:353::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;11472:353:2;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;11472:353:2;;;;;;;;:::i;8203:366::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;8203:366:2;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;8203:366:2;;;;;;;;:::i;14910:264::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;14910:264:2;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;14910:264:2;-1:-1:-1;;;;;14910:264:2;;:::i;14677:149::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;14677:149:2;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;14677:149:2;-1:-1:-1;;;;;14677:149:2;;:::i;7871:173::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;7871:173:2;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;7871:173:2;;;;;;;;;;:::i;6536:40::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;6536:40:2;;;:::i;:::-;;;;-1:-1:-1;;;;;6536:40:2;;;;;;;;;;;;;;15186:241;;;:::i;6478:23::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;6478:23:2;;;:::i;15186:241::-;15250:1;15238:9;:13;15230:22;;12:1:-1;9;2:12;15230:22:2;15331:5;;:42;;15263:12;;15331:5;;;-1:-1:-1;;;;;15331:5:2;;15363;;15348:9;;15263:12;15331:42;15263:12;15331:42;15348:9;15331:5;15363;15331:42;;;;;;;12:1:-1;19;14:27;;;;67:4;61:11;56:16;;134:4;130:9;123:4;105:16;101:27;97:43;94:1;90:51;84:4;77:65;157:16;154:1;147:27;211:16;208:1;201:4;198:1;194:12;179:49;5:228;;14:27;32:4;27:9;;5:228;;15316:57:2;;;;;15392:7;15384:35;;;;;-1:-1:-1;;;15384:35:2;;;;;;;;;;;;-1:-1:-1;;;15384:35:2;;;;;;;;;;;;;;;15186:241;:::o;6324:44::-;;;;;;;;;;;;;;-1:-1:-1;;;6324:44:2;;;;:::o;9196:235::-;9270:4;-1:-1:-1;;;;;9291:21:2;;9283:30;;12:1:-1;9;2:12;9283:30:2;9331:10;9322:20;;;;:8;:20;;;;;;;;-1:-1:-1;;;;;9322:29:2;;;;;;;;;;;;:37;;;9371:36;;;;;;;9322:29;;9331:10;9371:36;;;;;;;;;;;-1:-1:-1;9421:4:2;9196:235;;;;:::o;7139:94::-;7215:12;;7139:94;:::o;9711:489::-;-1:-1:-1;;;;;9867:15:2;;9834:4;9867:15;;;;;;;;;;;9858:24;;;9850:33;;12:1:-1;9;2:12;9850:33:2;-1:-1:-1;;;;;9907:14:2;;;;;;:8;:14;;;;;;;;9922:10;9907:26;;;;;;;;9898:35;;;9890:44;;12:1:-1;9;2:12;9890:44:2;-1:-1:-1;;;;;9949:16:2;;9941:25;;12:1:-1;9;2:12;9941:25:2;-1:-1:-1;;;;;9993:15:2;;:9;:15;;;;;;;;;;;:26;;10013:5;9993:26;:19;:26;:::i;:::-;-1:-1:-1;;;;;9975:15:2;;;:9;:15;;;;;;;;;;;:44;;;;10042:13;;;;;;;:24;;10060:5;10042:24;:17;:24;:::i;:::-;-1:-1:-1;;;;;10026:13:2;;;:9;:13;;;;;;;;;;;:40;;;;10102:14;;;;;:8;:14;;;;;10117:10;10102:26;;;;;;;:37;;10133:5;10102:37;:30;:37;:::i;:::-;-1:-1:-1;;;;;10073:14:2;;;;;;;:8;:14;;;;;;;;10088:10;10073:26;;;;;;;;:66;;;;10151:25;;;;;;;;;;;10073:14;;10151:25;;;;;;;;;;;-1:-1:-1;10190:4:2;9711:489;;;;;:::o;6416:35::-;6449:2;6416:35;:::o;10662:343::-;10767:4;-1:-1:-1;;;;;10791:21:2;;10783:30;;12:1:-1;9;2:12;10783:30:2;10872:10;10863:20;;;;:8;:20;;;;;;;;-1:-1:-1;;;;;10863:29:2;;;;;;;;;;:45;;10897:10;10863:45;:33;:45;:::i;:::-;10831:10;10822:20;;;;:8;:20;;;;;;;;-1:-1:-1;;;;;10822:29:2;;;;;;;;;;;;:87;;;10921:60;;;;;;10822:29;;10921:60;;;;;;;;;;;-1:-1:-1;10995:4:2;10662:343;;;;:::o;14013:536::-;6888:4;;;;6887:5;6879:27;;;;;-1:-1:-1;;;6879:27:2;;;;;;;;;;;;-1:-1:-1;;;6879:27:2;;;;;;;;;;;;;;;6915:4;:11;;-1:-1:-1;;6915:11:2;6922:4;6915:11;;;14097:7;14089:48:::1;;;::::0;;-1:-1:-1;;;14089:48:2;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;14179:3;14154:21;14164:10;14154:9;:21::i;:::-;:28;;14146:56;;;::::0;;-1:-1:-1;;;14146:56:2;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;14146:56:2;;;;;;;;;;;;;::::1;;14240:22;14246:10;14258:3;14240:5;:22::i;:::-;14344:70;14372:3;14344:70;;;;;;;;;;;;;;;;;14354:12;::::0;-1:-1:-1;;;;;14354:12:2::1;14344:9;:23:::0;;;::::1;::::0;;;;;;;;:70;::::1;:27;:70;:::i;:::-;14328:12;::::0;-1:-1:-1;;;;;14328:12:2::1;14318:9;:23:::0;;;::::1;::::0;;;;;;:96;14438:12:::1;::::0;:21:::1;::::0;14455:3;14438:21:::1;:16;:21;:::i;:::-;14423:12;:36:::0;14483:12:::1;::::0;;14468:35:::1;::::0;;-1:-1:-1;;;;;;14468:35:2;;;;-1:-1:-1;;;;;14483:12:2;;::::1;::::0;14468:33:::1;::::0;:35;;::::1;::::0;14483:12:::1;::::0;14468:35;;;;;;14483:12;;14468:35;::::1;;2:2:-1::0;::::1;;;27:1;24::::0;17:12:::1;2:2;14468:35:2;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;-1:-1:::0;;14517:26:2::1;::::0;;;;;;;14527:10:::1;::::0;-1:-1:-1;14517:26:2::1;::::0;-1:-1:-1;14517:26:2;;;;::::1;::::0;;::::1;-1:-1:-1::0;6945:4:2;:12;;-1:-1:-1;;6945:12:2;;;14013:536::o;7437:109::-;-1:-1:-1;;;;;7524:16:2;7501:7;7524:16;;;;;;;;;;;;7437:109::o;6373:38::-;;;;;;;;;;;;;;-1:-1:-1;;;6373:38:2;;;;:::o;11472:353::-;11582:4;-1:-1:-1;;;;;11606:21:2;;11598:30;;12:1:-1;9;2:12;11598:30:2;11687:10;11678:20;;;;:8;:20;;;;;;;;-1:-1:-1;;;;;11678:29:2;;;;;;;;;;:50;;11712:15;11678:50;:33;:50;:::i;8203:366::-;8313:10;8273:4;8303:21;;;;;;;;;;;8294:30;;;8286:39;;12:1:-1;9;2:12;8286:39:2;-1:-1:-1;;;;;8340:16:2;;8332:25;;12:1:-1;9;2:12;8332:25:2;-1:-1:-1;;;;;8372:19:2;;8386:4;8372:19;;8364:28;;12:1:-1;9;2:12;8364:28:2;8433:10;8423:9;:21;;;;;;;;;;;:32;;8449:5;8423:32;:25;:32;:::i;:::-;8409:10;8399:9;:21;;;;;;;;;;;:56;;;;-1:-1:-1;;;;;8478:13:2;;;;;;:24;;8496:5;8478:24;:17;:24;:::i;:::-;-1:-1:-1;;;;;8462:13:2;;:9;:13;;;;;;;;;;;;:40;;;;8514:31;;;;;;;8462:13;;8523:10;;8514:31;;;;;;;;;;-1:-1:-1;8559:4:2;8203:366;;;;:::o;14910:264::-;6636:5;;;;;-1:-1:-1;;;;;6636:5:2;6622:10;:19;6614:44;;;;;-1:-1:-1;;;6614:44:2;;;;;;;;;;;;-1:-1:-1;;;6614:44:2;;;;;;;;;;;;;;;15126:5:::1;::::0;15134:31:::1;::::0;;-1:-1:-1;;;15134:31:2;;15159:4:::1;15134:31;::::0;::::1;::::0;;;15063:13;;-1:-1:-1;;;;;15110:15:2;;::::1;::::0;::::1;::::0;15126:5;;;::::1;::::0;;::::1;::::0;15110:15;;15134:16:::1;::::0;:31;;;;;::::1;::::0;;;;;;;;15110:15;15134:31;::::1;;2:2:-1::0;::::1;;;27:1;24::::0;17:12:::1;2:2;15134:31:2;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;15134:31:2;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28::::0;21:12:::1;4:2;-1:-1:::0;15134:31:2;15110:56:::1;::::0;;-1:-1:-1;;;;;;15110:56:2::1;::::0;;;;;;-1:-1:-1;;;;;15110:56:2;;::::1;;::::0;::::1;::::0;;;;;;;;;;;;;;15134:31:::1;::::0;15110:56;;;;;;;-1:-1:-1;15110:56:2;;::::1;;2:2:-1::0;::::1;;;27:1;24::::0;17:12:::1;2:2;15110:56:2;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;15110:56:2;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28::::0;21:12:::1;4:2;-1:-1:::0;;;;14910:264:2:o;14677:149::-;6636:5;;;;;-1:-1:-1;;;;;6636:5:2;6622:10;:19;6614:44;;;;;-1:-1:-1;;;6614:44:2;;;;;;;;;;;;-1:-1:-1;;;6614:44:2;;;;;;;;;;;;;;;6717:11:::1;::::0;::::1;::::0;::::1;;;6716:12;6708:46;;;::::0;;-1:-1:-1;;;6708:46:2;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;6708:46:2;;;;;;;;;;;;;::::1;;14793:12:::2;:25:::0;;-1:-1:-1;;;;;14793:25:2;;::::2;-1:-1:-1::0;;;;;;14793:25:2;;::::2;::::0;;;::::2;::::0;;6773:11:::1;:18:::0;;-1:-1:-1;;6773:18:2::1;14793:25:::2;6773:18:::1;::::0;;14677:149::o;7871:173::-;-1:-1:-1;;;;;8014:15:2;;;7988:7;8014:15;;;:8;:15;;;;;;;;:24;;;;;;;;;;;;;7871:173::o;6536:40::-;;;-1:-1:-1;;;;;6536:40:2;;:::o;6478:23::-;;;;;;;;;:::o;1314:136:3:-;1372:7;1399:43;1403:1;1406;1399:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;1392:50;1314:136;-1:-1:-1;;;1314:136:3:o;858:181::-;916:7;948:5;;;972:6;;;;964:46;;;;;-1:-1:-1;;;964:46:3;;;;;;;;;;;;;;;;;;;;;;;;;;;12636:299:2;-1:-1:-1;;;;;12708:21:2;;12700:30;;12:1:-1;9;2:12;12700:30:2;-1:-1:-1;;;;;12755:18:2;;:9;:18;;;;;;;;;;;12745:28;;;12737:37;;12:1:-1;9;2:12;12737:37:2;12798:12;;:24;;12815:6;12798:24;:16;:24;:::i;:::-;12783:12;:39;-1:-1:-1;;;;;12850:18:2;;:9;:18;;;;;;;;;;;:30;;12873:6;12850:30;:22;:30;:::i;:::-;-1:-1:-1;;;;;12829:18:2;;:9;:18;;;;;;;;;;;:51;;;;12892:37;;;;;;;12829:9;;12892:37;;;;;;;;;;;12636:299;;:::o;1787:192:3:-;1873:7;1909:12;1901:6;;;;1893:29;;;;-1:-1:-1;;;1893:29:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;1893:29:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;1945:5:3;;;1787:192::o

Swarm Source

ipfs://3b774a8b8707390c2e6c2bf66605d541133ea69f3116fd12f1cb0470a371b9fc
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.