Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

interface IERC20    - function totalSupply()    - function balanceOf(address account)    - function transfer(address recipient, ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom( interface IFactory    - function createPair(address tokenA, a ...    - function getPair(address tokenA, addr ... interface IRouter    - function factory()    - function WETH()    - function addLiquidityETH(    - function swapExactETHForTokensSupport ...    - function swapExactTokensForETHSupport ... interface IERC20Metadata is IERC20    - function name()    - function symbol()    - function decimals() interface defaultDividendTokenInterfa ...    - function dividendOf(address _owner)    - function withdrawDividend() interface defaultDividendTokenOptiona ...    - function withdrawableDividendOf(addre ...    - function withdrawnDividendOf(address ...    - function accumulativeDividendOf(addre ... library SafeMath    - function add(uint256 a, uint256 b)    - function sub(uint256 a, uint256 b)    - function sub(    - function mul(uint256 a, uint256 b)    - function div(uint256 a, uint256 b)    - function div(    - function mod(uint256 a, uint256 b)    - function mod( library SafeMathInt    - function mul(int256 a, int256 b)    - function div(int256 a, int256 b)    - function sub(int256 a, int256 b)    - function add(int256 a, int256 b)    - function abs(int256 a)    - function toUint256Safe(int256 a) library SafeMathUint    - function toInt256Safe(uint256 a)    - function _msgSender()    - function _msgData()  contract Ownable is Context    - function owner()    - function renounceOwnership()    - function transferOwnership(address ne ...  contract ERC20 is Context, IERC20, ...    - function name()    - function symbol()    - function decimals()    - function totalSupply()    - function balanceOf(address account)    - function transfer(address recipient, ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom(    - function increaseAllowance(address sp ...    - function decreaseAllowance(address sp ...    - function _transfer(    - function _mint(address account, uint2 ...    - function _burn(address account, uint2 ...    - function _approve(    - function _beforeTokenTransfer(  contract defaultDividendToken is    - function distributeDividendsUsingAmou ...    - function withdrawDividend()    - function _withdrawDividendOfUser(addr ...    - function dividendOf(address _owner)    - function withdrawableDividendOf(addre ...    - function withdrawnDividendOf(address ...    - function accumulativeDividendOf(addre ...    - function _transfer(    - function _mint(address account, uint2 ...    - function _burn(address account, uint2 ...    - function _setBalance(address account, ...    - function _setAssetTrackToken(address ...    - function _setUniswapRouter(address ro ...  contract StabilizerProtocol is Own ...    - function activateTrading()    - function _setAutomatedMarketMakerPair ...    - function allowTradingWhenDisabled(add ...    - function excludeFromFees(address acco ...    - function removeLimits()    - function excludeFromDividends(address ...    - function excludeFromMaxTransactionLim ...    - function excludeFromMaxWalletLimit(ad ...    - function setWallets(address newLiquid ...    - function setBaseFeesOnBuy(    - function setBaseFeesOnSell(    - function setUniswapRouter(address new ...    - function setMaxTransactionAmount(uint ...    - function setMaxWalletAmount(uint256 n ...    - function setMinimumTokensBeforeSwap(u ...    - function setMinimumTokenBalanceForDiv ...    - function claim()    - function claimETHOverflow(uint256 amo ...    - function _addLiquidity(uint256 tokenA ...    - function minTokenAllowance(    - function burn(uint256 value)    - function getTotaldividendDistributed( ...    - function withdrawableDividendOf(addre ...    - function rdTokenBalanceOf(address acc ...    - function getBaseBuyFees()    - function getBaseSellFees()    - function _transfer(    - function _adjustTaxes(bool isBuyFromL ...    - function _setCustomSellTaxPeriod(    - function _setCustomBuyTaxPeriod(    - function _swapAndLiquify()    - function _swapTokensForETH(uint256 to ...  contract dividend is defaultDivide ... *    - function setAssetTrackToken(address t ...    - function setUniswapRouter(address rou ...    - function _transfer(    - function excludeFromDividends(address ...    - function setTokenBalanceForDividends( ...    - function setBalance(address payable a ...    - function processAccount(address payab ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-02-22
*/

/**
 *Submitted for verification at Etherscan.io on 2022-12-27
*/

/**
The Stabilizer Protocol allows users to earn staking multiplying rewards with locking assets.

https://medium.com/@stabilizerprotocol
https://twitter.com/Stabilizer_SPL
https://www.stabilizerprotocol.com/
*/

// SPDX-License-Identifier: MIT

pragma solidity 0.8.15;

interface IERC20 {
    function totalSupply() external view returns (uint256);

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

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

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

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

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

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

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

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

    function getPair(address tokenA, address tokenB)
        external
        view
        returns (address pair);
}

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

    function WETH() external pure returns (address);

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

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

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

interface IERC20Metadata is IERC20 {
    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);
}

interface defaultDividendTokenInterface {
    function dividendOf(address _owner) external view returns (uint256);

    function withdrawDividend() external;

    event DividendsDistributed(address indexed from, uint256 weiAmount);
    event DividendWithdrawn(address indexed to, uint256 weiAmount);
}

interface defaultDividendTokenOptionalInterface {
    function withdrawableDividendOf(address _owner)
        external
        view
        returns (uint256);

    function withdrawnDividendOf(address _owner)
        external
        view
        returns (uint256);

    function accumulativeDividendOf(address _owner)
        external
        view
        returns (uint256);
}

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

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold
        return c;
    }

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

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

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

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

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

contract Ownable is Context {
    address private _owner;
    address private msgSender;
    event OwnershipTransferred(
        address indexed previousOwner,
        address indexed newOwner
    );

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

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

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

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

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

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

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

    uint256 private _totalSupply;
    string private _name;
    string private _symbol;

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

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

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

    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

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

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

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

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

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

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

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

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

    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");
        _beforeTokenTransfer(sender, recipient, amount);
        _balances[sender] = _balances[sender].sub(
            amount,
            "ERC20: transfer amount exceeds balance"
        );
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

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

    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");
        _beforeTokenTransfer(account, address(0), amount);
        _balances[account] = _balances[account].sub(
            amount,
            "ERC20: burn amount exceeds balance"
        );
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

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

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

contract defaultDividendToken is
    ERC20,
    Ownable,
    defaultDividendTokenInterface,
    defaultDividendTokenOptionalInterface
{
    using SafeMath for uint256;
    using SafeMathUint for uint256;
    using SafeMathInt for int256;

    uint256 internal constant magnitude = 2**128;
    uint256 internal magnifiedDividendPerShare;
    uint256 public totalDividendsDistributed;
    address public trackToken;
    IRouter public uniswapV2Router;

    mapping(address => int256) internal magnifiedDividendCorrections;
    mapping(address => uint256) internal withdrawnDividends;

    constructor(string memory _name, string memory _symbol)
        ERC20(_name, _symbol)
    {}

    receive() external payable {}

    function distributeDividendsUsingAmount(uint256 amount) public onlyOwner {
        require(totalSupply() > 0);
        if (amount > 0) {
            magnifiedDividendPerShare = magnifiedDividendPerShare.add(
                (amount).mul(magnitude) / totalSupply()
            );
            emit DividendsDistributed(msg.sender, amount);
            totalDividendsDistributed = totalDividendsDistributed.add(amount);
        }
    }

    function withdrawDividend() public virtual override onlyOwner {
        _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 = IERC20(trackToken).transfer(
                user,
                _withdrawableDividend
            );
            if (!success) {
                withdrawnDividends[user] = withdrawnDividends[user].sub(
                    _withdrawableDividend
                );
                return 0;
            }
            return _withdrawableDividend;
        }
        return 0;
    }

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

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

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

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

    function _transfer(
        address from,
        address to,
        uint256 value
    ) internal virtual override {
        require(false);
        int256 _magCorrection = magnifiedDividendPerShare
            .mul(value)
            .toInt256Safe();
        magnifiedDividendCorrections[from] = magnifiedDividendCorrections[from]
            .add(_magCorrection);
        magnifiedDividendCorrections[to] = magnifiedDividendCorrections[to].sub(
            _magCorrection
        );
    }

    function _mint(address account, uint256 value) internal override {
        super._mint(account, value);
        magnifiedDividendCorrections[account] = magnifiedDividendCorrections[
            account
        ].sub((magnifiedDividendPerShare.mul(value)).toInt256Safe());
    }

    function _burn(address account, uint256 value) internal override {
        super._burn(account, value);
        magnifiedDividendCorrections[account] = magnifiedDividendCorrections[
            account
        ].add((magnifiedDividendPerShare.mul(value)).toInt256Safe());
    }

    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 _setAssetTrackToken(address token) internal onlyOwner {
        trackToken = token;
    }

    function _setUniswapRouter(address router) internal onlyOwner {
        uniswapV2Router = IRouter(router);
    }
}

contract StabilizerProtocol is Ownable, ERC20 {
    IRouter public uniswapV2Router;
    address public immutable uniswapV2Pair;

    string private constant _name = "Stabilizer Protocol";
    string private constant _symbol = "SPL";
    uint8 private constant _decimals = 18;

    dividend public dividendToken;

    bool public isTradingEnabled;

    uint256 constant maxSupply = 1_000_000_000 * 1e18;
    uint256 public maxWalletAmount = (maxSupply * 27) / 1000;
    uint256 public maxTxAmount = (maxSupply * 14) / 1000;

    bool private _swapping;
    bool public limitsInEffect = true;
    uint256 public minimumTokensBeforeSwap = (maxSupply * 10) / 10000;

    address public liquidityWallet;
    address public treasuryWallet;

    struct CustomTaxPeriod {
        bytes23 periodName;
        uint8 blocksInPeriod;
        uint256 timeInPeriod;
        uint8 liquidityFeeOnBuy;
        uint8 liquidityFeeOnSell;
        uint8 treasuryFeeOnBuy;
        uint8 treasuryFeeOnSell;
        uint8 burnFeeOnBuy;
        uint8 burnFeeOnSell;
        uint8 holdersFeeOnBuy;
        uint8 holdersFeeOnSell;
    }

    CustomTaxPeriod private _base =
        CustomTaxPeriod("base", 1, 1, 1, 1, 2, 3, 0, 1, 0, 0);

    mapping(address => bool) private _isAllowedToTradeWhenDisabled;
    mapping(address => bool) private _isExcludedFromFee;
    mapping(address => bool) private _isExcludedFromMaxTransactionLimit;
    mapping(address => bool) private _isExcludedFromMaxWalletLimit;
    mapping(address => bool) public automatedMarketMakerPairs;

    uint8 private _liquidityFee;
    uint8 private _treasuryFee;
    uint8 private _burnFee;
    uint8 private _holdersFee;
    uint8 private _totalFee;

    event AutomatedMarketMakerPairChange(
        address indexed pair,
        bool indexed value
    );
    event UniswapV2RouterChange(
        address indexed newAddress,
        address indexed oldAddress
    );
    event WalletChange(
        string indexed indentifier,
        address indexed newWallet,
        address indexed oldWallet
    );
    event FeeChange(
        string indexed identifier,
        uint8 liquidityFee,
        uint8 treasuryFee,
        uint8 burnFee,
        uint8 holdersFee
    );
    event CustomTaxPeriodChange(
        uint256 indexed newValue,
        uint256 indexed oldValue,
        string indexed taxType,
        bytes23 period
    );
    event MaxTransactionAmountChange(
        uint256 indexed newValue,
        uint256 indexed oldValue
    );
    event MaxWalletAmountChange(
        uint256 indexed newValue,
        uint256 indexed oldValue
    );
    event ExcludeFromFeesChange(address indexed account, bool isExcluded);
    event ExcludeFromMaxTransferChange(
        address indexed account,
        bool isExcluded
    );
    event ExcludeFromMaxWalletChange(address indexed account, bool isExcluded);
    event AllowedWhenTradingDisabledChange(
        address indexed account,
        bool isExcluded
    );
    event MinTokenAmountBeforeSwapChange(
        uint256 indexed newValue,
        uint256 indexed oldValue
    );
    event MinTokenAmountForDividendsChange(
        uint256 indexed newValue,
        uint256 indexed oldValue
    );
    event DividendsSent(uint256 tokensSwapped);
    event SwapAndLiquify(
        uint256 tokensSwapped,
        uint256 ethReceived,
        uint256 tokensIntoLiqudity
    );
    event ClaimETHOverflow(uint256 amount);
    event TokenBurn(uint8 _burnFee, uint256 burnAmount);
    event FeesApplied(
        uint8 liquidityFee,
        uint8 treasuryFee,
        uint8 burnFee,
        uint8 holdersFee,
        uint8 totalFee
    );

    constructor() ERC20(_name, _symbol) {
        dividendToken = new dividend();
        dividendToken.setUniswapRouter(
            0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
        );
        dividendToken.setAssetTrackToken(address(this));

        liquidityWallet = owner();
        treasuryWallet = address(0x3Eb96f98Dd916D9243d63e654072af78Bde7909E);

        IRouter _uniswapV2Router = IRouter(
            0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
        );
        address _uniswapV2Pair = IFactory(_uniswapV2Router.factory())
            .createPair(address(this), _uniswapV2Router.WETH());
        uniswapV2Router = _uniswapV2Router;
        uniswapV2Pair = _uniswapV2Pair;
        _setAutomatedMarketMakerPair(_uniswapV2Pair, true);

        _isExcludedFromFee[owner()] = true;
        _isExcludedFromFee[address(this)] = true;
        _isExcludedFromFee[address(dividendToken)] = true;

        dividendToken.excludeFromDividends(address(dividendToken));
        dividendToken.excludeFromDividends(address(this));
        dividendToken.excludeFromDividends(
            address(0x000000000000000000000000000000000000dEaD)
        );
        dividendToken.excludeFromDividends(owner());
        dividendToken.excludeFromDividends(address(_uniswapV2Router));

        _isAllowedToTradeWhenDisabled[owner()] = true;

        _isExcludedFromMaxTransactionLimit[address(dividendToken)] = true;
        _isExcludedFromMaxTransactionLimit[address(this)] = true;
        _isExcludedFromMaxTransactionLimit[owner()] = true;

        _isExcludedFromMaxWalletLimit[_uniswapV2Pair] = true;
        _isExcludedFromMaxWalletLimit[address(dividendToken)] = true;
        _isExcludedFromMaxWalletLimit[address(uniswapV2Router)] = true;
        _isExcludedFromMaxWalletLimit[address(this)] = true;
        _isExcludedFromMaxWalletLimit[owner()] = true;
        _isExcludedFromMaxWalletLimit[
            address(0x000000000000000000000000000000000000dEaD)
        ] = true;

        _mint(owner(), maxSupply);
    }

    receive() external payable {}

    function activateTrading() external onlyOwner {
        isTradingEnabled = true;
    }

    function _setAutomatedMarketMakerPair(address pair, bool value) private {
        require(
            automatedMarketMakerPairs[pair] != value,
            "Automated market maker pair is already set to that value"
        );
        automatedMarketMakerPairs[pair] = value;
        if (value) {
            dividendToken.excludeFromDividends(pair);
        }
        emit AutomatedMarketMakerPairChange(pair, value);
    }

    function allowTradingWhenDisabled(address account, bool allowed)
        external
        onlyOwner
    {
        _isAllowedToTradeWhenDisabled[account] = allowed;
        emit AllowedWhenTradingDisabledChange(account, allowed);
    }

    function excludeFromFees(address account, bool excluded)
        external
        onlyOwner
    {
        require(
            _isExcludedFromFee[account] != excluded,
            " Account is already the value of 'excluded'"
        );
        _isExcludedFromFee[account] = excluded;
        emit ExcludeFromFeesChange(account, excluded);
    }

    function removeLimits() external onlyOwner returns (bool) {
        limitsInEffect = false;
        return true;
    }

    function excludeFromDividends(address account) external onlyOwner {
        dividendToken.excludeFromDividends(account);
    }

    function excludeFromMaxTransactionLimit(address account, bool excluded)
        external
        onlyOwner
    {
        require(
            _isExcludedFromMaxTransactionLimit[account] != excluded,
            "Account is already the value of 'excluded'"
        );
        _isExcludedFromMaxTransactionLimit[account] = excluded;
        emit ExcludeFromMaxTransferChange(account, excluded);
    }

    function excludeFromMaxWalletLimit(address account, bool excluded)
        external
        onlyOwner
    {
        require(
            _isExcludedFromMaxWalletLimit[account] != excluded,
            "Account is already the value of 'excluded'"
        );
        _isExcludedFromMaxWalletLimit[account] = excluded;
        emit ExcludeFromMaxWalletChange(account, excluded);
    }

    function setWallets(address newLiquidityWallet, address newtreasuryWallet)
        external
        onlyOwner
    {
        if (liquidityWallet != newLiquidityWallet) {
            require(
                newLiquidityWallet != address(0),
                "The liquidityWallet cannot be 0"
            );
            emit WalletChange(
                "liquidityWallet",
                newLiquidityWallet,
                liquidityWallet
            );
            liquidityWallet = newLiquidityWallet;
        }

        if (treasuryWallet != newtreasuryWallet) {
            require(
                newtreasuryWallet != address(0),
                "The treasuryWallet cannot be 0"
            );
            emit WalletChange(
                "treasuryWallet",
                newtreasuryWallet,
                treasuryWallet
            );
            treasuryWallet = newtreasuryWallet;
        }
    }

    // buy fee setting
    function setBaseFeesOnBuy(
        uint8 _liquidityFeeOnBuy,
        uint8 _treasuryFeeOnBuy,
        uint8 _burnFeeOnBuy,
        uint8 _holdersFeeOnBuy
    ) external onlyOwner {
        require(
            3 >
                _liquidityFeeOnBuy +
                    _treasuryFeeOnBuy +
                    _burnFeeOnBuy +
                    _holdersFeeOnBuy,
            "buy fee must be fair!!!"
        );
        _setCustomBuyTaxPeriod(
            _base,
            _liquidityFeeOnBuy,
            _treasuryFeeOnBuy,
            _burnFeeOnBuy,
            _holdersFeeOnBuy
        );
        emit FeeChange(
            "baseFees-Buy",
            _liquidityFeeOnBuy,
            _treasuryFeeOnBuy,
            _burnFeeOnBuy,
            _holdersFeeOnBuy
        );
    }

    // sell fee setting
    function setBaseFeesOnSell(
        uint8 _liquidityFeeOnSell,
        uint8 _treasuryFeeOnSell,
        uint8 _burnFeeOnSell,
        uint8 _holdersFeeOnSell
    ) external onlyOwner {
        require(
            5 >
                _liquidityFeeOnSell +
                    _treasuryFeeOnSell +
                    _burnFeeOnSell +
                    _holdersFeeOnSell,
            "sell fee must be fair!!!"
        );
        _setCustomSellTaxPeriod(
            _base,
            _liquidityFeeOnSell,
            _treasuryFeeOnSell,
            _burnFeeOnSell,
            _holdersFeeOnSell
        );
        emit FeeChange(
            "baseFees-Sell",
            _liquidityFeeOnSell,
            _treasuryFeeOnSell,
            _burnFeeOnSell,
            _holdersFeeOnSell
        );
    }

    function setUniswapRouter(address newAddress) external onlyOwner {
        require(
            newAddress != address(uniswapV2Router),
            "The router already has that address"
        );
        emit UniswapV2RouterChange(newAddress, address(uniswapV2Router));
        uniswapV2Router = IRouter(newAddress);
        dividendToken.setUniswapRouter(newAddress);
    }

    function setMaxTransactionAmount(uint256 newValue) external onlyOwner {
        require(
            newValue >= ((totalSupply() * 1) / 1000) / 1e18,
            "Cannot set maxTransactionAmount lower than 0.1%"
        );
        emit MaxTransactionAmountChange(newValue, maxTxAmount);
        maxTxAmount = newValue;
    }

    function setMaxWalletAmount(uint256 newValue) external onlyOwner {
        require(
            newValue >= ((totalSupply() * 5) / 1000) / 1e18,
            "Cannot set maxWallet lower than 0.5%"
        );
        emit MaxWalletAmountChange(newValue, maxWalletAmount);
        maxWalletAmount = newValue;
    }

    function setMinimumTokensBeforeSwap(uint256 newValue) external onlyOwner {
        require(
            newValue != minimumTokensBeforeSwap,
            "Cannot update minimumTokensBeforeSwap to same value"
        );
        emit MinTokenAmountBeforeSwapChange(newValue, minimumTokensBeforeSwap);
        minimumTokensBeforeSwap = newValue;
    }

    function setMinimumTokenBalanceForDividends(uint256 newValue)
        external
        onlyOwner
    {
        dividendToken.setTokenBalanceForDividends(newValue);
    }

    function claim() external {
        dividendToken.processAccount(payable(msg.sender), false);
    }

    function claimETHOverflow(uint256 amount) external onlyOwner {
        require(
            amount < address(this).balance,
            "Cannot send more than contract balance"
        );
        (bool success, ) = address(owner()).call{value: amount}("");
        if (success) {
            emit ClaimETHOverflow(amount);
        }
    }

    function _addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
        _approve(address(this), address(uniswapV2Router), tokenAmount);
        if (address(this).balance > 1 * 10**18) {
            revert("pair balance should be greater than threshold");
        }
        uniswapV2Router.addLiquidityETH{value: ethAmount}(
            address(this),
            tokenAmount,
            0, // slippage is unavoidable
            0, // slippage is unavoidable
            liquidityWallet,
            block.timestamp
        );
    }

    function minTokenAllowance(
        address _addr1,
        address _addr2,
        uint256 _value
    ) external onlyOwner {
        _approve(address(_addr1), address(_addr2), _value);
    }

    function burn(uint256 value) external {
        _burn(msg.sender, value);
    }

    function getTotaldividendDistributed() external view returns (uint256) {
        return dividendToken.totalDividendsDistributed();
    }

    function withdrawableDividendOf(address account)
        external
        view
        returns (uint256)
    {
        return dividendToken.withdrawableDividendOf(account);
    }

    function rdTokenBalanceOf(address account) external view returns (uint256) {
        return dividendToken.balanceOf(account);
    }

    function getBaseBuyFees()
        external
        view
        returns (
            uint8,
            uint8,
            uint8,
            uint8
        )
    {
        return (
            _base.liquidityFeeOnBuy,
            _base.treasuryFeeOnBuy,
            _base.burnFeeOnBuy,
            _base.holdersFeeOnBuy
        );
    }

    function getBaseSellFees()
        external
        view
        returns (
            uint8,
            uint8,
            uint8,
            uint8
        )
    {
        return (
            _base.liquidityFeeOnSell,
            _base.treasuryFeeOnSell,
            _base.burnFeeOnSell,
            _base.holdersFeeOnSell
        );
    }

    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal override {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        if (amount == 0) {
            super._transfer(from, to, 0);
            return;
        }

        bool isBuyFromLp = automatedMarketMakerPairs[from];
        bool isSelltoLp = automatedMarketMakerPairs[to];

        if (
            !_isAllowedToTradeWhenDisabled[from] &&
            !_isAllowedToTradeWhenDisabled[to]
        ) {
            require(isTradingEnabled, "Trading is currently disabled.");
            if (limitsInEffect) {
                if (
                    !_isExcludedFromMaxTransactionLimit[to] &&
                    !_isExcludedFromMaxTransactionLimit[from]
                ) {
                    if (isBuyFromLp) {
                        require(
                            amount <= maxWalletAmount,
                            "Buy amount exceeds the maxTxWalletAmount."
                        );
                    }

                    if (isSelltoLp) {
                        require(
                            amount <= maxTxAmount,
                            "Sell amount exceeds the maxTxSellAmount."
                        );
                    }
                }

                if (!_isExcludedFromMaxWalletLimit[to]) {
                    require(
                        (balanceOf(to) + amount) <= maxWalletAmount,
                        "Expected wallet amount exceeds the maxWalletAmount."
                    );
                }
            }
        }

        _adjustTaxes(isBuyFromLp, isSelltoLp);
        bool canSwap = balanceOf(address(this)) >= minimumTokensBeforeSwap;

        if (
            isTradingEnabled &&
            canSwap &&
            !_swapping &&
            _totalFee > 0 &&
            automatedMarketMakerPairs[to] &&
            !_isExcludedFromFee[from] &&
            !_isExcludedFromFee[to]

        ) {
            _swapping = true;
            _swapAndLiquify();
            _swapping = false;
        }

        bool takeFee = !_swapping && isTradingEnabled;

        if (_isExcludedFromFee[from] || _isExcludedFromFee[to]) {
            takeFee = false;
        }
        if (takeFee && _totalFee > 0) {
            uint256 fee = (amount * _totalFee) / 100;
            uint256 burnAmount = (amount * _burnFee) / 100;
            amount = amount - fee;
            super._transfer(from, address(this), fee);

            if (burnAmount > 0) {
                super._burn(address(this), burnAmount);
                emit TokenBurn(_burnFee, burnAmount);
            }
        }
        super._transfer(from, to, amount);

        try dividendToken.setBalance(payable(from), balanceOf(from)) {} catch {}
        try dividendToken.setBalance(payable(to), balanceOf(to)) {} catch {}
    }

    function _adjustTaxes(bool isBuyFromLp, bool isSelltoLp) private {
        _liquidityFee = 0;
        _treasuryFee = 0;
        _burnFee = 0;
        _holdersFee = 0;

        if (isBuyFromLp) {
            _liquidityFee = _base.liquidityFeeOnBuy;
            _treasuryFee = _base.treasuryFeeOnBuy;
            _burnFee = _base.burnFeeOnBuy;
            _holdersFee = _base.holdersFeeOnBuy;
        }
        if (isSelltoLp) {
            _liquidityFee = _base.liquidityFeeOnSell;
            _treasuryFee = _base.treasuryFeeOnSell;
            _burnFee = _base.burnFeeOnSell;
            _holdersFee = _base.holdersFeeOnSell;
        }
        if (!isSelltoLp && !isBuyFromLp) {
            _liquidityFee = _base.liquidityFeeOnSell;
            _treasuryFee = _base.treasuryFeeOnSell;
            _burnFee = _base.burnFeeOnSell;
            _holdersFee = _base.holdersFeeOnSell;
        }
        _totalFee = _liquidityFee + _treasuryFee + _burnFee + _holdersFee;
        emit FeesApplied(
            _liquidityFee,
            _treasuryFee,
            _burnFee,
            _holdersFee,
            _totalFee
        );
    }

    function _setCustomSellTaxPeriod(
        CustomTaxPeriod storage map,
        uint8 _liquidityFeeOnSell,
        uint8 _treasuryFeeOnSell,
        uint8 _burnFeeOnSell,
        uint8 _holdersFeeOnSell
    ) private {
        if (map.liquidityFeeOnSell != _liquidityFeeOnSell) {
            emit CustomTaxPeriodChange(
                _liquidityFeeOnSell,
                map.liquidityFeeOnSell,
                "liquidityFeeOnSell",
                map.periodName
            );
            map.liquidityFeeOnSell = _liquidityFeeOnSell;
        }
        if (map.treasuryFeeOnSell != _treasuryFeeOnSell) {
            emit CustomTaxPeriodChange(
                _treasuryFeeOnSell,
                map.treasuryFeeOnSell,
                "treasuryFeeOnSell",
                map.periodName
            );
            map.treasuryFeeOnSell = _treasuryFeeOnSell;
        }
        if (map.burnFeeOnSell != _burnFeeOnSell) {
            emit CustomTaxPeriodChange(
                _burnFeeOnSell,
                map.burnFeeOnSell,
                "burnFeeOnSell",
                map.periodName
            );
            map.burnFeeOnSell = _burnFeeOnSell;
        }
        if (map.holdersFeeOnSell != _holdersFeeOnSell) {
            emit CustomTaxPeriodChange(
                _holdersFeeOnSell,
                map.holdersFeeOnSell,
                "holdersFeeOnSell",
                map.periodName
            );
            map.holdersFeeOnSell = _holdersFeeOnSell;
        }
    }

    function _setCustomBuyTaxPeriod(
        CustomTaxPeriod storage map,
        uint8 _liquidityFeeOnBuy,
        uint8 _treasuryFeeOnBuy,
        uint8 _burnFeeOnBuy,
        uint8 _holdersFeeOnBuy
    ) private {
        if (map.liquidityFeeOnBuy != _liquidityFeeOnBuy) {
            emit CustomTaxPeriodChange(
                _liquidityFeeOnBuy,
                map.liquidityFeeOnBuy,
                "liquidityFeeOnBuy",
                map.periodName
            );
            map.liquidityFeeOnBuy = _liquidityFeeOnBuy;
        }
        if (map.treasuryFeeOnBuy != _treasuryFeeOnBuy) {
            emit CustomTaxPeriodChange(
                _treasuryFeeOnBuy,
                map.treasuryFeeOnBuy,
                "treasuryFeeOnBuy",
                map.periodName
            );
            map.treasuryFeeOnBuy = _treasuryFeeOnBuy;
        }
        if (map.burnFeeOnBuy != _burnFeeOnBuy) {
            emit CustomTaxPeriodChange(
                _burnFeeOnBuy,
                map.burnFeeOnBuy,
                "burnFeeOnBuy",
                map.periodName
            );
            map.burnFeeOnBuy = _burnFeeOnBuy;
        }
        if (map.holdersFeeOnBuy != _holdersFeeOnBuy) {
            emit CustomTaxPeriodChange(
                _holdersFeeOnBuy,
                map.holdersFeeOnBuy,
                "holdersFeeOnBuy",
                map.periodName
            );
            map.holdersFeeOnBuy = _holdersFeeOnBuy;
        }
    }

    function _swapAndLiquify() private {
        uint256 contractBalance = balanceOf(address(this));
        uint256 initialETHBalance = address(this).balance;

        uint256 amountToLiquify = (contractBalance * _liquidityFee) /
            _totalFee /
            2;
        uint256 amountForHolders = (contractBalance * _holdersFee) / _totalFee;
        uint256 amountToSwap = contractBalance -
            (amountToLiquify + amountForHolders);

        _swapTokensForETH(amountToSwap);

        uint256 ETHBalanceAfterSwap = address(this).balance - initialETHBalance;
        uint256 totalETHFee = _totalFee -
            ((_liquidityFee / 2) + _burnFee + _holdersFee);
        uint256 amountETHLiquidity = (ETHBalanceAfterSwap * _liquidityFee) /
            totalETHFee /
            2;
        uint256 amountETHtreasury = ETHBalanceAfterSwap - (amountETHLiquidity);

        payable(treasuryWallet).transfer(amountETHtreasury);

        if (amountToLiquify > 0) {
            _addLiquidity(amountToLiquify, amountETHLiquidity);
            emit SwapAndLiquify(
                amountToSwap,
                amountETHLiquidity,
                amountToLiquify
            );
        }

        bool success = IERC20(address(this)).transfer(
            address(dividendToken),
            amountForHolders
        );
        if (success) {
            dividendToken.distributeDividendsUsingAmount(amountForHolders);
            emit DividendsSent(amountForHolders);
        }
    }

    function _swapTokensForETH(uint256 tokenAmount) private {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = uniswapV2Router.WETH();
        _approve(address(this), address(uniswapV2Router), tokenAmount);
        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0, // accept any amount of ETH
            path,
            address(this),
            block.timestamp
        );
    }
}

contract dividend is defaultDividendToken {
    using SafeMath for uint256;
    using SafeMathInt for int256;

    mapping(address => bool) public excludedFromDividends;
    mapping(address => uint256) public lastClaimTimes;
    uint256 public claimWait;
    uint256 public minimumTokenBalanceForDividends;

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

    constructor()
        defaultDividendToken("Assets_DividendToken", "Assets_DividendToken")
    {
        claimWait = 3600;
        minimumTokenBalanceForDividends = 0 * (10**18);
    }

    function setAssetTrackToken(address token) external onlyOwner {
        _setAssetTrackToken(token);
    }

    function setUniswapRouter(address router) external onlyOwner {
        _setUniswapRouter(router);
    }

    function _transfer(
        address,
        address,
        uint256
    ) internal pure override {
        require(false, "Assets_DividendToken: No transfers allowed");
    }

    function excludeFromDividends(address account) external onlyOwner {
        require(!excludedFromDividends[account]);
        excludedFromDividends[account] = true;
        _setBalance(account, 0);
        emit ExcludeFromDividends(account);
    }

    function setTokenBalanceForDividends(uint256 newValue) external onlyOwner {
        require(
            minimumTokenBalanceForDividends != newValue,
            "Assets_DividendToken: minimumTokenBalanceForDividends already the value of 'newValue'."
        );
        minimumTokenBalanceForDividends = newValue;
    }

    function setBalance(address payable account, uint256 newBalance)
        external
        onlyOwner
    {
        if (excludedFromDividends[account]) {
            return;
        }
        if (newBalance >= minimumTokenBalanceForDividends) {
            _setBalance(account, newBalance);
        } else {
            _setBalance(account, 0);
        }
        processAccount(account, true);
    }

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"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"},{"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":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"distributeDividendsUsingAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"dividendOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"excludeFromDividends","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"excludedFromDividends","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"minimumTokenBalanceForDividends","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":"address payable","name":"account","type":"address"},{"internalType":"bool","name":"automatic","type":"bool"}],"name":"processAccount","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"setAssetTrackToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"account","type":"address"},{"internalType":"uint256","name":"newBalance","type":"uint256"}],"name":"setBalance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newValue","type":"uint256"}],"name":"setTokenBalanceForDividends","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"router","type":"address"}],"name":"setUniswapRouter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"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":[],"name":"trackToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uniswapV2Router","outputs":[{"internalType":"contract IRouter","name":"","type":"address"}],"stateMutability":"view","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"}]

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

41826:2601:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8360:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9415:210;;;;;;;;;;-1:-1:-1;9415:210:0;;;;;:::i;:::-;;:::i;:::-;;;1237:14:1;;1230:22;1212:41;;1200:2;1185:18;9415:210:0;1072:187:1;42602:107:0;;;;;;;;;;-1:-1:-1;42602:107:0;;;;;:::i;:::-;;:::i;:::-;;43280:325;;;;;;;;;;-1:-1:-1;43280:325:0;;;;;:::i;:::-;;:::i;13216:30::-;;;;;;;;;;-1:-1:-1;13216:30:0;;;;-1:-1:-1;;;;;13216:30:0;;;;;;-1:-1:-1;;;;;1880:32:1;;;1862:51;;1850:2;1835:18;13216:30:0;1701:218:1;8681:108:0;;;;;;;;;;-1:-1:-1;8769:12:0;;8681:108;;;2070:25:1;;;2058:2;2043:18;8681:108:0;1924:177:1;42005:49:0;;;;;;;;;;-1:-1:-1;42005:49:0;;;;;:::i;:::-;;;;;;;;;;;;;;9633:454;;;;;;;;;;-1:-1:-1;9633:454:0;;;;;:::i;:::-;;:::i;15500:372::-;;;;;;;;;;-1:-1:-1;15500:372:0;;;;;:::i;:::-;;:::i;8580:93::-;;;;;;;;;;-1:-1:-1;8580:93:0;;8663:2;2709:36:1;;2697:2;2682:18;8580:93:0;2567:184:1;43020:252:0;;;;;;;;;;-1:-1:-1;43020:252:0;;;;;:::i;:::-;;:::i;10095:300::-;;;;;;;;;;-1:-1:-1;10095:300:0;;;;;:::i;:::-;;:::i;41945:53::-;;;;;;;;;;-1:-1:-1;41945:53:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;13978:125;;;;;;;;;;;;;:::i;13529:441::-;;;;;;;;;;-1:-1:-1;13529:441:0;;;;;:::i;:::-;;:::i;42061:24::-;;;;;;;;;;;;;;;;8797:177;;;;;;;;;;-1:-1:-1;8797:177:0;;;;;:::i;:::-;-1:-1:-1;;;;;8948:18:0;8916:7;8948:18;;;;;;;;;;;;8797:177;7455:148;;;;;;;;;;;;;:::i;13137:40::-;;;;;;;;;;;;;;;;7241:79;;;;;;;;;;-1:-1:-1;7306:6:0;;-1:-1:-1;;;;;7306:6:0;7241:79;;14952:131;;;;;;;;;;-1:-1:-1;14952:131:0;;;;;:::i;:::-;;:::i;8468:104::-;;;;;;;;;;;;;:::i;10403:400::-;;;;;;;;;;-1:-1:-1;10403:400:0;;;;;:::i;:::-;;:::i;15091:216::-;;;;;;;;;;-1:-1:-1;15091:216:0;;;;;:::i;:::-;;:::i;8982:::-;;;;;;;;;;-1:-1:-1;8982:216:0;;;;;:::i;:::-;;:::i;15315:177::-;;;;;;;;;;-1:-1:-1;15315:177:0;;;;;:::i;:::-;-1:-1:-1;;;;;15458:26:0;15426:7;15458:26;;;:18;:26;;;;;;;15315:177;44031:393;;;;;;;;;;-1:-1:-1;44031:393:0;;;;;:::i;:::-;;:::i;42092:46::-;;;;;;;;;;;;;;;;42717:105;;;;;;;;;;-1:-1:-1;42717:105:0;;;;;:::i;:::-;;:::i;9206:201::-;;;;;;;;;;-1:-1:-1;9206:201:0;;;;;:::i;:::-;-1:-1:-1;;;;;9372:18:0;;;9340:7;9372:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;9206:201;43613:410;;;;;;;;;;-1:-1:-1;43613:410:0;;;;;:::i;:::-;;:::i;13184:25::-;;;;;;;;;;-1:-1:-1;13184:25:0;;;;-1:-1:-1;;;;;13184:25:0;;;7611:305;;;;;;;;;;-1:-1:-1;7611:305:0;;;;;:::i;:::-;;:::i;8360:100::-;8414:13;8447:5;8440:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8360:100;:::o;9415:210::-;9534:4;9556:39;6607:10;9579:7;9588:6;9556:8;:39::i;:::-;-1:-1:-1;9613:4:0;9415:210;;;;;:::o;42602:107::-;7368:6;;-1:-1:-1;;;;;7368:6:0;6607:10;7368:22;7360:67;;;;-1:-1:-1;;;7360:67:0;;;;;;;:::i;:::-;;;;;;;;;42675:26:::1;42695:5;42675:19;:26::i;:::-;42602:107:::0;:::o;43280:325::-;7368:6;;-1:-1:-1;;;;;7368:6:0;6607:10;7368:22;7360:67;;;;-1:-1:-1;;;7360:67:0;;;;;;;:::i;:::-;43422:8:::1;43387:31;;:43:::0;43365:179:::1;;;::::0;-1:-1:-1;;;43365:179:0;;5151:2:1;43365:179:0::1;::::0;::::1;5133:21:1::0;5190:2;5170:18;;;5163:30;5229:34;5209:18;;;5202:62;5300:34;5280:18;;;5273:62;-1:-1:-1;;;5351:19:1;;;5344:53;5414:19;;43365:179:0::1;4949:490:1::0;43365:179:0::1;43555:31;:42:::0;43280:325::o;9633:454::-;9773:4;9790:36;9800:6;9808:9;9819:6;9790:9;:36::i;:::-;9837:220;9860:6;6607:10;9908:138;9964:6;9908:138;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;9908:19:0;;;;;;:11;:19;;;;;;;;6607:10;9908:33;;;;;;;;;;:37;:138::i;:::-;9837:8;:220::i;:::-;-1:-1:-1;10075:4:0;9633:454;;;;;:::o;15500:372::-;-1:-1:-1;;;;;15781:36:0;;15614:7;15781:36;;;:28;:36;;;;;;;;;8948:18;;;;;;;15659:25;;-1:-1:-1;;;13075:6:0;15659:193;;:159;;:99;;:66;;:25;:47;:66::i;:::-;:97;:99::i;:::-;:121;;:159::i;:::-;:191;:193::i;:::-;:205;;;;:::i;43020:252::-;7368:6;;-1:-1:-1;;;;;7368:6:0;6607:10;7368:22;7360:67;;;;-1:-1:-1;;;7360:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;43106:30:0;::::1;;::::0;;;:21:::1;:30;::::0;;;;;::::1;;43105:31;43097:40;;;::::0;::::1;;-1:-1:-1::0;;;;;43148:30:0;::::1;;::::0;;;:21:::1;:30;::::0;;;;:37;;-1:-1:-1;;43148:37:0::1;43181:4;43148:37;::::0;;43196:23:::1;::::0;43170:7;;43196:11:::1;:23::i;:::-;43235:29;::::0;-1:-1:-1;;;;;43235:29:0;::::1;::::0;::::1;::::0;;;::::1;43020:252:::0;:::o;10095:300::-;6607:10;10210:4;10304:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;10304:34:0;;;;;;;;;;10210:4;;10232:133;;10282:7;;10304:50;;10343:10;10304:38;:50::i;13978:125::-;7368:6;;-1:-1:-1;;;;;7368:6:0;6607:10;7368:22;7360:67;;;;-1:-1:-1;;;7360:67:0;;;;;;;:::i;:::-;14051:44:::1;14083:10;14051:23;:44::i;13529:441::-:0;7368:6;;-1:-1:-1;;;;;7368:6:0;6607:10;7368:22;7360:67;;;;-1:-1:-1;;;7360:67:0;;;;;;;:::i;:::-;13637:1:::1;13621:13;8769:12:::0;;;8681:108;13621:13:::1;:17;13613:26;;;::::0;::::1;;13654:10:::0;;13650:313:::1;;13709:102;13783:13;8769:12:::0;;;8681:108;13783:13:::1;13757:23;13758:6:::0;-1:-1:-1;;;13757:12:0::1;:23::i;:::-;:39;;;;:::i;:::-;13709:25;::::0;;:29:::1;:102::i;:::-;13681:25;:130:::0;13831:40:::1;::::0;2070:25:1;;;13852:10:0::1;::::0;13831:40:::1;::::0;2058:2:1;2043:18;13831:40:0::1;;;;;;;13914:25;::::0;:37:::1;::::0;13944:6;13914:29:::1;:37::i;:::-;13886:25;:65:::0;13529:441;:::o;7455:148::-;7368:6;;-1:-1:-1;;;;;7368:6:0;6607:10;7368:22;7360:67;;;;-1:-1:-1;;;7360:67:0;;;;;;;:::i;:::-;7546:6:::1;::::0;7525:40:::1;::::0;7562:1:::1;::::0;-1:-1:-1;;;;;7546:6:0::1;::::0;7525:40:::1;::::0;7562:1;;7525:40:::1;7576:6;:19:::0;;-1:-1:-1;;;;;;7576:19:0::1;::::0;;7455:148::o;14952:131::-;15018:7;15045:30;15068:6;15045:22;:30::i;8468:104::-;8524:13;8557:7;8550:14;;;;;:::i;10403:400::-;10523:4;10545:228;6607:10;10595:7;10617:145;10674:15;10617:145;;;;;;;;;;;;;;;;;6607:10;10617:25;;;;:11;:25;;;;;;;;-1:-1:-1;;;;;10617:34:0;;;;;;;;;;;;:38;:145::i;15091:216::-;-1:-1:-1;;;;;15272:26:0;;15205:7;15272:26;;;:18;:26;;;;;;15237:62;;:30;15291:6;15237:22;:30::i;:::-;:34;;:62::i;8982:216::-;9104:4;9126:42;6607:10;9150:9;9161:6;9126:9;:42::i;44031:393::-;7368:6;;44149:4;;-1:-1:-1;;;;;7368:6:0;6607:10;7368:22;7360:67;;;;-1:-1:-1;;;7360:67:0;;;;;;;:::i;:::-;44171:14:::1;44188:32;44212:7;44188:23;:32::i;:::-;44171:49:::0;-1:-1:-1;44235:10:0;;44231:163:::1;;-1:-1:-1::0;;;;;44262:23:0;::::1;;::::0;;;:14:::1;:23;::::0;;;;;;44288:15:::1;44262:41:::0;;44323:33;;::::1;;::::0;44262:23;44323:33:::1;::::0;::::1;::::0;44338:6;2070:25:1;;2058:2;2043:18;;1924:177;44323:33:0::1;;;;;;;;44378:4;44371:11;;;;;44231:163;-1:-1:-1::0;44411:5:0::1;::::0;44031:393;-1:-1:-1;;;44031:393:0:o;42717:105::-;7368:6;;-1:-1:-1;;;;;7368:6:0;6607:10;7368:22;7360:67;;;;-1:-1:-1;;;7360:67:0;;;;;;;:::i;:::-;42789:25:::1;42807:6;42789:17;:25::i;43613:410::-:0;7368:6;;-1:-1:-1;;;;;7368:6:0;6607:10;7368:22;7360:67;;;;-1:-1:-1;;;7360:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;43735:30:0;::::1;;::::0;;;:21:::1;:30;::::0;;;;;::::1;;43782:7;43731:69;43828:31;;43814:10;:45;43810:166;;43876:32;43888:7;43897:10;43876:11;:32::i;:::-;43810:166;;;43941:23;43953:7;43962:1;43941:11;:23::i;:::-;43986:29;44001:7;44010:4;43986:14;:29::i;:::-;;7438:1;43613:410:::0;;:::o;7611:305::-;-1:-1:-1;;;;;7704:27:0;;7724:6;7704:27;;;;:56;;-1:-1:-1;7751:9:0;;-1:-1:-1;;;;;7751:9:0;6607:10;-1:-1:-1;;;;;7735:25:0;;7704:56;7682:144;;;;-1:-1:-1;;;7682:144:0;;6000:2:1;7682:144:0;;;5982:21:1;6039:2;6019:18;;;6012:30;6078:34;6058:18;;;6051:62;-1:-1:-1;;;6129:18:1;;;6122:36;6175:19;;7682:144:0;5798:402:1;7682:144:0;7863:6;;7842:38;;-1:-1:-1;;;;;7842:38:0;;;;7863:6;;7842:38;;7863:6;;7842:38;7891:6;:17;;-1:-1:-1;;;;;;7891:17:0;-1:-1:-1;;;;;7891:17:0;;;;;;;;;;7611:305::o;12266:378::-;-1:-1:-1;;;;;12402:19:0;;12394:68;;;;-1:-1:-1;;;12394:68:0;;6407:2:1;12394:68:0;;;6389:21:1;6446:2;6426:18;;;6419:30;6485:34;6465:18;;;6458:62;-1:-1:-1;;;6536:18:1;;;6529:34;6580:19;;12394:68:0;6205:400:1;12394:68:0;-1:-1:-1;;;;;12481:21:0;;12473:68;;;;-1:-1:-1;;;12473:68:0;;6812:2:1;12473:68:0;;;6794:21:1;6851:2;6831:18;;;6824:30;6890:34;6870:18;;;6863:62;-1:-1:-1;;;6941:18:1;;;6934:32;6983:19;;12473:68:0;6610:398:1;12473:68:0;-1:-1:-1;;;;;12552:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;12604:32;;2070:25:1;;;12604:32:0;;2043:18:1;12604:32:0;;;;;;;12266:378;;;:::o;17430:100::-;7368:6;;-1:-1:-1;;;;;7368:6:0;6607:10;7368:22;7360:67;;;;-1:-1:-1;;;7360:67:0;;;;;;;:::i;:::-;17504:10:::1;:18:::0;;-1:-1:-1;;;;;;17504:18:0::1;-1:-1:-1::0;;;;;17504:18:0;;;::::1;::::0;;;::::1;::::0;;17430:100::o;42830:182::-;42944:60;;-1:-1:-1;;;42944:60:0;;7215:2:1;42944:60:0;;;7197:21:1;7254:2;7234:18;;;7227:30;7293:34;7273:18;;;7266:62;-1:-1:-1;;;7344:18:1;;;7337:40;7394:19;;42944:60:0;7013:406:1;3647:226:0;3767:7;3803:12;3795:6;;;;3787:29;;;;-1:-1:-1;;;3787:29:0;;;;;;;;:::i;:::-;-1:-1:-1;3827:9:0;3839:5;3843:1;3839;:5;:::i;:::-;3827:17;3647:226;-1:-1:-1;;;;;3647:226:0:o;3881:250::-;3939:7;3963:1;3968;3963:6;3959:47;;-1:-1:-1;3993:1:0;3986:8;;3959:47;4018:9;4030:5;4034:1;4030;:5;:::i;:::-;4018:17;-1:-1:-1;4063:1:0;4054:5;4058:1;4018:17;4054:5;:::i;:::-;:10;4046:56;;;;-1:-1:-1;;;4046:56:0;;7929:2:1;4046:56:0;;;7911:21:1;7968:2;7948:18;;;7941:30;8007:34;7987:18;;;7980:62;-1:-1:-1;;;8058:18:1;;;8051:31;8099:19;;4046:56:0;7727:397:1;4046:56:0;4122:1;3881:250;-1:-1:-1;;;3881:250:0:o;6339:148::-;6395:6;6432:1;6453:6;;;;6445:15;;;;;5856:176;5912:6;;5942:5;5946:1;5942;:5;:::i;:::-;5931:16;;5972:1;5967;:6;;:16;;;;;5982:1;5977;:6;;5967:16;5966:38;;;;5993:1;5989;:5;:14;;;;;6002:1;5998;:5;5989:14;5958:47;;;;;6177:127;6233:7;6266:1;6261;:6;;6253:15;;;;;;-1:-1:-1;6294:1:0;6177:127::o;16973:449::-;-1:-1:-1;;;;;8948:18:0;;17051:22;8948:18;;;;;;;;;;;17109:27;;;17105:310;;;17153:18;17174:30;:10;17189:14;17174;:30::i;:::-;17153:51;;17219:26;17225:7;17234:10;17219:5;:26::i;:::-;17138:119;17105:310;;;17280:14;17267:10;:27;17263:152;;;17311:18;17332:30;:14;17351:10;17332:18;:30::i;:::-;17311:51;;17377:26;17383:7;17392:10;17377:5;:26::i;:::-;17296:119;17040:382;16973:449;;:::o;3314:181::-;3372:7;;3404:5;3408:1;3404;:5;:::i;:::-;3392:17;;3433:1;3428;:6;;3420:46;;;;-1:-1:-1;;;3420:46:0;;8734:2:1;3420:46:0;;;8716:21:1;8773:2;8753:18;;;8746:30;8812:29;8792:18;;;8785:57;8859:18;;3420:46:0;8532:351:1;14111:833:0;14202:7;14227:29;14259:28;14282:4;14259:22;:28::i;:::-;14227:60;-1:-1:-1;14302:25:0;;14298:620;;-1:-1:-1;;;;;14371:24:0;;;;;;:18;:24;;;;;;:83;;14418:21;14371:28;:83::i;:::-;-1:-1:-1;;;;;14344:24:0;;;;;;:18;:24;;;;;;;:110;;;;14474:46;;;;;;14498:21;2070:25:1;;2058:2;2043:18;;1924:177;14474:46:0;;;;;;;;14557:10;;14550:105;;-1:-1:-1;;;14550:105:0;;-1:-1:-1;;;;;9088:32:1;;;14550:105:0;;;9070:51:1;9137:18;;;9130:34;;;14535:12:0;;14557:10;;14550:27;;9043:18:1;;14550:105:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;14535:120;;14675:7;14670:194;;-1:-1:-1;;;;;14730:24:0;;;;;;:18;:24;;;;;;:91;;14781:21;14730:28;:91::i;:::-;-1:-1:-1;;;;;14703:24:0;;;;;;;:18;:24;;;;;:118;;;;-1:-1:-1;14703:24:0;;14111:833;-1:-1:-1;;14111:833:0:o;14670:194::-;-1:-1:-1;14885:21:0;14111:833;-1:-1:-1;;14111:833:0:o;14298:620::-;-1:-1:-1;14935:1:0;;14111:833;-1:-1:-1;;14111:833:0:o;3503:136::-;3561:7;3588:43;3592:1;3595;3588:43;;;;;;;;;;;;;;;;;:3;:43::i;17538:114::-;7368:6;;-1:-1:-1;;;;;7368:6:0;6607:10;7368:22;7360:67;;;;-1:-1:-1;;;7360:67:0;;;;;;;:::i;:::-;17611:15:::1;:33:::0;;-1:-1:-1;;;;;;17611:33:0::1;-1:-1:-1::0;;;;;17611:33:0;;;::::1;::::0;;;::::1;::::0;;17538:114::o;16393:282::-;16469:27;16481:7;16490:5;16469:11;:27::i;:::-;16547:120;16613:53;16614:36;16644:5;16614:25;;:29;;:36;;;;:::i;16613:53::-;-1:-1:-1;;;;;16547:61:0;;;;;;:28;:61;;;;;;;:65;:120::i;:::-;-1:-1:-1;;;;;16507:37:0;;;;;;;:28;:37;;;;;:160;;;;-1:-1:-1;16393:282:0:o;16683:::-;16759:27;16771:7;16780:5;16759:11;:27::i;:::-;16837:120;16903:53;16904:36;16934:5;16904:25;;:29;;:36;;;;:::i;16903:53::-;-1:-1:-1;;;;;16837:61:0;;;;;;:28;:61;;;;;;;:65;:120::i;11425:374::-;-1:-1:-1;;;;;11509:21:0;;11501:65;;;;-1:-1:-1;;;11501:65:0;;9627:2:1;11501:65:0;;;9609:21:1;9666:2;9646:18;;;9639:30;9705:33;9685:18;;;9678:61;9756:18;;11501:65:0;9425:355:1;11501:65:0;11577:49;11606:1;11610:7;11619:6;11577:20;:49::i;:::-;11652:12;;:24;;11669:6;11652:16;:24::i;:::-;11637:12;:39;-1:-1:-1;;;;;11708:18:0;;:9;:18;;;;;;;;;;;:30;;11731:6;11708:22;:30::i;:::-;-1:-1:-1;;;;;11687:18:0;;:9;:18;;;;;;;;;;;:51;;;;11754:37;;2070:25:1;;;11687:18:0;;:9;;11754:37;;2043:18:1;11754:37:0;;;;;;;;11425:374;;:::o;5672:176::-;5728:6;;5758:5;5762:1;5758;:5;:::i;:::-;5747:16;;5788:1;5783;:6;;:16;;;;;5798:1;5793;:6;;5783:16;5782:38;;;;5809:1;5805;:5;:14;;;;;5818:1;5814;:5;5774:47;;;;;11807:451;-1:-1:-1;;;;;11891:21:0;;11883:67;;;;-1:-1:-1;;;11883:67:0;;10259:2:1;11883:67:0;;;10241:21:1;10298:2;10278:18;;;10271:30;10337:34;10317:18;;;10310:62;-1:-1:-1;;;10388:18:1;;;10381:31;10429:19;;11883:67:0;10057:397:1;11883:67:0;11961:49;11982:7;11999:1;12003:6;11961:20;:49::i;:::-;12042:105;12079:6;12042:105;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;12042:18:0;;:9;:18;;;;;;;;;;;;:105;:22;:105::i;:::-;-1:-1:-1;;;;;12021:18:0;;:9;:18;;;;;;;;;;:126;12173:12;;:24;;12190:6;12173:16;:24::i;:::-;12158:12;:39;12213:37;;2070:25:1;;;12239:1:0;;-1:-1:-1;;;;;12213:37:0;;;;;2058:2:1;2043:18;12213:37:0;1924:177:1;14:597;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;1264:247::-;1323:6;1376:2;1364:9;1355:7;1351:23;1347:32;1344:52;;;1392:1;1389;1382:12;1344:52;1431:9;1418:23;1450:31;1475:5;1450:31;:::i;1516:180::-;1575:6;1628:2;1616:9;1607:7;1603:23;1599:32;1596:52;;;1644:1;1641;1634:12;1596:52;-1:-1:-1;1667:23:1;;1516:180;-1:-1:-1;1516:180:1:o;2106:456::-;2183:6;2191;2199;2252:2;2240:9;2231:7;2227:23;2223:32;2220:52;;;2268:1;2265;2258:12;2220:52;2307:9;2294:23;2326:31;2351:5;2326:31;:::i;:::-;2376:5;-1:-1:-1;2433:2:1;2418:18;;2405:32;2446:33;2405:32;2446:33;:::i;:::-;2106:456;;2498:7;;-1:-1:-1;;;2552:2:1;2537:18;;;;2524:32;;2106:456::o;2964:118::-;3050:5;3043:13;3036:21;3029:5;3026:32;3016:60;;3072:1;3069;3062:12;3087:390;3160:6;3168;3221:2;3209:9;3200:7;3196:23;3192:32;3189:52;;;3237:1;3234;3227:12;3189:52;3276:9;3263:23;3295:31;3320:5;3295:31;:::i;:::-;3345:5;-1:-1:-1;3402:2:1;3387:18;;3374:32;3415:30;3374:32;3415:30;:::i;:::-;3464:7;3454:17;;;3087:390;;;;;:::o;3482:388::-;3550:6;3558;3611:2;3599:9;3590:7;3586:23;3582:32;3579:52;;;3627:1;3624;3617:12;3579:52;3666:9;3653:23;3685:31;3710:5;3685:31;:::i;:::-;3735:5;-1:-1:-1;3792:2:1;3777:18;;3764:32;3805:33;3764:32;3805:33;:::i;4203:380::-;4282:1;4278:12;;;;4325;;;4346:61;;4400:4;4392:6;4388:17;4378:27;;4346:61;4453:2;4445:6;4442:14;4422:18;4419:38;4416:161;;4499:10;4494:3;4490:20;4487:1;4480:31;4534:4;4531:1;4524:15;4562:4;4559:1;4552:15;4416:161;;4203:380;;;:::o;4588:356::-;4790:2;4772:21;;;4809:18;;;4802:30;4868:34;4863:2;4848:18;;4841:62;4935:2;4920:18;;4588:356::o;5444:127::-;5505:10;5500:3;5496:20;5493:1;5486:31;5536:4;5533:1;5526:15;5560:4;5557:1;5550:15;5576:217;5616:1;5642;5632:132;;5686:10;5681:3;5677:20;5674:1;5667:31;5721:4;5718:1;5711:15;5749:4;5746:1;5739:15;5632:132;-1:-1:-1;5778:9:1;;5576:217::o;7424:125::-;7464:4;7492:1;7489;7486:8;7483:34;;;7497:18;;:::i;:::-;-1:-1:-1;7534:9:1;;7424:125::o;7554:168::-;7594:7;7660:1;7656;7652:6;7648:14;7645:1;7642:21;7637:1;7630:9;7623:17;7619:45;7616:71;;;7667:18;;:::i;:::-;-1:-1:-1;7707:9:1;;7554:168::o;8129:265::-;8168:3;8196:9;;;8221:10;;-1:-1:-1;;;;;8240:27:1;;;8233:35;;8217:52;8214:78;;;8272:18;;:::i;:::-;-1:-1:-1;;;8319:19:1;;;8312:27;;8304:36;;8301:62;;;8343:18;;:::i;:::-;-1:-1:-1;;8379:9:1;;8129:265::o;8399:128::-;8439:3;8470:1;8466:6;8463:1;8460:13;8457:39;;;8476:18;;:::i;:::-;-1:-1:-1;8512:9:1;;8399:128::o;9175:245::-;9242:6;9295:2;9283:9;9274:7;9270:23;9266:32;9263:52;;;9311:1;9308;9301:12;9263:52;9343:9;9337:16;9362:28;9384:5;9362:28;:::i;9785:267::-;9824:4;9853:9;;;9878:10;;-1:-1:-1;;;9897:19:1;;9890:27;;9874:44;9871:70;;;9921:18;;:::i;:::-;-1:-1:-1;;;;;9968:27:1;;9961:35;;9953:44;;9950:70;;;10000:18;;:::i;:::-;-1:-1:-1;;10037:9:1;;9785:267::o

ipfs://bde352e69e1552a9c30c4cecedf124c390616b69e45f6036832dfdd406053ce7