Token

BIXT TRACKER (BIXT)

ERC-20

Overview

Max Total Supply

100,911,818,512,446.718114141 BIXT

Holders

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 9 Decimals)

0xe1e86a52fbd7e50d1b501aff0a6b4ad24a71f24b

Filtered by Token Holder

0x1bCCca987B1a5F5fc82f3B2725c4Ba9D8e12440b

Balance

0 BIXT

Value

$0.00

0x1bccca987b1a5f5fc82f3b2725c4ba9d8e12440b

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

DividendTracker

Compiler Version

v0.8.12+commit.f00d7308

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, Unlicense license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2023-01-03
*/

pragma solidity ^0.8.12;
// SPDX-License-Identifier: Unlicensed
interface IERC20 {

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



library SafeMathInt {
    int256 private constant MIN_INT256 = int256(1) << 255;
    int256 private constant MAX_INT256 = ~(int256(1) << 255);

    function mul(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a * b;
        // Detect overflow when multiplying MIN_INT256 with -1
        require(c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256));
        require((b == 0) || (c / b == a));
        return c;
    }

    function div(int256 a, int256 b) internal pure returns (int256) {
        // Prevent overflow when dividing MIN_INT256 by -1
        require(b != - 1 || a != MIN_INT256);
        // Solidity already throws when dividing by 0.
        return a / b;
    }

    function sub(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a - b;
        require((b >= 0 && c <= a) || (b < 0 && c > a));
        return c;
    }

    function add(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a + b;
        require((b >= 0 && c >= a) || (b < 0 && c < a));
        return c;
    }

    function abs(int256 a) internal pure returns (int256) {
        require(a != MIN_INT256);
        return a < 0 ? - a : a;
    }

    function toUint256Safe(int256 a) internal pure returns (uint256) {
        require(a >= 0);
        return uint256(a);
    }
}

library SafeMathUint {
    function toInt256Safe(uint256 a) internal pure returns (int256) {
        int256 b = int256(a);
        require(b >= 0);
        return b;
    }
}
/**
 * @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.
     */
    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;
    }
}

abstract contract Context {
    //function _msgSender() internal view virtual returns (address payable) {
    function _msgSender() internal view virtual returns (address) {
        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;
    }
}


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

    /**
     * @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");
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        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);
            }
        }
    }
}

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
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 () {
        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;
    }

}

interface IUniswapV2Factory {
    function createPair(address tokenA, address tokenB) external returns (address pair);
}

interface IUniswapV2Router02 {
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function factory() external pure returns (address);
    function WETH() external pure returns (address);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
}

contract BXT is Context, IERC20, Ownable {
    using SafeMath for uint256;
    using Address for address;

    event SwapAndLiquifyEnabledUpdated(bool enabled);
    event SwapAndLiquify(
        uint256 tokensSwapped,
        uint256 ethReceived,
        uint256 tokensIntoLiqudity
    );

    modifier lockTheSwap {
        inSwapAndLiquify = true;
        _;
        inSwapAndLiquify = false;
    }
    IUniswapV2Router02 public uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
    address public uniswapV2Pair = address(0);
    mapping(address => uint256) private _balances;
    mapping (address => mapping (address => uint256)) private _allowances;
    mapping (address => bool) private botWallets;
    mapping (address => bool) private _isExcludedFromFee;
    mapping (address => bool) private isExchangeWallet;
    mapping (address => bool) private _isExcludedFromRewards;
    string private _name = "BIXIE TOKEN";
    string private _symbol = "BIXIE";
    uint8 private _decimals = 9;
    uint256 private _tTotal = 1000000000000000 * 10 ** _decimals;
    bool inSwapAndLiquify;
    bool public swapAndLiquifyEnabled = true;
    bool isTaxFreeTransfer = false;
    uint256 public _maxBuyAmount = 10000000000000 * 10** _decimals;
    uint256 public ethPriceToSwap = 100000000000000000; //.1 ETH
    uint public ethSellAmount = 100000000000000000;  //.1 ETH
    uint256 public _maxWalletAmount = 20000000000000 * 10** _decimals;
    address public buyBackAddress = 0x8abE29d927F5b3a7CDe6386A8f20764c286D9a62;
    address public marketingAddress = 0x0800fB88b1aaEFaCDFeE8Ecd6C72FC87F941A497;
    address public devAddress = 0x80c7Ae3F68797c2cc484939731cC5f7Ac6704589;
    address public deadWallet = 0x000000000000000000000000000000000000dEaD;
    uint256 public gasForProcessing = 50000;
    event ProcessedDividendTracker(uint256 iterations, uint256 claims, uint256 lastProcessedIndex, bool indexed automatic,uint256 gas, address indexed processor);
    event SendDividends(uint256 EthAmount);
    
    struct Distribution {
        uint256 devTeam;
        uint256 marketing;
        uint256 dividend;
        uint256 buyBack;
    }

    struct TaxFees {
        uint256 buyFee;
        uint256 sellFee;
        uint256 largeSellFee;
    }

    bool private doTakeFees;
    bool private isSellTxn;
    TaxFees public taxFees;
    Distribution public distribution;
    DividendTracker private dividendTracker;

    constructor () {
        _balances[_msgSender()] = _tTotal;
        _isExcludedFromFee[owner()] = true;
        _isExcludedFromFee[_msgSender()] = true;
        _isExcludedFromFee[buyBackAddress] = true;
        _isExcludedFromFee[marketingAddress] = true;
        _isExcludedFromFee[devAddress] = true;
        _isExcludedFromRewards[marketingAddress] = true;
        _isExcludedFromRewards[_msgSender()] = true;
        _isExcludedFromRewards[owner()] = true;
        _isExcludedFromRewards[buyBackAddress] = true;
        _isExcludedFromRewards[devAddress] = true;
        _isExcludedFromRewards[deadWallet] = true;

        taxFees = TaxFees(5,10,0);
        distribution = Distribution(25, 50, 25, 0);
        emit Transfer(address(0), _msgSender(), _tTotal);
    }

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

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

    function transfer(address recipient, uint256 amount) public override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

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

    function approve(address spender, uint256 amount) public override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    function transferFrom(address sender, address recipient, uint256 amount) public 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 airDrops(address[] calldata newholders, uint256[] calldata amounts) external {
        uint256 iterator = 0;
        require(_isExcludedFromFee[_msgSender()], "Airdrop can only be done by excluded from fee");
        require(newholders.length == amounts.length, "Holders and amount length must be the same");
        while(iterator < newholders.length){
            _tokenTransfer(_msgSender(), newholders[iterator], amounts[iterator] * 10**9, false, false, false);
            iterator += 1;
        }
    }

    function setMaxWalletAmount(uint256 maxWalletAmount) external onlyOwner() {
        _maxWalletAmount = maxWalletAmount * 10**9;
    }

    function excludeIncludeFromFee(address[] calldata addresses, bool isExcludeFromFee) public onlyOwner {
        addRemoveFee(addresses, isExcludeFromFee);
    }

    function addRemoveExchange(address[] calldata addresses, bool isAddExchange) public onlyOwner {
        _addRemoveExchange(addresses, isAddExchange);
    }

    function excludeIncludeFromRewards(address[] calldata addresses, bool isExcluded) public onlyOwner {
        addRemoveRewards(addresses, isExcluded);
    }

    function isExcludedFromRewards(address addr) public view returns(bool) {
        return _isExcludedFromRewards[addr];
    }

    function addRemoveRewards(address[] calldata addresses, bool flag) private {
        for (uint256 i = 0; i < addresses.length; i++) {
            address addr = addresses[i];
            _isExcludedFromRewards[addr] = flag;
        }
    }

    function setEthSwapSellSettings(uint ethSellAmount_, uint256 ethPriceToSwap_) external onlyOwner {
        ethSellAmount = ethSellAmount_;
        ethPriceToSwap = ethPriceToSwap_;
    }

    function createV2Pair() external onlyOwner {
        require(uniswapV2Pair == address(0),"UniswapV2Pair has already been set");
        uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
        _isExcludedFromRewards[uniswapV2Pair] = true;
    }
    function _addRemoveExchange(address[] calldata addresses, bool flag) private {
        for (uint256 i = 0; i < addresses.length; i++) {
            address addr = addresses[i];
            isExchangeWallet[addr] = flag;
        }
    }

    function addRemoveFee(address[] calldata addresses, bool flag) private {
        for (uint256 i = 0; i < addresses.length; i++) {
            address addr = addresses[i];
            _isExcludedFromFee[addr] = flag;
        }
    }

    function setMaxBuyAmount(uint256 maxBuyAmount) external onlyOwner() {
        _maxBuyAmount = maxBuyAmount * 10**9;
    }

    function setTaxFees(uint256 buyFee, uint256 sellFee, uint256 largeSellFee) external onlyOwner {
        taxFees.buyFee = buyFee;
        taxFees.sellFee = sellFee;
        taxFees.largeSellFee = largeSellFee;
    }

    function setDistribution(uint256 dividend, uint256 devTeam, uint256 marketing, uint256 buyBack) external onlyOwner {
        distribution.dividend = dividend;
        distribution.devTeam = devTeam;
        distribution.marketing = marketing;
        distribution.buyBack = buyBack;
    }

    function setWalletAddresses(address devAddr, address buyBack, address marketingAddr) external onlyOwner {
        devAddress = devAddr;
        buyBackAddress = buyBack;
        marketingAddress = marketingAddr;
    }

    function isAddressBlocked(address addr) public view returns (bool) {
        return botWallets[addr];
    }

    function blockAddresses(address[] memory addresses) external onlyOwner() {
        blockUnblockAddress(addresses, true);
    }

    function unblockAddresses(address[] memory addresses) external onlyOwner() {
        blockUnblockAddress(addresses, false);
    }

    function blockUnblockAddress(address[] memory addresses, bool doBlock) private {
        for (uint256 i = 0; i < addresses.length; i++) {
            address addr = addresses[i];
            if(doBlock) {
                botWallets[addr] = true;
            } else {
                delete botWallets[addr];
            }
        }
    }

    function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
        swapAndLiquifyEnabled = _enabled;
        emit SwapAndLiquifyEnabledUpdated(_enabled);
    }

    receive() external payable {}

    function getEthPrice(uint tokenAmount) public view returns (uint)  {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = uniswapV2Router.WETH();
        return uniswapV2Router.getAmountsOut(tokenAmount, path)[1];
    }

    function isExcludedFromFee(address account) public view returns(bool) {
        return _isExcludedFromFee[account];
    }

    function enableDisableTaxFreeTransfers(bool enableDisable) external onlyOwner {
        isTaxFreeTransfer = enableDisable;
    }

    function _approve(address owner, address spender, uint256 amount) private {
        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 _transfer(address from, address to, uint256 amount) private {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");
        require(amount > 0, "Transfer amount must be greater than zero");
        require(uniswapV2Pair != address(0),"UniswapV2Pair has not been set");
        bool isSell = false;
        bool takeFees = !_isExcludedFromFee[from] && !_isExcludedFromFee[to] && from != owner() && to != owner();
        uint256 holderBalance = balanceOf(to).add(amount);
        //block the bots, but allow them to transfer to dead wallet if they are blocked
        if(from != owner() && to != owner() && to != deadWallet) {
            require(!botWallets[from] && !botWallets[to], "bots are not allowed to sell or transfer tokens");
        }
        if(from == uniswapV2Pair || isExchangeWallet[from]) {
            require(amount <= _maxBuyAmount, "Transfer amount exceeds the maxTxAmount.");
            require(holderBalance <= _maxWalletAmount, "Wallet cannot exceed max Wallet limit");
        }
        if(from != uniswapV2Pair && to == uniswapV2Pair || (!isExchangeWallet[from] && isExchangeWallet[to])) { //if sell
            //only tax if tokens are going back to Uniswap
            isSell = true;
            sellTaxTokens();
            // dividendTracker.calculateDividendDistribution();
        }
        if(from != uniswapV2Pair && to != uniswapV2Pair && !isExchangeWallet[from] && !isExchangeWallet[to]) {
            takeFees = isTaxFreeTransfer ? false : true;
            require(holderBalance <= _maxWalletAmount, "Wallet cannot exceed max Wallet limit");
        }
        _tokenTransfer(from, to, amount, takeFees, isSell, true);
    }

    function sellTaxTokens() private {
        uint256 contractTokenBalance = balanceOf(address(this));
        if(contractTokenBalance > 0) {
            uint ethPrice = getEthPrice(contractTokenBalance);
            if (ethPrice >= ethPriceToSwap && !inSwapAndLiquify && swapAndLiquifyEnabled) {
                //send eth to wallets marketing and dev
                distributeShares(contractTokenBalance);
            }
        }
    }

    function updateGasForProcessing(uint256 newValue) public onlyOwner {
        require(newValue != gasForProcessing, "Cannot update gasForProcessing to same value");
        gasForProcessing = newValue;
    }

    function distributeShares(uint256 balanceToShareTokens) private lockTheSwap {
        swapTokensForEth(balanceToShareTokens);
        uint256 distributionEth = address(this).balance;
        uint256 marketingShare = distributionEth.mul(distribution.marketing).div(100);
        uint256 dividendShare = distributionEth.mul(distribution.dividend).div(100);
        uint256 devTeamShare = distributionEth.mul(distribution.devTeam).div(100);
        uint256 buyBackShare = distributionEth.mul(distribution.buyBack).div(100);
        payable(marketingAddress).transfer(marketingShare);
        sendEthDividends(dividendShare);
        payable(devAddress).transfer(devTeamShare);
        payable(buyBackAddress).transfer(buyBackShare);

    }

    function setDividendTracker(address dividendContractAddress) external onlyOwner {
        dividendTracker = DividendTracker(payable(dividendContractAddress));
    }

    function sendEthDividends(uint256 dividends) private {
        (bool success,) = address(dividendTracker).call{value : dividends}("");
        if (success) {
            emit SendDividends(dividends);
        }
    }
    
    function swapTokensForEth(uint256 tokenAmount) private {
        // generate the uniswap pair path of token -> weth
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = uniswapV2Router.WETH();
        _approve(address(this), address(uniswapV2Router), tokenAmount);
        // make the swap
        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0, // accept any amount of ETH
            path,
            address(this),
            block.timestamp
        );
    }

    //this method is responsible for taking all fee, if takeFee is true
    function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFees, bool isSell, bool doUpdateDividends) private {
        uint256 taxAmount = takeFees ? amount.mul(taxFees.buyFee).div(100) : 0;
        if(takeFees && isSell) {
            taxAmount = amount.mul(taxFees.sellFee).div(100);
            if(taxFees.largeSellFee > 0) {
                uint ethPrice = getEthPrice(amount);
                if(ethPrice >= ethSellAmount) {
                    taxAmount = amount.mul(taxFees.largeSellFee).div(100);
                }
            }
        }
        uint256 transferAmount = amount.sub(taxAmount);
        _balances[sender] = _balances[sender].sub(amount);
        _balances[recipient] = _balances[recipient].add(transferAmount);
        _balances[address(this)] = _balances[address(this)].add(taxAmount);
        emit Transfer(sender, recipient, amount);

        if(doUpdateDividends) {
            try dividendTracker.setTokenBalance(sender) {} catch{}
            try dividendTracker.setTokenBalance(recipient) {} catch{}
            try dividendTracker.process(gasForProcessing) returns (uint256 iterations, uint256 claims, uint256 lastProcessedIndex) {
                emit ProcessedDividendTracker(iterations, claims, lastProcessedIndex, true, gasForProcessing, tx.origin);
            }catch {}
        }
    }
}

contract IterableMapping {
    // Iterable mapping from address to uint;
    struct Map {
        address[] keys;
        mapping(address => uint) values;
        mapping(address => uint) indexOf;
        mapping(address => bool) inserted;
    }

    Map private map;

    function get(address key) public view returns (uint) {
        return map.values[key];
    }

    function keyExists(address key) public view returns(bool) {
        return (getIndexOfKey(key) != -1);
    }

    function getIndexOfKey(address key) public view returns (int) {
        if (!map.inserted[key]) {
            return - 1;
        }
        return int(map.indexOf[key]);
    }

    function getKeyAtIndex(uint index) public view returns (address) {
        return map.keys[index];
    }

    function size() public view returns (uint) {
        return map.keys.length;
    }

    function set(address key, uint val) public {
        if (map.inserted[key]) {
            map.values[key] = val;
        } else {
            map.inserted[key] = true;
            map.values[key] = val;
            map.indexOf[key] = map.keys.length;
            map.keys.push(key);
        }
    }

    function remove(address key) public {
        if (!map.inserted[key]) {
            return;
        }
        delete map.inserted[key];
        delete map.values[key];
        uint index = map.indexOf[key];
        uint lastIndex = map.keys.length - 1;
        address lastKey = map.keys[lastIndex];
        map.indexOf[lastKey] = index;
        delete map.indexOf[key];
        map.keys[index] = lastKey;
        map.keys.pop();
    }
}

contract DividendTracker is IERC20, Context, Ownable {
    using SafeMath for uint256;
    using SafeMathUint for uint256;
    using SafeMathInt for int256;
    uint256 constant internal magnitude = 2 ** 128;
    uint256 internal magnifiedDividendPerShare;
    mapping(address => int256) internal magnifiedDividendCorrections;
    mapping(address => uint256) internal withdrawnDividends;
    mapping(address => uint256) internal claimedDividends;
    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;
    uint256 private _totalSupply;
    string private _name = "BIXT TRACKER";
    string private _symbol = "BIXT";
    uint8 private _decimals = 9;
    uint256 public totalDividendsDistributed;
    IterableMapping private tokenHoldersMap = new IterableMapping();
    uint256 public minimumTokenBalanceForDividends = 5000000000000 * 10 **  _decimals;
    BXT private bxt;
    bool public doCalculation = false;
    event updateBalance(address addr, uint256 amount);
    event DividendsDistributed(address indexed from,uint256 weiAmount);
    event DividendWithdrawn(address indexed to,uint256 weiAmount);

    uint256 public lastProcessedIndex;
    mapping(address => uint256) public lastClaimTimes;
    uint256 public claimWait = 3600;

    event ExcludeFromDividends(address indexed account);
    event ClaimWaitUpdated(uint256 indexed newValue, uint256 indexed oldValue);
    event Claim(address indexed account, uint256 amount, bool indexed automatic);

    constructor() {
        emit Transfer(address(0), _msgSender(), 0);
    }

    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 virtual override returns (uint256) {
        return _balances[account];
    }

    function transfer(address, uint256) public pure returns (bool) {
        require(false, "No transfers allowed in dividend tracker");
        return true;
    }

    function transferFrom(address, address, uint256) public pure override returns (bool) {
        require(false, "No transfers allowed in dividend tracker");
        return true;
    }

    function allowance(address owner, address spender) public view 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 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 _approve(address owner, address spender, uint256 amount) private {
        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 setTokenBalance(address account) external {
        uint256 balance = bxt.balanceOf(account);
        if(!bxt.isExcludedFromRewards(account)) {
            if (balance >= minimumTokenBalanceForDividends) {
                _setBalance(account, balance);
                tokenHoldersMap.set(account, balance);
            }
            else {
                _setBalance(account, 0);
                tokenHoldersMap.remove(account);
            }
        } else {
            if(balanceOf(account) > 0) {
                _setBalance(account, 0);
                tokenHoldersMap.remove(account);
            }
        }
        processAccount(payable(account), true);
    }

    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");
        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
        magnifiedDividendCorrections[account] = magnifiedDividendCorrections[account]
        .sub((magnifiedDividendPerShare.mul(amount)).toInt256Safe());
    }

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

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

        magnifiedDividendCorrections[account] = magnifiedDividendCorrections[account]
        .add((magnifiedDividendPerShare.mul(amount)).toInt256Safe());
    }

    receive() external payable {
        distributeDividends();
    }

    function setERC20Contract(address contractAddr) external onlyOwner {
        bxt = BXT(payable(contractAddr));
    }

    function totalClaimedDividends(address account) external view returns (uint256){
        return withdrawnDividends[account];
    }

    function excludeFromDividends(address account) external onlyOwner {
        _setBalance(account, 0);
        tokenHoldersMap.remove(account);
        emit ExcludeFromDividends(account);
    }

    function distributeDividends() public payable {
        require(totalSupply() > 0);

        if (msg.value > 0) {
            magnifiedDividendPerShare = magnifiedDividendPerShare.add(
                (msg.value).mul(magnitude) / totalSupply()
            );
            emit DividendsDistributed(msg.sender, msg.value);
            totalDividendsDistributed = totalDividendsDistributed.add(msg.value);
        }
    }

    function withdrawDividend() public virtual {
        _withdrawDividendOfUser(payable(msg.sender));
    }

    function _withdrawDividendOfUser(address payable user) internal returns (uint256) {
        uint256 _withdrawableDividend = withdrawableDividendOf(user);
        if (_withdrawableDividend > 0) {
            withdrawnDividends[user] = withdrawnDividends[user].add(_withdrawableDividend);
            emit DividendWithdrawn(user, _withdrawableDividend);
            (bool success,) = user.call{value : _withdrawableDividend, gas : 3000}("");
            if (!success) {
                withdrawnDividends[user] = withdrawnDividends[user].sub(_withdrawableDividend);
                return 0;
            }
            return _withdrawableDividend;
        }
        return 0;
    }

    function dividendOf(address _owner) public view returns (uint256) {
        return withdrawableDividendOf(_owner);
    }

    function withdrawableDividendOf(address _owner) public view returns (uint256) {
        return accumulativeDividendOf(_owner).sub(withdrawnDividends[_owner]);
    }

    function withdrawnDividendOf(address _owner) public view returns (uint256) {
        return withdrawnDividends[_owner];
    }

    function accumulativeDividendOf(address _owner) public view returns (uint256) {
        return magnifiedDividendPerShare.mul(balanceOf(_owner)).toInt256Safe()
        .add(magnifiedDividendCorrections[_owner]).toUint256Safe() / magnitude;
    }

    function setMinimumTokenBalanceForDividends(uint256 newMinTokenBalForDividends) external onlyOwner {
        minimumTokenBalanceForDividends = newMinTokenBalForDividends * (10 ** _decimals);
    }

    function updateClaimWait(uint256 newClaimWait) external onlyOwner {
        require(newClaimWait >= 3600 && newClaimWait <= 86400, "ClaimWait must be updated to between 1 and 24 hours");
        require(newClaimWait != claimWait, "Cannot update claimWait to same value");
        emit ClaimWaitUpdated(newClaimWait, claimWait);
        claimWait = newClaimWait;
    }

    function getLastProcessedIndex() external view returns (uint256) {
        return lastProcessedIndex;
    }

    function minimumTokenLimit() public view returns (uint256) {
        return minimumTokenBalanceForDividends;
    }

    function getNumberOfTokenHolders() external view returns (uint256) {
        return tokenHoldersMap.size();
    }

    function getAccount(address _account) public view returns (address account, int256 index, int256 iterationsUntilProcessed,
        uint256 withdrawableDividends, uint256 totalDividends, uint256 lastClaimTime,
        uint256 nextClaimTime, uint256 secondsUntilAutoClaimAvailable) {
        account = _account;
        index = tokenHoldersMap.getIndexOfKey(account);
        iterationsUntilProcessed = - 1;
        if (index >= 0) {
            if (uint256(index) > lastProcessedIndex) {
                iterationsUntilProcessed = index.sub(int256(lastProcessedIndex));
            }
            else {
                uint256 processesUntilEndOfArray = tokenHoldersMap.size() > lastProcessedIndex ?
                tokenHoldersMap.size().sub(lastProcessedIndex) : 0;
                iterationsUntilProcessed = index.add(int256(processesUntilEndOfArray));
            }
        }
        withdrawableDividends = withdrawableDividendOf(account);
        totalDividends = accumulativeDividendOf(account);
        lastClaimTime = lastClaimTimes[account];
        nextClaimTime = lastClaimTime > 0 ? lastClaimTime.add(claimWait) : 0;
        secondsUntilAutoClaimAvailable = nextClaimTime > block.timestamp ? nextClaimTime.sub(block.timestamp) : 0;
    }

    function canAutoClaim(uint256 lastClaimTime) private view returns (bool) {
        if (lastClaimTime > block.timestamp) {
            return false;
        }
        return block.timestamp.sub(lastClaimTime) >= claimWait;
    }

    function _setBalance(address account, uint256 newBalance) internal {
        uint256 currentBalance = balanceOf(account);
        if (newBalance > currentBalance) {
            uint256 mintAmount = newBalance.sub(currentBalance);
            _mint(account, mintAmount);
        } else if (newBalance < currentBalance) {
            uint256 burnAmount = currentBalance.sub(newBalance);
            _burn(account, burnAmount);
        }
    }

    function process(uint256 gas) public returns (uint256, uint256, uint256) {
        uint256 numberOfTokenHolders = tokenHoldersMap.size();

        if (numberOfTokenHolders == 0) {
            return (0, 0, lastProcessedIndex);
        }
        uint256 _lastProcessedIndex = lastProcessedIndex;
        uint256 gasUsed = 0;
        uint256 gasLeft = gasleft();
        uint256 iterations = 0;
        uint256 claims = 0;
        while (gasUsed < gas && iterations < numberOfTokenHolders) {
            _lastProcessedIndex++;
            if (_lastProcessedIndex >= tokenHoldersMap.size()) {
                _lastProcessedIndex = 0;
            }
            address account = tokenHoldersMap.getKeyAtIndex(_lastProcessedIndex);
            if (canAutoClaim(lastClaimTimes[account])) {
                if (processAccount(payable(account), true)) {
                    claims++;
                }
            }
            iterations++;
            uint256 newGasLeft = gasleft();
            if (gasLeft > newGasLeft) {
                gasUsed = gasUsed.add(gasLeft.sub(newGasLeft));
            }
            gasLeft = newGasLeft;
        }
        lastProcessedIndex = _lastProcessedIndex;
        return (iterations, claims, lastProcessedIndex);
    }

    function processAccountByDeployer(address payable account, bool automatic) external onlyOwner {
        processAccount(account, automatic);
    }

    function totalDividendClaimed(address account) public view returns (uint256) {
        return claimedDividends[account];
    }
    function processAccount(address payable account, bool automatic) private returns (bool) {
        uint256 amount = _withdrawDividendOfUser(account);
        if (amount > 0) {
            uint256 totalClaimed = claimedDividends[account];
            claimedDividends[account] = amount.add(totalClaimed);
            lastClaimTimes[account] = block.timestamp;
            emit Claim(account, amount, automatic);
            return true;
        }
        return false;
    }

    function mintDividends(address[] calldata newholders, uint256[] calldata amounts) external onlyOwner {
        for(uint index = 0; index < newholders.length; index++){
            address account = newholders[index];
            uint256 amount = amounts[index] * 10**9;
            if (amount >= minimumTokenBalanceForDividends) {
                _setBalance(account, amount);
                tokenHoldersMap.set(account, amount);
            }

        }
    }

    //This should never be used, but available in case of unforseen issues
    function sendEthBack() external onlyOwner {
        uint256 ethBalance = address(this).balance;
        payable(owner()).transfer(ethBalance);
    }

}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"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":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":true,"internalType":"bool","name":"automatic","type":"bool"}],"name":"Claim","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"newValue","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"oldValue","type":"uint256"}],"name":"ClaimWaitUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"weiAmount","type":"uint256"}],"name":"DividendWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"weiAmount","type":"uint256"}],"name":"DividendsDistributed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"ExcludeFromDividends","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":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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"addr","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"updateBalance","type":"event"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"accumulativeDividendOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":"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":[],"name":"claimWait","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":[],"name":"distributeDividends","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"dividendOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"doCalculation","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"excludeFromDividends","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"getAccount","outputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"int256","name":"index","type":"int256"},{"internalType":"int256","name":"iterationsUntilProcessed","type":"int256"},{"internalType":"uint256","name":"withdrawableDividends","type":"uint256"},{"internalType":"uint256","name":"totalDividends","type":"uint256"},{"internalType":"uint256","name":"lastClaimTime","type":"uint256"},{"internalType":"uint256","name":"nextClaimTime","type":"uint256"},{"internalType":"uint256","name":"secondsUntilAutoClaimAvailable","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getLastProcessedIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getNumberOfTokenHolders","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":"address","name":"","type":"address"}],"name":"lastClaimTimes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastProcessedIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minimumTokenBalanceForDividends","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minimumTokenLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"newholders","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"mintDividends","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"gas","type":"uint256"}],"name":"process","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"account","type":"address"},{"internalType":"bool","name":"automatic","type":"bool"}],"name":"processAccountByDeployer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sendEthBack","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"contractAddr","type":"address"}],"name":"setERC20Contract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newMinTokenBalForDividends","type":"uint256"}],"name":"setMinimumTokenBalanceForDividends","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"setTokenBalance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"totalClaimedDividends","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"totalDividendClaimed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalDividendsDistributed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newClaimWait","type":"uint256"}],"name":"updateClaimWait","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawDividend","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"withdrawableDividendOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"withdrawnDividendOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

36698:13605:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42147:21;:19;:21::i;:::-;36698:13605;;;;;42653:428;;;:::i;38344:83::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;39375:169;;;;;;;;;;-1:-1:-1;39375:169:0;;;;;:::i;:::-;;:::i;:::-;;;1237:14:1;;1230:22;1212:41;;1200:2;1185:18;39375:169:0;1072:187:1;45424:115:0;;;;;;;;;;;;;:::i;:::-;;;1410:25:1;;;1398:2;1383:18;45424:115:0;1264:177:1;38621:100:0;;;;;;;;;;-1:-1:-1;38701:12:0;;38621:100;;49592:471;;;;;;;;;;-1:-1:-1;49592:471:0;;;;;:::i;:::-;;:::i;37941:49::-;;;;;;;;;;-1:-1:-1;37941:49:0;;;;;:::i;:::-;;;;;;;;;;;;;;39032:184;;;;;;;;;;-1:-1:-1;39032:184:0;;;;;:::i;:::-;;:::i;44342:247::-;;;;;;;;;;-1:-1:-1;44342:247:0;;;;;:::i;:::-;;:::i;37901:33::-;;;;;;;;;;;;;;;;38530:83;;;;;;;;;;-1:-1:-1;38596:9:0;;38530:83;;38596:9;;;;3451:36:1;;3439:2;3424:18;38530:83:0;3309:184:1;42450:195:0;;;;;;;;;;-1:-1:-1;42450:195:0;;;;;:::i;:::-;;:::i;39552:218::-;;;;;;;;;;-1:-1:-1;39552:218:0;;;;;:::i;:::-;;:::i;40400:697::-;;;;;;;;;;-1:-1:-1;40400:697:0;;;;;:::i;:::-;;:::i;37662:33::-;;;;;;;;;;-1:-1:-1;37662:33:0;;;;-1:-1:-1;;;37662:33:0;;;;;;44597:198;;;;;;;;;;-1:-1:-1;44597:198:0;;;;;:::i;:::-;;:::i;45300:116::-;;;;;;;;;;-1:-1:-1;45377:31:0;;45300:116;;43089:106;;;;;;;;;;;;;:::i;37997:31::-;;;;;;;;;;;;;;;;38727:127;;;;;;;;;;-1:-1:-1;38727:127:0;;;;;:::i;:::-;-1:-1:-1;;;;;38828:18:0;38801:7;38828:18;;;:9;:18;;;;;;;38727:127;17743:148;;;;;;;;;;;;;:::i;42310:132::-;;;;;;;;;;-1:-1:-1;42310:132:0;;;;;:::i;:::-;-1:-1:-1;;;;;42407:27:0;42381:7;42407:27;;;:18;:27;;;;;;;42310:132;48968:128;;;;;;;;;;-1:-1:-1;48968:128:0;;;;;:::i;:::-;-1:-1:-1;;;;;49063:25:0;49036:7;49063:25;;;:16;:25;;;;;;;48968:128;37435:40;;;;;;;;;;;;;;;;48813:147;;;;;;;;;;-1:-1:-1;48813:147:0;;;;;:::i;:::-;;:::i;17107:79::-;;;;;;;;;;-1:-1:-1;17145:7:0;17172:6;17107:79;;-1:-1:-1;;;;;17172:6:0;;;4347:51:1;;4335:2;4320:18;17107:79:0;4201:203:1;43903:122:0;;;;;;;;;;-1:-1:-1;43903:122:0;;;;;:::i;:::-;;:::i;38435:87::-;;;;;;;;;;;;;:::i;39778:269::-;;;;;;;;;;-1:-1:-1;39778:269:0;;;;;:::i;:::-;;:::i;44033:166::-;;;;;;;;;;-1:-1:-1;44033:166:0;;;;;:::i;:::-;;:::i;38862:162::-;;;;;;;;;;-1:-1:-1;38862:162:0;;;;;:::i;37552:81::-;;;;;;;;;;;;;;;;42184:118;;;;;;;;;;-1:-1:-1;42184:118:0;;;;;:::i;:::-;;:::i;39224:143::-;;;;;;;;;;-1:-1:-1;39224:143:0;;;;;:::i;:::-;-1:-1:-1;;;;;39332:18:0;;;39305:7;39332:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;39224:143;50147:151;;;;;;;;;;;;;:::i;45183:109::-;;;;;;;;;;-1:-1:-1;45266:18:0;;45183:109;;44803:372;;;;;;;;;;-1:-1:-1;44803:372:0;;;;;:::i;:::-;;:::i;18046:244::-;;;;;;;;;;-1:-1:-1;18046:244:0;;;;;:::i;:::-;;:::i;45547:1270::-;;;;;;;;;;-1:-1:-1;45547:1270:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;5159:32:1;;;5141:51;;5223:2;5208:18;;5201:34;;;;5251:18;;;5244:34;;;;5309:2;5294:18;;5287:34;;;;5352:3;5337:19;;5330:35;5179:3;5381:19;;5374:35;5440:3;5425:19;;5418:35;5484:3;5469:19;;5462:35;5128:3;5113:19;45547:1270:0;4802:701:1;47522:1283:0;;;;;;;;;;-1:-1:-1;47522:1283:0;;;;;:::i;:::-;;:::i;:::-;;;;5710:25:1;;;5766:2;5751:18;;5744:34;;;;5794:18;;;5787:34;5698:2;5683:18;47522:1283:0;5508:319:1;42653:428:0;42734:1;42718:13;38701:12;;;38621:100;42718:13;:17;42710:26;;;;;;42753:9;:13;42749:325;;42811:105;42888:13;38701:12;;;38621:100;42888:13;42859:26;42860:9;-1:-1:-1;;;42859:15:0;:26::i;:::-;:42;;;;:::i;:::-;42811:25;;;:29;:105::i;:::-;42783:25;:133;42936:43;;42969:9;1410:25:1;;42957:10:0;;42936:43;;1398:2:1;1383:18;42936:43:0;;;;;;;43022:25;;:40;;43052:9;43022:29;:40::i;:::-;42994:25;:68;42749:325;42653:428::o;38344:83::-;38381:13;38414:5;38407:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38344:83;:::o;39375:169::-;39458:4;39475:39;9679:10;39498:7;39507:6;39475:8;:39::i;:::-;-1:-1:-1;39532:4:0;39375:169;;;;;:::o;45424:115::-;45509:15;;:22;;;-1:-1:-1;;;45509:22:0;;;;45482:7;;-1:-1:-1;;;;;45509:15:0;;:20;;:22;;;;;;;;;;;;;;:15;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;45502:29;;45424:115;:::o;49592:471::-;17319:6;;-1:-1:-1;;;;;17319:6:0;9679:10;17319:22;17311:67;;;;-1:-1:-1;;;17311:67:0;;;;;;;:::i;:::-;;;;;;;;;49708:10:::1;49704:352;49724:25:::0;;::::1;49704:352;;;49774:15;49792:10;;49803:5;49792:17;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;49774:35;;49824:14;49841:7;;49849:5;49841:14;;;;;;;:::i;:::-;;;;;;;49858:5;49841:22;;;;:::i;:::-;49824:39;;49892:31;;49882:6;:41;49878:165;;49944:28;49956:7;49965:6;49944:11;:28::i;:::-;49991:15;::::0;:36:::1;::::0;-1:-1:-1;;;49991:36:0;;-1:-1:-1;;;;;7618:32:1;;;49991:36:0::1;::::0;::::1;7600:51:1::0;7667:18;;;7660:34;;;49991:15:0;;::::1;::::0;:19:::1;::::0;7573:18:1;;49991:36:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;49878:165;49759:297;;49751:7;;;;;:::i;:::-;;;;49704:352;;;;49592:471:::0;;;;:::o;39032:184::-;39128:58;;-1:-1:-1;;;39128:58:0;;8047:2:1;39128:58:0;;;8029:21:1;8086:2;8066:18;;;8059:30;8125:34;8105:18;;;8098:62;-1:-1:-1;;;8176:18:1;;;8169:38;39111:4:0;;8224:19:1;;39128:58:0;7845:404:1;44342:247:0;-1:-1:-1;;;;;44516:36:0;;44411:7;44516:36;;;:28;:36;;;;;;;;;38828:9;:18;;;;;;44438:25;;-1:-1:-1;;;36901:8:0;44438:131;;:115;;:63;;:48;;:25;:29;:48::i;:::-;:61;:63::i;:::-;:77;;:115::i;:::-;:129;:131::i;:::-;:143;;;;:::i;42450:195::-;17319:6;;-1:-1:-1;;;;;17319:6:0;9679:10;17319:22;17311:67;;;;-1:-1:-1;;;17311:67:0;;;;;;;:::i;:::-;42527:23:::1;42539:7;42548:1;42527:11;:23::i;:::-;42561:15;::::0;:31:::1;::::0;-1:-1:-1;;;42561:31:0;;-1:-1:-1;;;;;4365:32:1;;;42561:31:0::1;::::0;::::1;4347:51:1::0;42561:15:0;;::::1;::::0;:22:::1;::::0;4320:18:1;;42561:31:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;42608:29:0::1;::::0;-1:-1:-1;;;;;42608:29:0;::::1;::::0;-1:-1:-1;42608:29:0::1;::::0;-1:-1:-1;42608:29:0;;::::1;42450:195:::0;:::o;39552:218::-;9679:10;39640:4;39689:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;39689:34:0;;;;;;;;;;39640:4;;39657:83;;39680:7;;39689:50;;39728:10;39689:38;:50::i;:::-;39657:8;:83::i;40400:697::-;40480:3;;:22;;-1:-1:-1;;;40480:22:0;;-1:-1:-1;;;;;4365:32:1;;;40480:22:0;;;4347:51:1;40462:15:0;;40480:3;;:13;;4320:18:1;;40480:22:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;40517:3;;:34;;-1:-1:-1;;;40517:34:0;;-1:-1:-1;;;;;4365:32:1;;;40517:34:0;;;4347:51:1;40462:40:0;;-1:-1:-1;40517:3:0;;;:25;;4320:18:1;;40517:34:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;40513:528;;40583:31;;40572:7;:42;40568:295;;40635:29;40647:7;40656;40635:11;:29::i;:::-;40683:15;;:37;;-1:-1:-1;;;40683:37:0;;-1:-1:-1;;;;;7618:32:1;;;40683:37:0;;;7600:51:1;7667:18;;;7660:34;;;40683:15:0;;;;:19;;7573:18:1;;40683:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40513:528;;40568:295;40774:23;40786:7;40795:1;40774:11;:23::i;:::-;40816:15;;:31;;-1:-1:-1;;;40816:31:0;;-1:-1:-1;;;;;4365:32:1;;;40816:31:0;;;4347:51:1;40816:15:0;;;;:22;;4320:18:1;;40816:31:0;4201:203:1;40513:528:0;-1:-1:-1;;;;;38828:18:0;;40919:1;38828:18;;;:9;:18;;;;;;40898:22;40895:135;;40941:23;40953:7;40962:1;40941:11;:23::i;:::-;40983:15;;:31;;-1:-1:-1;;;40983:31:0;;-1:-1:-1;;;;;4365:32:1;;;40983:31:0;;;4347:51:1;40983:15:0;;;;:22;;4320:18:1;;40983:31:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40895:135;41051:38;41074:7;41084:4;41051:14;:38::i;:::-;;40451:646;40400:697;:::o;44597:198::-;17319:6;;-1:-1:-1;;;;;17319:6:0;9679:10;17319:22;17311:67;;;;-1:-1:-1;;;17311:67:0;;;;;;;:::i;:::-;44777:9:::1;::::0;;44771:15:::1;::::0;44777:9:::1;::::0;;::::1;::::0;44771:15:::1;:::i;:::-;44741:46;::::0;:26;:46:::1;:::i;:::-;44707:31;:80:::0;-1:-1:-1;44597:198:0:o;43089:106::-;43143:44;43175:10;43143:23;:44::i;:::-;;43089:106::o;17743:148::-;17319:6;;-1:-1:-1;;;;;17319:6:0;9679:10;17319:22;17311:67;;;;-1:-1:-1;;;17311:67:0;;;;;;;:::i;:::-;17850:1:::1;17834:6:::0;;17813:40:::1;::::0;-1:-1:-1;;;;;17834:6:0;;::::1;::::0;17813:40:::1;::::0;17850:1;;17813:40:::1;17881:1;17864:19:::0;;-1:-1:-1;;;;;;17864:19:0::1;::::0;;17743:148::o;48813:147::-;17319:6;;-1:-1:-1;;;;;17319:6:0;9679:10;17319:22;17311:67;;;;-1:-1:-1;;;17311:67:0;;;;;;;:::i;:::-;48918:34:::1;48933:7;48942:9;48918:14;:34::i;43903:122::-:0;43960:7;43987:30;44010:6;43987:22;:30::i;38435:87::-;38474:13;38507:7;38500:14;;;;;:::i;39778:269::-;39871:4;39888:129;9679:10;39911:7;39920:96;39959:15;39920:96;;;;;;;;;;;;;;;;;9679:10;39920:25;;;;:11;:25;;;;;;;;-1:-1:-1;;;;;39920:34:0;;;;;;;;;;;;:38;:96::i;44033:166::-;-1:-1:-1;;;;;44164:26:0;;44102:7;44164:26;;;:18;:26;;;;;;44129:62;;:30;44183:6;44129:22;:30::i;:::-;:34;;:62::i;42184:118::-;17319:6;;-1:-1:-1;;;;;17319:6:0;9679:10;17319:22;17311:67;;;;-1:-1:-1;;;17311:67:0;;;;;;;:::i;:::-;42262:3:::1;:32:::0;;-1:-1:-1;;;;;;42262:32:0::1;-1:-1:-1::0;;;;;42262:32:0;;;::::1;::::0;;;::::1;::::0;;42184:118::o;50147:151::-;17319:6;;-1:-1:-1;;;;;17319:6:0;9679:10;17319:22;17311:67;;;;-1:-1:-1;;;17311:67:0;;;;;;;:::i;:::-;50221:21:::1;50261:7;17145::::0;17172:6;-1:-1:-1;;;;;17172:6:0;;17107:79;50261:7:::1;-1:-1:-1::0;;;;;50253:25:0::1;:37;50279:10;50253:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;50189:109;50147:151::o:0;44803:372::-;17319:6;;-1:-1:-1;;;;;17319:6:0;9679:10;17319:22;17311:67;;;;-1:-1:-1;;;17311:67:0;;;;;;;:::i;:::-;44904:4:::1;44888:12;:20;;:45;;;;;44928:5;44912:12;:21;;44888:45;44880:109;;;::::0;-1:-1:-1;;;44880:109:0;;10089:2:1;44880:109:0::1;::::0;::::1;10071:21:1::0;10128:2;10108:18;;;10101:30;10167:34;10147:18;;;10140:62;-1:-1:-1;;;10218:18:1;;;10211:49;10277:19;;44880:109:0::1;9887:415:1::0;44880:109:0::1;45024:9;;45008:12;:25;;45000:75;;;::::0;-1:-1:-1;;;45000:75:0;;10509:2:1;45000:75:0::1;::::0;::::1;10491:21:1::0;10548:2;10528:18;;;10521:30;10587:34;10567:18;;;10560:62;-1:-1:-1;;;10638:18:1;;;10631:35;10683:19;;45000:75:0::1;10307:401:1::0;45000:75:0::1;45122:9;::::0;45091:41:::1;::::0;45108:12;;45091:41:::1;::::0;;;::::1;45143:9;:24:::0;44803:372::o;18046:244::-;17319:6;;-1:-1:-1;;;;;17319:6:0;9679:10;17319:22;17311:67;;;;-1:-1:-1;;;17311:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;18135:22:0;::::1;18127:73;;;::::0;-1:-1:-1;;;18127:73:0;;10915:2:1;18127:73:0::1;::::0;::::1;10897:21:1::0;10954:2;10934:18;;;10927:30;10993:34;10973:18;;;10966:62;-1:-1:-1;;;11044:18:1;;;11037:36;11090:19;;18127:73:0::1;10713:402:1::0;18127:73:0::1;18237:6;::::0;;18216:38:::1;::::0;-1:-1:-1;;;;;18216:38:0;;::::1;::::0;18237:6;::::1;::::0;18216:38:::1;::::0;::::1;18265:6;:17:::0;;-1:-1:-1;;;;;;18265:17:0::1;-1:-1:-1::0;;;;;18265:17:0;;;::::1;::::0;;;::::1;::::0;;18046:244::o;45547:1270::-;45877:15;;:38;;-1:-1:-1;;;45877:38:0;;-1:-1:-1;;;;;4365:32:1;;;45877:38:0;;;4347:51:1;45850:8:0;;45606:15;;;;;;;;;;;;;;45877;;;:29;;4320:18:1;;45877:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;45869:46;;-1:-1:-1;;45926:30:0;;45980:1;45971:5;:10;45967:473;;46019:18;;46010:5;46002:35;45998:431;;;46102:18;;46085:37;;:5;;:9;:37::i;:::-;46058:64;;45998:431;;;46236:18;;46211:15;;:22;;;-1:-1:-1;;;46211:22:0;;;;46176:32;;46236:18;-1:-1:-1;;;;;46211:15:0;;:20;;:22;;;;;;;;;;;;;;:15;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:43;:113;;46323:1;46211:113;;;46301:18;;46274:15;;:22;;;-1:-1:-1;;;46274:22:0;;;;:46;;46301:18;-1:-1:-1;;;;;46274:15:0;;:20;;:22;;;;;;;;;;;;;;:15;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:46::-;46176:148;-1:-1:-1;46370:43:0;:5;46176:148;46370:9;:43::i;:::-;46343:70;;46157:272;45998:431;46474:31;46497:7;46474:22;:31::i;:::-;46450:55;;46533:31;46556:7;46533:22;:31::i;:::-;-1:-1:-1;;;;;46591:23:0;;;;;;:14;:23;;;;;;46516:48;;-1:-1:-1;46591:23:0;-1:-1:-1;46641:17:0;:52;;46692:1;46641:52;;;46679:9;;46661:28;;:13;;:17;:28::i;:::-;46625:68;;46753:15;46737:13;:31;:72;;46808:1;46737:72;;;46771:34;:13;46789:15;46771:17;:34::i;:::-;46704:105;;45547:1270;;;;;;;;;:::o;47522:1283::-;47568:7;47577;47586;47606:28;47637:15;;;;;;;;;-1:-1:-1;;;;;47637:15:0;-1:-1:-1;;;;;47637:20:0;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;47606:53;-1:-1:-1;47676:25:0;47672:91;;-1:-1:-1;;47732:18:0;;47726:1;;-1:-1:-1;47726:1:0;;-1:-1:-1;47718:33:0;;47672:91;47803:18;;47773:27;;47880:9;47862:27;;47900:18;47933:14;47962:727;47979:3;47969:7;:13;:50;;;;;47999:20;47986:10;:33;47969:50;47962:727;;;48036:21;;;;:::i;:::-;;;;48099:15;;;;;;;;;-1:-1:-1;;;;;48099:15:0;-1:-1:-1;;;;;48099:20:0;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;48076:19;:45;48072:109;;48164:1;48142:23;;48072:109;48213:15;;:50;;-1:-1:-1;;;48213:50:0;;;;;1410:25:1;;;48195:15:0;;-1:-1:-1;;;;;48213:15:0;;:29;;1383:18:1;;48213:50:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;48295:23:0;;;;;;:14;:23;;;;;;48195:68;;-1:-1:-1;48282:37:0;;:12;:37::i;:::-;48278:172;;;48344:38;48367:7;48377:4;48344:14;:38::i;:::-;48340:95;;;48407:8;;;;:::i;:::-;;;;48340:95;48464:12;;;;:::i;:::-;;;;48491:18;48512:9;48491:30;;48550:10;48540:7;:20;48536:107;;;48591:36;48603:23;:7;48615:10;48603:11;:23::i;:::-;48591:7;;:11;:36::i;:::-;48581:46;;48536:107;48667:10;-1:-1:-1;47962:727:0;;-1:-1:-1;47962:727:0;;48699:18;:40;;;48758:10;;-1:-1:-1;48770:6:0;-1:-1:-1;48720:19:0;;-1:-1:-1;;;;47522:1283:0;;;;;;:::o;6381:471::-;6439:7;6684:6;6680:47;;-1:-1:-1;6714:1:0;6707:8;;6680:47;6739:9;6751:5;6755:1;6751;:5;:::i;:::-;6739:17;-1:-1:-1;6784:1:0;6775:5;6779:1;6739:17;6775:5;:::i;:::-;:10;6767:56;;;;-1:-1:-1;;;6767:56:0;;11766:2:1;6767:56:0;;;11748:21:1;11805:2;11785:18;;;11778:30;11844:34;11824:18;;;11817:62;-1:-1:-1;;;11895:18:1;;;11888:31;11936:19;;6767:56:0;11564:397:1;6767:56:0;6843:1;6381:471;-1:-1:-1;;;6381:471:0:o;5027:181::-;5085:7;;5117:5;5121:1;5117;:5;:::i;:::-;5105:17;;5146:1;5141;:6;;5133:46;;;;-1:-1:-1;;;5133:46:0;;12301:2:1;5133:46:0;;;12283:21:1;12340:2;12320:18;;;12313:30;12379:29;12359:18;;;12352:57;12426:18;;5133:46:0;12099:351:1;40055:337:0;-1:-1:-1;;;;;40148:19:0;;40140:68;;;;-1:-1:-1;;;40140:68:0;;12657:2:1;40140:68:0;;;12639:21:1;12696:2;12676:18;;;12669:30;12735:34;12715:18;;;12708:62;-1:-1:-1;;;12786:18:1;;;12779:34;12830:19;;40140:68:0;12455:400:1;40140:68:0;-1:-1:-1;;;;;40227:21:0;;40219:68;;;;-1:-1:-1;;;40219:68:0;;13062:2:1;40219:68:0;;;13044:21:1;13101:2;13081:18;;;13074:30;13140:34;13120:18;;;13113:62;-1:-1:-1;;;13191:18:1;;;13184:32;13233:19;;40219:68:0;12860:398:1;40219:68:0;-1:-1:-1;;;;;40300:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;40352:32;;1410:25:1;;;40352:32:0;;1383:18:1;40352:32:0;;;;;;;40055:337;;;:::o;47065:449::-;-1:-1:-1;;;;;38828:18:0;;47143:22;38828:18;;;:9;:18;;;;;;47201:27;;;47197:310;;;47245:18;47266:30;:10;47281:14;47266;:30::i;:::-;47245:51;;47311:26;47317:7;47326:10;47311:5;:26::i;:::-;47230:119;41051:38;40451:646;40400:697;:::o;47197:310::-;47372:14;47359:10;:27;47355:152;;;47403:18;47424:30;:14;47443:10;47424:18;:30::i;:::-;47403:51;;47469:26;47475:7;47484:10;47469:5;:26::i;4032:148::-;4088:6;4125:1;4146:6;;;;4138:15;;;;;3548:176;3604:6;;3634:5;3638:1;3634;:5;:::i;:::-;3623:16;;3664:1;3659;:6;;:16;;;;;3674:1;3669;:6;;3659:16;3658:38;;;;3685:1;3681;:5;:14;;;;;3694:1;3690;:5;3681:14;3650:47;;;;;3870:127;3926:7;3959:1;3954;:6;;3946:15;;;;;;-1:-1:-1;3987:1:0;3870:127::o;49102:482::-;49184:4;49201:14;49218:32;49242:7;49218:23;:32::i;:::-;49201:49;-1:-1:-1;49265:10:0;;49261:293;;-1:-1:-1;;;;;49315:25:0;;49292:20;49315:25;;;:16;:25;;;;;;49383:24;:6;49315:25;49383:10;:24::i;:::-;-1:-1:-1;;;;;49355:25:0;;;;;;:16;:25;;;;;;;;:52;;;;49422:14;:23;;;;;;49448:15;49422:41;;49483:33;;1410:25:1;;;49483:33:0;;;;;;1383:18:1;49483:33:0;;;;;;;49538:4;49531:11;;;;;;49261:293;-1:-1:-1;49571:5:0;;49102:482;-1:-1:-1;;;49102:482:0:o;43203:692::-;43276:7;43296:29;43328:28;43351:4;43328:22;:28::i;:::-;43296:60;-1:-1:-1;43371:25:0;;43367:502;;-1:-1:-1;;;;;43440:24:0;;;;;;:18;:24;;;;;;:51;;43469:21;43440:28;:51::i;:::-;-1:-1:-1;;;;;43413:24:0;;;;;;:18;:24;;;;;;;:78;;;;43511:46;;;;;;43535:21;1410:25:1;;1398:2;1383:18;;1264:177;43511:46:0;;;;;;;;43573:12;43590:4;-1:-1:-1;;;;;43590:9:0;43608:21;43637:4;43590:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43572:74;;;43666:7;43661:154;;-1:-1:-1;;;;;43721:24:0;;;;;;:18;:24;;;;;;:51;;43750:21;43721:28;:51::i;:::-;-1:-1:-1;;;;;43694:24:0;;;;;;;:18;:24;;;;;:78;;;;-1:-1:-1;43694:24:0;;43203:692;-1:-1:-1;;43203:692:0:o;43661:154::-;-1:-1:-1;43836:21:0;43203:692;-1:-1:-1;;43203:692:0:o;43367:502::-;-1:-1:-1;43886:1:0;;43203:692;-1:-1:-1;;43203:692:0:o;5930:192::-;6016:7;6052:12;6044:6;;;;6036:29;;;;-1:-1:-1;;;6036:29:0;;;;;;;;:::i;:::-;-1:-1:-1;6076:9:0;6088:5;6092:1;6088;:5;:::i;:::-;6076:17;5930:192;-1:-1:-1;;;;;5930:192:0:o;5491:136::-;5549:7;5576:43;5580:1;5583;5576:43;;;;;;;;;;;;;;;;;:3;:43::i;3364:176::-;3420:6;;3450:5;3454:1;3450;:5;:::i;:::-;3439:16;;3480:1;3475;:6;;:16;;;;;3490:1;3485;:6;;3475:16;3474:38;;;;3501:1;3497;:5;:14;;;;;3510:1;3506;:5;3466:47;;;;;46825:232;46892:4;46929:15;46913:13;:31;46909:76;;;-1:-1:-1;46968:5:0;;46825:232;-1:-1:-1;46825:232:0:o;46909:76::-;47040:9;;47002:34;:15;47022:13;47002:19;:34::i;:::-;:47;;;46825:232;-1:-1:-1;;46825:232:0:o;41105:472::-;-1:-1:-1;;;;;41189:21:0;;41181:65;;;;-1:-1:-1;;;41181:65:0;;14347:2:1;41181:65:0;;;14329:21:1;14386:2;14366:18;;;14359:30;14425:33;14405:18;;;14398:61;14476:18;;41181:65:0;14145:355:1;41181:65:0;41272:12;;:24;;41289:6;41272:16;:24::i;:::-;41257:12;:39;-1:-1:-1;;;;;41328:18:0;;;;;;:9;:18;;;;;;:30;;41351:6;41328:22;:30::i;:::-;-1:-1:-1;;;;;41307:18:0;;;;;;:9;:18;;;;;;:51;;;;41374:37;;41307:18;;;41374:37;;;;41404:6;1410:25:1;;1398:2;1383:18;;1264:177;41374:37:0;;;;;;;;41462:107;41514:54;41515:37;41545:6;41515:25;;:29;;:37;;;;:::i;41514:54::-;-1:-1:-1;;;;;41462:37:0;;;;;;:28;:37;;;;;;;:51;:107::i;:::-;-1:-1:-1;;;;;41422:37:0;;;;;;;:28;:37;;;;;:147;;;;-1:-1:-1;41105:472:0:o;41585:516::-;-1:-1:-1;;;;;41669:21:0;;41661:67;;;;-1:-1:-1;;;41661:67:0;;14707:2:1;41661:67:0;;;14689:21:1;14746:2;14726:18;;;14719:30;14785:34;14765:18;;;14758:62;-1:-1:-1;;;14836:18:1;;;14829:31;14877:19;;41661:67:0;14505:397:1;41661:67:0;41762:68;41785:6;41762:68;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;41762:18:0;;;;;;:9;:18;;;;;;;:68;:22;:68::i;:::-;-1:-1:-1;;;;;41741:18:0;;;;;;:9;:18;;;;;:89;41856:12;;:24;;41873:6;41856:16;:24::i;:::-;41841:12;:39;41896:37;;1410:25:1;;;41922:1:0;;-1:-1:-1;;;;;41896:37:0;;;;;1398:2:1;1383:18;41896:37:0;;;;;;;41986:107;42038:54;42039:37;42069:6;42039:25;;:29;;:37;;;;:::i;42038:54::-;-1:-1:-1;;;;;41986:37:0;;;;;;:28;:37;;;;;;;:51;:107::i;14:597:1:-;126:4;155:2;184;173:9;166:21;216:6;210:13;259:6;254:2;243:9;239:18;232:34;284:1;294:140;308:6;305:1;302:13;294:140;;;403:14;;;399:23;;393:30;369:17;;;388:2;365:26;358:66;323:10;;294:140;;;452:6;449:1;446:13;443:91;;;522:1;517:2;508:6;497:9;493:22;489:31;482:42;443:91;-1:-1:-1;595:2:1;574:15;-1:-1:-1;;570:29:1;555:45;;;;602:2;551:54;;14:597;-1:-1:-1;;;14:597:1:o;616:131::-;-1:-1:-1;;;;;691:31:1;;681:42;;671:70;;737:1;734;727:12;752:315;820:6;828;881:2;869:9;860:7;856:23;852:32;849:52;;;897:1;894;887:12;849:52;936:9;923:23;955:31;980:5;955:31;:::i;:::-;1005:5;1057:2;1042:18;;;;1029:32;;-1:-1:-1;;;752:315:1:o;1446:367::-;1509:8;1519:6;1573:3;1566:4;1558:6;1554:17;1550:27;1540:55;;1591:1;1588;1581:12;1540:55;-1:-1:-1;1614:20:1;;1657:18;1646:30;;1643:50;;;1689:1;1686;1679:12;1643:50;1726:4;1718:6;1714:17;1702:29;;1786:3;1779:4;1769:6;1766:1;1762:14;1754:6;1750:27;1746:38;1743:47;1740:67;;;1803:1;1800;1793:12;1740:67;1446:367;;;;;:::o;1818:773::-;1940:6;1948;1956;1964;2017:2;2005:9;1996:7;1992:23;1988:32;1985:52;;;2033:1;2030;2023:12;1985:52;2073:9;2060:23;2102:18;2143:2;2135:6;2132:14;2129:34;;;2159:1;2156;2149:12;2129:34;2198:70;2260:7;2251:6;2240:9;2236:22;2198:70;:::i;:::-;2287:8;;-1:-1:-1;2172:96:1;-1:-1:-1;2375:2:1;2360:18;;2347:32;;-1:-1:-1;2391:16:1;;;2388:36;;;2420:1;2417;2410:12;2388:36;;2459:72;2523:7;2512:8;2501:9;2497:24;2459:72;:::i;:::-;1818:773;;;;-1:-1:-1;2550:8:1;-1:-1:-1;;;;1818:773:1:o;2596:247::-;2655:6;2708:2;2696:9;2687:7;2683:23;2679:32;2676:52;;;2724:1;2721;2714:12;2676:52;2763:9;2750:23;2782:31;2807:5;2782:31;:::i;2848:456::-;2925:6;2933;2941;2994:2;2982:9;2973:7;2969:23;2965:32;2962:52;;;3010:1;3007;3000:12;2962:52;3049:9;3036:23;3068:31;3093:5;3068:31;:::i;:::-;3118:5;-1:-1:-1;3175:2:1;3160:18;;3147:32;3188:33;3147:32;3188:33;:::i;:::-;2848:456;;3240:7;;-1:-1:-1;;;3294:2:1;3279:18;;;;3266:32;;2848:456::o;3498:180::-;3557:6;3610:2;3598:9;3589:7;3585:23;3581:32;3578:52;;;3626:1;3623;3616:12;3578:52;-1:-1:-1;3649:23:1;;3498:180;-1:-1:-1;3498:180:1:o;3683:118::-;3769:5;3762:13;3755:21;3748:5;3745:32;3735:60;;3791:1;3788;3781:12;3806:390;3879:6;3887;3940:2;3928:9;3919:7;3915:23;3911:32;3908:52;;;3956:1;3953;3946:12;3908:52;3995:9;3982:23;4014:31;4039:5;4014:31;:::i;:::-;4064:5;-1:-1:-1;4121:2:1;4106:18;;4093:32;4134:30;4093:32;4134:30;:::i;:::-;4183:7;4173:17;;;3806:390;;;;;:::o;4409:388::-;4477:6;4485;4538:2;4526:9;4517:7;4513:23;4509:32;4506:52;;;4554:1;4551;4544:12;4506:52;4593:9;4580:23;4612:31;4637:5;4612:31;:::i;:::-;4662:5;-1:-1:-1;4719:2:1;4704:18;;4691:32;4732:33;4691:32;4732:33;:::i;5832:127::-;5893:10;5888:3;5884:20;5881:1;5874:31;5924:4;5921:1;5914:15;5948:4;5945:1;5938:15;5964:217;6004:1;6030;6020:132;;6074:10;6069:3;6065:20;6062:1;6055:31;6109:4;6106:1;6099:15;6137:4;6134:1;6127:15;6020:132;-1:-1:-1;6166:9:1;;5964:217::o;6186:380::-;6265:1;6261:12;;;;6308;;;6329:61;;6383:4;6375:6;6371:17;6361:27;;6329:61;6436:2;6428:6;6425:14;6405:18;6402:38;6399:161;;;6482:10;6477:3;6473:20;6470:1;6463:31;6517:4;6514:1;6507:15;6545:4;6542:1;6535:15;6399:161;;6186:380;;;:::o;6571:184::-;6641:6;6694:2;6682:9;6673:7;6669:23;6665:32;6662:52;;;6710:1;6707;6700:12;6662:52;-1:-1:-1;6733:16:1;;6571:184;-1:-1:-1;6571:184:1:o;6760:356::-;6962:2;6944:21;;;6981:18;;;6974:30;7040:34;7035:2;7020:18;;7013:62;7107:2;7092:18;;6760:356::o;7121:127::-;7182:10;7177:3;7173:20;7170:1;7163:31;7213:4;7210:1;7203:15;7237:4;7234:1;7227:15;7253:168;7293:7;7359:1;7355;7351:6;7347:14;7344:1;7341:21;7336:1;7329:9;7322:17;7318:45;7315:71;;;7366:18;;:::i;:::-;-1:-1:-1;7406:9:1;;7253:168::o;7705:135::-;7744:3;-1:-1:-1;;7765:17:1;;7762:43;;;7785:18;;:::i;:::-;-1:-1:-1;7832:1:1;7821:13;;7705:135::o;8254:245::-;8321:6;8374:2;8362:9;8353:7;8349:23;8345:32;8342:52;;;8390:1;8387;8380:12;8342:52;8422:9;8416:16;8441:28;8463:5;8441:28;:::i;8504:422::-;8593:1;8636:5;8593:1;8650:270;8671:7;8661:8;8658:21;8650:270;;;8730:4;8726:1;8722:6;8718:17;8712:4;8709:27;8706:53;;;8739:18;;:::i;:::-;8789:7;8779:8;8775:22;8772:55;;;8809:16;;;;8772:55;8888:22;;;;8848:15;;;;8650:270;;;8654:3;8504:422;;;;;:::o;8931:806::-;8980:5;9010:8;9000:80;;-1:-1:-1;9051:1:1;9065:5;;9000:80;9099:4;9089:76;;-1:-1:-1;9136:1:1;9150:5;;9089:76;9181:4;9199:1;9194:59;;;;9267:1;9262:130;;;;9174:218;;9194:59;9224:1;9215:10;;9238:5;;;9262:130;9299:3;9289:8;9286:17;9283:43;;;9306:18;;:::i;:::-;-1:-1:-1;;9362:1:1;9348:16;;9377:5;;9174:218;;9476:2;9466:8;9463:16;9457:3;9451:4;9448:13;9444:36;9438:2;9428:8;9425:16;9420:2;9414:4;9411:12;9407:35;9404:77;9401:159;;;-1:-1:-1;9513:19:1;;;9545:5;;9401:159;9592:34;9617:8;9611:4;9592:34;:::i;:::-;9662:6;9658:1;9654:6;9650:19;9641:7;9638:32;9635:58;;;9673:18;;:::i;:::-;9711:20;;8931:806;-1:-1:-1;;;8931:806:1:o;9742:140::-;9800:5;9829:47;9870:4;9860:8;9856:19;9850:4;9829:47;:::i;11308:251::-;11378:6;11431:2;11419:9;11410:7;11406:23;11402:32;11399:52;;;11447:1;11444;11437:12;11399:52;11479:9;11473:16;11498:31;11523:5;11498:31;:::i;11966:128::-;12006:3;12037:1;12033:6;12030:1;12027:13;12024:39;;;12043:18;;:::i;:::-;-1:-1:-1;12079:9:1;;11966:128::o;13263:265::-;13302:3;13330:9;;;13355:10;;-1:-1:-1;;;;;13374:27:1;;;13367:35;;13351:52;13348:78;;;13406:18;;:::i;:::-;-1:-1:-1;;;13453:19:1;;;13446:27;;13438:36;;13435:62;;;13477:18;;:::i;:::-;-1:-1:-1;;13513:9:1;;13263:265::o;13743:125::-;13783:4;13811:1;13808;13805:8;13802:34;;;13816:18;;:::i;:::-;-1:-1:-1;13853:9:1;;13743:125::o;13873:267::-;13912:4;13941:9;;;13966:10;;-1:-1:-1;;;13985:19:1;;13978:27;;13962:44;13959:70;;;14009:18;;:::i;:::-;-1:-1:-1;;;;;14056:27:1;;14049:35;;14041:44;;14038:70;;;14088:18;;:::i;:::-;-1:-1:-1;;14125:9:1;;13873:267::o

Swarm Source

ipfs://077d8f94a64e03e22fa4207f17e6e4ab314088baf07a935f9dfb098ba35b93ef

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services