/** *Submitted for verification at Etherscan.io on 2022-10-07 */

// SPDX-License-Identifier: MIT

pragma solidity 0.8.13;

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;

}

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: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
	if (a == 0) {
		return 0;
	}

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

	return c;
}

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 Address { function isContract(address account) internal view returns (bool) { uint256 size; assembly { size := extcodesize(account) } return size > 0; }

function sendValue(address payable recipient, uint256 amount) internal {
	require(
		address(this).balance >= amount,
		"Address: insufficient balance"
	);

	(bool success, ) = recipient.call{value: amount}("");
	require(
		success,
		"Address: unable to send value, recipient may have reverted"
	);
}

function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
	return functionCall(target, data, "Address: low-level call failed");
}

function functionCall(
	address target,
	bytes memory data,
	string memory errorMessage
) internal returns (bytes memory) {
	return functionCallWithValue(target, data, 0, errorMessage);
}

function functionCallWithValue(
	address target,
	bytes memory data,
	uint256 value
) internal returns (bytes memory) {
	return
	functionCallWithValue(
		target,
		data,
		value,
		"Address: low-level call with value failed"
	);
}

function functionCallWithValue(
	address target,
	bytes memory data,
	uint256 value,
	string memory errorMessage
) internal returns (bytes memory) {
	require(
		address(this).balance >= value,
		"Address: insufficient balance for call"
	);
	require(isContract(target), "Address: call to non-contract");

	(bool success, bytes memory returndata) = target.call{value: value}(
	data
	);
	return _verifyCallResult(success, returndata, errorMessage);
}

function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
	return
	functionStaticCall(
		target,
		data,
		"Address: low-level static call failed"
	);
}

function functionStaticCall(
	address target,
	bytes memory data,
	string memory errorMessage
) internal view returns (bytes memory) {
	require(isContract(target), "Address: static call to non-contract");

	(bool success, bytes memory returndata) = target.staticcall(data);
	return _verifyCallResult(success, returndata, errorMessage);
}

function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
	return
	functionDelegateCall(
		target,
		data,
		"Address: low-level delegate call failed"
	);
}

function functionDelegateCall(
	address target,
	bytes memory data,
	string memory errorMessage
) internal returns (bytes memory) {
	require(isContract(target), "Address: delegate call to non-contract");

	(bool success, bytes memory returndata) = target.delegatecall(data);
	return _verifyCallResult(success, returndata, errorMessage);
}

function _verifyCallResult(
	bool success,
	bytes memory returndata,
	string memory errorMessage
) private pure returns (bytes memory) {
	if (success) {
		return returndata;
	} else {
		if (returndata.length > 0) {
			assembly {
				let returndata_size := mload(returndata)
				revert(add(32, returndata), returndata_size)
			}
		} else {
			revert(errorMessage);
		}
	}
}

}

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;

event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

constructor () {
	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;
}

}

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

IRouter public uniswapV2Router;
address public immutable uniswapV2Pair;

string private constant _name =  "The SkyToken";
string private constant _symbol = "SKY";
uint8 private constant _decimals = 18;

mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;

uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 37500000 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;

bool public isTradingEnabled;

// max wallet is 1.0% of initialSupply
uint256 public maxWalletAmount = _tTotal;

// max tx is 0.33% of initialSupply
uint256 public maxTxAmount = _tTotal;

bool private _swapping;

// max wallet is 0.025% of initialSupply
uint256 public minimumTokensBeforeSwap = _tTotal * 250 / 1000000;

address private dead = 0x000000000000000000000000000000000000dEaD;

address public liquidityWallet;
address public marketingWallet;
address public buyBackWallet;
address public devWallet;

struct CustomTaxPeriod {
	bytes23 periodName;
	uint8 blocksInPeriod;
	uint256 timeInPeriod;
	uint8 liquidityFeeOnBuy;
	uint8 liquidityFeeOnSell;
	uint8 marketingFeeOnBuy;
	uint8 marketingFeeOnSell;
    uint8 devFeeOnBuy;
	uint8 devFeeOnSell;
	uint8 buyBackFeeOnBuy;
	uint8 buyBackFeeOnSell;
	uint8 holdersFeeOnBuy;
	uint8 holdersFeeOnSell;
}

// Base taxes
CustomTaxPeriod private _base = CustomTaxPeriod('base',0,0,1,1,3,3,2,2,2,2,2,2);

uint256 private constant _blockedTimeLimit = 259200;
uint256 private _launchBlockNumber;
uint256 private _launchTimestamp;
mapping (address => bool) private _isBlocked;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isExcludedFromMaxWalletLimit;
mapping (address => bool) private _isExcludedFromMaxTransactionLimit;
mapping (address => bool) public automatedMarketMakerPairs;
mapping (address => bool) private _isExcludedFromDividends;
mapping (address => bool) private _isAllowedToTradeWhenDisabled;
address[] private _excludedFromDividends;

uint8 private _liquidityFee;
uint8 private _marketingFee;
uint8 private _devFee;
uint8 private _buyBackFee;
uint8 private _holdersFee;
uint8 private _totalFee;

event AutomatedMarketMakerPairChange(address indexed pair, bool indexed value);
event AllowedWhenTradingDisabledChange(address indexed account, bool isExcluded);
event BlockedAccountChange(address indexed holder, bool indexed status);
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 marketingFee, uint8 devFee, uint8 buyBackFee, uint8 holdersFee);
event CustomTaxPeriodChange(uint256 indexed newValue, uint256 indexed oldValue, string indexed taxType, bytes23 period);
event MaxWalletAmountChange(uint256 indexed newValue, uint256 indexed oldValue);
event MaxTransactionAmountChange(uint256 indexed newValue, uint256 indexed oldValue);
event ExcludeFromDividendsChange(address indexed account, bool isExcluded);
event ExcludeFromFeesChange(address indexed account, bool isExcluded);
event ExcludeFromMaxTransferChange(address indexed account, bool isExcluded);
event ExcludeFromMaxWalletChange(address indexed account, bool isExcluded);
event MinTokenAmountBeforeSwapChange(uint256 indexed newValue, uint256 indexed oldValue);
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived,uint256 tokensIntoLiqudity);
event ClaimETHOverflow(uint256 amount);
event FeesApplied(uint8 liquidityFee, uint8 marketingFee, uint8 devFee, uint8 buyBackFee, uint8 holdersFee, uint8 totalFee);

constructor() {
	liquidityWallet = owner();
	marketingWallet = owner();
	buyBackWallet = owner();
    devWallet = owner();

	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;

    excludeFromDividends(address(this), true);
	excludeFromDividends(address(dead), true);
	excludeFromDividends(address(_uniswapV2Router), true);

	_isAllowedToTradeWhenDisabled[owner()] = true;
	_isAllowedToTradeWhenDisabled[address(this)] = true;

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

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

	_rOwned[owner()] = _rTotal;
	emit Transfer(address(0), owner(), _tTotal);
}

receive() external payable {}

// Setters
function transfer(address recipient, uint256 amount) external override returns (bool) {
	_transfer(_msgSender(), recipient, amount);
	return true;
}
function approve(address spender, uint256 amount) public override returns (bool) {
	_approve(_msgSender(), spender, amount);
	return true;
}
function transferFrom( address sender,address recipient,uint256 amount) external 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) external virtual returns (bool){
	_approve(_msgSender(),spender,_allowances[_msgSender()][spender].add(addedValue));
	return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) external virtual returns (bool) {
	_approve(_msgSender(),spender,_allowances[_msgSender()][spender].sub(subtractedValue,"ERC20: decreased allowance below zero"));
	return true;
}
function _approve(address owner,address spender,uint256 amount) private {
	require(owner != address(0), "ERC20: approve from the zero address");
	require(spender != address(0), "ERC20: approve to the zero address");
	_allowances[owner][spender] = amount;
	emit Approval(owner, spender, amount);
}
function activateTrading() external onlyOwner {
	isTradingEnabled = true;
    if (_launchTimestamp == 0) {
		_launchTimestamp = block.timestamp;
		_launchBlockNumber = block.number;
	}
}
function deactivateTrading() external onlyOwner {
	isTradingEnabled = false;
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
	require(automatedMarketMakerPairs[pair] != value, "The SkyToken: Automated market maker pair is already set to that value");
	automatedMarketMakerPairs[pair] = value;
	emit AutomatedMarketMakerPairChange(pair, value);
}
function blockAccount(address account) external onlyOwner {
	require(!_isBlocked[account], "The SkyToken: Account is already blocked");
	require((block.timestamp - _launchTimestamp) < _blockedTimeLimit, "The SkyToken: Time to block accounts has expired");
	_isBlocked[account] = true;
	emit BlockedAccountChange(account, true);
}
function unblockAccount(address account) external onlyOwner {
	require(_isBlocked[account], "The SkyToken: Account is not blcoked");
	_isBlocked[account] = false;
	emit BlockedAccountChange(account, false);
}
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, "The SkyToken: Account is already the value of 'excluded'");
	_isExcludedFromFee[account] = excluded;
	emit ExcludeFromFeesChange(account, excluded);
}
function excludeFromMaxWalletLimit(address account, bool excluded) external onlyOwner {
	require(_isExcludedFromMaxWalletLimit[account] != excluded, "The SkyToken: Account is already the value of 'excluded'");
	_isExcludedFromMaxWalletLimit[account] = excluded;
	emit ExcludeFromMaxWalletChange(account, excluded);
}
function excludeFromMaxTransactionLimit(address account, bool excluded) external onlyOwner {
	require(_isExcludedFromMaxTransactionLimit[account] != excluded, "The SkyToken: Account is already the value of 'excluded'");
	_isExcludedFromMaxTransactionLimit[account] = excluded;
	emit ExcludeFromMaxTransferChange(account, excluded);
}
function setWallets(address newLiquidityWallet, address newMarketingWallet, address newDevWallet, address newBuyBackWallet) external onlyOwner {
	if(liquidityWallet != newLiquidityWallet) {
        require(newLiquidityWallet != address(0), "The SkyToken: The liquidityWallet cannot be 0");
		emit WalletChange('liquidityWallet', newLiquidityWallet, liquidityWallet);
		liquidityWallet = newLiquidityWallet;
	}
    if(marketingWallet != newMarketingWallet) {
        require(newMarketingWallet != address(0), "The SkyToken: The marketingWallet cannot be 0");
		emit WalletChange('marketingWallet', newMarketingWallet, marketingWallet);
		marketingWallet = newMarketingWallet;
	}
	if(devWallet != newDevWallet) {
        require(newDevWallet != address(0), "The SkyToken: The devWallet cannot be 0");
		emit WalletChange('devWallet', newDevWallet, devWallet);
		devWallet = newDevWallet;
	}
	if(buyBackWallet != newBuyBackWallet) {
        require(newBuyBackWallet != address(0), "The SkyToken: The buyBackWallet cannot be 0");
		emit WalletChange('buyBackWallet', newBuyBackWallet, buyBackWallet);
		buyBackWallet = newBuyBackWallet;
	}
}
// Base fees
function setBaseFeesOnBuy(uint8 _liquidityFeeOnBuy,  uint8 _marketingFeeOnBuy, uint8 _devFeeOnBuy,  uint8 _buyBackFeeOnBuy, uint8 _holdersFeeOnBuy) external onlyOwner {
	_setCustomBuyTaxPeriod(_base, _liquidityFeeOnBuy, _marketingFeeOnBuy, _devFeeOnBuy, _buyBackFeeOnBuy, _holdersFeeOnBuy);
	emit FeeChange('baseFees-Buy', _liquidityFeeOnBuy, _marketingFeeOnBuy, _devFeeOnBuy, _buyBackFeeOnBuy, _holdersFeeOnBuy);
}
function setBaseFeesOnSell(uint8 _liquidityFeeOnSell, uint8 _marketingFeeOnSell, uint8 _devFeeOnSell, uint8 _buyBackFeeOnSell, uint8 _holdersFeeOnSell) external onlyOwner {
	_setCustomSellTaxPeriod(_base, _liquidityFeeOnSell, _marketingFeeOnSell, _devFeeOnSell, _buyBackFeeOnSell, _holdersFeeOnSell);
	emit FeeChange('baseFees-Sell', _liquidityFeeOnSell, _marketingFeeOnSell, _devFeeOnSell, _buyBackFeeOnSell, _holdersFeeOnSell);
}
function setMaxWalletAmount(uint256 newValue) external onlyOwner {
	require(newValue != maxWalletAmount, "The SkyToken: Cannot update maxWalletAmount to same value");
	emit MaxWalletAmountChange(newValue, maxWalletAmount);
	maxWalletAmount = newValue;
}
function setMaxTransactionAmount(uint256 newValue) external onlyOwner {
	require(newValue != maxTxAmount, "The SkyToken: Cannot update maxTxAmount to same value");
    emit MaxTransactionAmountChange(newValue, maxTxAmount);
    maxTxAmount = newValue;
}
function excludeFromDividends(address account, bool excluded) public onlyOwner {
	require(_isExcludedFromDividends[account] != excluded, "The SkyToken: Account is already the value of 'excluded'");
	if(excluded) {
		if(_rOwned[account] > 0) {
			_tOwned[account] = tokenFromReflection(_rOwned[account]);
		}
		_isExcludedFromDividends[account] = excluded;
		_excludedFromDividends.push(account);
	} else {
		for (uint256 i = 0; i < _excludedFromDividends.length; i++) {
			if (_excludedFromDividends[i] == account) {
				_excludedFromDividends[i] = _excludedFromDividends[_excludedFromDividends.length - 1];
				_tOwned[account] = 0;
				_isExcludedFromDividends[account] = false;
				_excludedFromDividends.pop();
				break;
			}
		}
	}
	emit ExcludeFromDividendsChange(account, excluded);
}
function setMinimumTokensBeforeSwap(uint256 newValue) external onlyOwner {
	require(newValue != minimumTokensBeforeSwap, "The SkyToken: Cannot update minimumTokensBeforeSwap to same value");
	emit MinTokenAmountBeforeSwapChange(newValue, minimumTokensBeforeSwap);
	minimumTokensBeforeSwap = newValue;
}
function claimETHOverflow() external onlyOwner {
	require(address(this).balance > 0, "The SkyToken: Cannot send more than contract balance");
    uint256 amount = address(this).balance;
	(bool success,) = address(owner()).call{value : amount}("");
	if (success){
		emit ClaimETHOverflow(amount);
	}
}

// Getters
function name() external view returns (string memory) {
	return _name;
}
function symbol() external view returns (string memory) {
	return _symbol;
}
function decimals() external view virtual returns (uint8) {
	return _decimals;
}
function totalSupply() external view override returns (uint256) {
	return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
	if (_isExcludedFromDividends[account]) return _tOwned[account];
	return tokenFromReflection(_rOwned[account]);
}
function totalFees() external view returns (uint256) {
	return _tFeeTotal;
}
function allowance(address owner, address spender) external view override returns (uint256) {
	return _allowances[owner][spender];
}
function getBaseBuyFees() external view returns (uint8, uint8, uint8, uint8, uint8){
	return (_base.liquidityFeeOnBuy, _base.marketingFeeOnBuy, _base.devFeeOnBuy, _base.buyBackFeeOnBuy, _base.holdersFeeOnBuy);
}
function getBaseSellFees() external view returns (uint8, uint8, uint8, uint8, uint8){
	return (_base.liquidityFeeOnSell, _base.marketingFeeOnSell, _base.devFeeOnSell, _base.buyBackFeeOnSell, _base.holdersFeeOnSell);
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
	require(rAmount <= _rTotal, "The SkyToken: Amount must be less than total reflections");
	uint256 currentRate =  _getRate();
	return rAmount / currentRate;
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) external view returns (uint256) {
	require(tAmount <= _tTotal, "The SkyToken: Amount must be less than supply");
	uint256 currentRate = _getRate();
	uint256 rAmount  = tAmount * currentRate;
	if (!deductTransferFee) {
		return rAmount;
	}
	else {
		uint256 rTotalFee  = tAmount * _totalFee / 100 * currentRate;
		uint256 rTransferAmount = rAmount - rTotalFee;
		return rTransferAmount;
	}
}

// Main
function _transfer(
address from,
address to,
uint256 amount
) internal {
	require(from != address(0), "ERC20: transfer from the zero address");
	require(to != address(0), "ERC20: transfer to the zero address");
	require(amount > 0, "Transfer amount must be greater than zero");
	require(amount <= balanceOf(from), "The SkyToken: Cannot transfer more than balance");

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

	if(!_isAllowedToTradeWhenDisabled[from] && !_isAllowedToTradeWhenDisabled[to]) {
		require(isTradingEnabled, "The SkyToken: Trading is currently disabled.");
        require(!_isBlocked[to], "The SkyToken: Account is blocked");
		require(!_isBlocked[from], "The SkyToken: Account is blocked");
        if (!_isExcludedFromMaxTransactionLimit[to] && !_isExcludedFromMaxTransactionLimit[from]) {
            require(amount <= maxTxAmount, "The SkyToken: Transfer amount exceeds the maxTxAmount.");
        }
		if (!_isExcludedFromMaxWalletLimit[to]) {
			require((balanceOf(to) + amount) <= maxWalletAmount, "The SkyToken: Expected wallet amount exceeds the maxWalletAmount.");
		}
	}

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

	if (
		isTradingEnabled &&
		canSwap &&
		!_swapping &&
		_totalFee > 0 &&
		automatedMarketMakerPairs[to]
	) {
		_swapping = true;
		_swapAndLiquify();
		_swapping = false;
	}

	bool takeFee = !_swapping && isTradingEnabled;

	if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){
		takeFee = false;
	}
	_tokenTransfer(from, to, amount, takeFee);
}
function _tokenTransfer(address sender,address recipient, uint256 tAmount, bool takeFee) private {
	(uint256 tTransferAmount,uint256 tFee, uint256 tOther) = _getTValues(tAmount, takeFee);
	(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 rOther) = _getRValues(tAmount, tFee, tOther, _getRate());

	if (_isExcludedFromDividends[sender]) {
		_tOwned[sender] = _tOwned[sender] - tAmount;
	}
	if (_isExcludedFromDividends[recipient]) {
		_tOwned[recipient] = _tOwned[recipient] + tTransferAmount;
	}
	_rOwned[sender] = _rOwned[sender] - rAmount;
	_rOwned[recipient] = _rOwned[recipient] + rTransferAmount;
	_takeContractFees(rOther, tOther);
	_reflectFee(rFee, tFee);
	emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
	_rTotal -= rFee;
	_tFeeTotal += tFee;
}
function _getTValues(uint256 tAmount, bool takeFee) private view returns (uint256,uint256,uint256){
	if (!takeFee) {
		return (tAmount, 0, 0);
	}
	else {
		uint256 tFee = tAmount * _holdersFee / 100;
		uint256 tOther = tAmount * (_liquidityFee + _devFee + _marketingFee + _buyBackFee) / 100;
		uint256 tTransferAmount = tAmount - (tFee + tOther);
		return (tTransferAmount, tFee, tOther);
	}
}
function _getRValues(
	uint256 tAmount,
	uint256 tFee,
	uint256 tOther,
	uint256 currentRate
	) private pure returns ( uint256, uint256, uint256, uint256) {
	uint256 rAmount = tAmount * currentRate;
	uint256 rFee = tFee * currentRate;
	uint256 rOther = tOther * currentRate;
	uint256 rTransferAmount = rAmount - (rFee + rOther);
	return (rAmount, rTransferAmount, rFee, rOther);
}
function _getRate() private view returns (uint256) {
	(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
	return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns (uint256, uint256) {
	uint256 rSupply = _rTotal;
	uint256 tSupply = _tTotal;
	for (uint256 i = 0; i < _excludedFromDividends.length; i++) {
		if (
			_rOwned[_excludedFromDividends[i]] > rSupply ||
			_tOwned[_excludedFromDividends[i]] > tSupply
		) return (_rTotal, _tTotal);
		rSupply = rSupply - _rOwned[_excludedFromDividends[i]];
		tSupply = tSupply - _tOwned[_excludedFromDividends[i]];
	}
	if (rSupply < _rTotal / _tTotal) return (_rTotal, _tTotal);
	return (rSupply, tSupply);
}
function _takeContractFees(uint256 rOther, uint256 tOther) private {
	if (_isExcludedFromDividends[address(this)]) {
		_tOwned[address(this)] += tOther;
	}
	_rOwned[address(this)] += rOther;
}
function _adjustTaxes(bool isBuyFromLp, bool isSelltoLp) private {
	_liquidityFee = 0;
	_devFee = 0;
	_marketingFee = 0;
	_buyBackFee = 0;
	_holdersFee = 0;

	if (isBuyFromLp) {
        if ((block.number - _launchBlockNumber) <= 5) {
			_liquidityFee = 100;
		} else {
            _liquidityFee = _base.liquidityFeeOnBuy;
            _devFee = _base.devFeeOnBuy;
            _marketingFee = _base.marketingFeeOnBuy;
            _buyBackFee = _base.buyBackFeeOnBuy;
            _holdersFee = _base.holdersFeeOnBuy;
        }
	}
	if (isSelltoLp) {
        _liquidityFee = _base.liquidityFeeOnSell;
		_devFee = _base.devFeeOnSell;
		_marketingFee = _base.marketingFeeOnSell;
		_buyBackFee = _base.buyBackFeeOnSell;
		_holdersFee = _base.holdersFeeOnSell;

        if (block.timestamp - _launchTimestamp <= 259200) {
            _liquidityFee = 2;
            _devFee = 3;
            _marketingFee = 10;
            _buyBackFee = 8;
            _holdersFee = 2;
        }
	}
	_totalFee = _liquidityFee + _marketingFee + _devFee + _buyBackFee + _holdersFee;
	emit FeesApplied(_liquidityFee, _marketingFee, _devFee, _buyBackFee, _holdersFee, _totalFee);
}
function _setCustomSellTaxPeriod(CustomTaxPeriod storage map,
	uint8 _liquidityFeeOnSell,
	uint8 _marketingFeeOnSell,
    uint8 _devFeeOnSell,
	uint8 _buyBackFeeOnSell,
	uint8 _holdersFeeOnSell
) private {
	if (map.liquidityFeeOnSell != _liquidityFeeOnSell) {
		emit CustomTaxPeriodChange(_liquidityFeeOnSell, map.liquidityFeeOnSell, 'liquidityFeeOnSell', map.periodName);
		map.liquidityFeeOnSell = _liquidityFeeOnSell;
	}
	if (map.marketingFeeOnSell != _marketingFeeOnSell) {
		emit CustomTaxPeriodChange(_marketingFeeOnSell, map.marketingFeeOnSell, 'marketingFeeOnSell', map.periodName);
		map.marketingFeeOnSell = _marketingFeeOnSell;
	}
    if (map.devFeeOnSell != _devFeeOnSell) {
		emit CustomTaxPeriodChange(_devFeeOnSell, map.devFeeOnSell, 'devFeeOnSell', map.periodName);
		map.devFeeOnSell = _devFeeOnSell;
	}
	if (map.buyBackFeeOnSell != _buyBackFeeOnSell) {
		emit CustomTaxPeriodChange(_buyBackFeeOnSell, map.buyBackFeeOnSell, 'buyBackFeeOnSell', map.periodName);
		map.buyBackFeeOnSell = _buyBackFeeOnSell;
	}
	if (map.holdersFeeOnSell != _holdersFeeOnSell) {
		emit CustomTaxPeriodChange(_holdersFeeOnSell, map.holdersFeeOnSell, 'holdersFeeOnSell', map.periodName);
		map.holdersFeeOnSell = _holdersFeeOnSell;
	}
}
function _setCustomBuyTaxPeriod(CustomTaxPeriod storage map,
	uint8 _liquidityFeeOnBuy,
	uint8 _marketingFeeOnBuy,
    uint8 _devFeeOnBuy,
	uint8 _buyBackFeeOnBuy,
	uint8 _holdersFeeOnBuy
) private {
	if (map.liquidityFeeOnBuy != _liquidityFeeOnBuy) {
		emit CustomTaxPeriodChange(_liquidityFeeOnBuy, map.liquidityFeeOnBuy, 'liquidityFeeOnBuy', map.periodName);
		map.liquidityFeeOnBuy = _liquidityFeeOnBuy;
	}
	if (map.marketingFeeOnBuy != _marketingFeeOnBuy) {
		emit CustomTaxPeriodChange(_marketingFeeOnBuy, map.marketingFeeOnBuy, 'marketingFeeOnBuy', map.periodName);
		map.marketingFeeOnBuy = _marketingFeeOnBuy;
	}
    if (map.devFeeOnBuy != _devFeeOnBuy) {
		emit CustomTaxPeriodChange(_devFeeOnBuy, map.devFeeOnBuy, 'devFeeOnBuy', map.periodName);
		map.devFeeOnBuy = _devFeeOnBuy;
	}
	if (map.buyBackFeeOnBuy != _buyBackFeeOnBuy) {
		emit CustomTaxPeriodChange(_buyBackFeeOnBuy, map.buyBackFeeOnBuy, 'buyBackFeeOnBuy', map.periodName);
		map.buyBackFeeOnBuy = _buyBackFeeOnBuy;
	}
	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;

	uint8 totalFeePrior = _totalFee;
    uint8 liquidityFeePrior = _liquidityFee;
    uint8 marketingFeePrior = _marketingFee;
    uint8 devFeePrior = _devFee;
    uint8 buyBackFeePrior  = _buyBackFee;
	uint8 holdersFeePrior = _holdersFee;

	uint256 amountToLiquify = contractBalance * _liquidityFee / _totalFee / 2;
	uint256 amountToSwapForETH = contractBalance - amountToLiquify;

	_swapTokensForETH(amountToSwapForETH);

	uint256 ETHBalanceAfterSwap = address(this).balance - initialETHBalance;
	uint256 totalETHFee = totalFeePrior - (liquidityFeePrior / 2) - (holdersFeePrior);
	uint256 amountETHLiquidity = ETHBalanceAfterSwap * liquidityFeePrior / totalETHFee / 2;
	uint256 amountETHDev = ETHBalanceAfterSwap * devFeePrior / totalETHFee;
	uint256 amountETHBuyBack = ETHBalanceAfterSwap * buyBackFeePrior / totalETHFee;
	uint256 amountETHMarketing = ETHBalanceAfterSwap - (amountETHLiquidity + amountETHDev + amountETHBuyBack);

	payable(marketingWallet).transfer(amountETHMarketing);
	payable(devWallet).transfer(amountETHDev);
	payable(buyBackWallet).transfer(amountETHBuyBack);

	if (amountToLiquify > 0) {
		_addLiquidity(amountToLiquify, amountETHLiquidity);
		emit SwapAndLiquify(amountToSwapForETH, amountETHLiquidity, amountToLiquify);
	}
	_totalFee = totalFeePrior;
    _liquidityFee = liquidityFeePrior;
    _marketingFee = marketingFeePrior;
    _devFee = devFeePrior;
    _buyBackFee = buyBackFeePrior;
	_holdersFee = holdersFeePrior;
}
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
	);
}
function _addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
	_approve(address(this), address(uniswapV2Router), tokenAmount);
	uniswapV2Router.addLiquidityETH{value: ethAmount}(
	address(this),
	tokenAmount,
	0, // slippage is unavoidable
	0, // slippage is unavoidable
	liquidityWallet,
	block.timestamp
	);
}

}