/**
*Submitted for verification at BscScan.com on 2020-09-09
*/

pragma solidity 0.5.16;

interface IBEP20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);

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

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

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

/**
* @dev Returns the bep token owner.
*/
function getOwner() external view returns (address);

/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);

/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);

/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address _owner, address spender) external view returns (uint256);

/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);

/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
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);


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

event PledgeMiner(address indexed from,address indexed to, uint256 value,uint256 pledge_id);

/**
* @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);


}

/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }

function _msgSender() internal view returns (address payable) {
return msg.sender;
}

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

/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition b y reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
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;
}
}

interface IPancakeSwapPair {
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;
}

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

interface IPancakeSwapFactory {
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;
}

contract Ownable is Context {
address private _owner;

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

/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}

/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}

/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}

/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}

/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}

/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
*/
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}


contract OutLets is Context,IBEP20, Ownable {
using SafeMath for uint256;

mapping (address => uint256) private _balances;

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

uint256 private _totalSupply;
uint8 public _decimals;
string public _symbol;
string public _name;

uint256 liquidityRate = 30; //buy
uint256 totalTransAward = 40;
uint[3] transAwardArr = [20,10,10]; //buy

uint256 destoryRate = 50; //sell
uint256 consensusRate = 20; //sell

uint256 transAwardGetStart = 1 * 10**18;

address public consensus_address = 0x3Db3Be366C854f4DC2b50E05f95AcA95D19f1F47;
address public liquidity_address = 0x87eBeb5E2E26E7395FEC56B8296c3Fcf55D8cAc5;
address public dao_address = 0x8B47a456c00eea58b824a880d291Fb4140D002d1;

uint256 HdFee = 100; //滑点总计手续费

address public pair;

address usdtAddress = 0x55d398326f99059fF775485246999027B3197955;

IPancakeSwapRouter public router;

mapping(address => address) private recomRelation;
mapping(address => bool) private registerAddress;

constructor(address _pancakeSwapRouter) public {

require(_pancakeSwapRouter!=address(0),"invalid swap router address");

router = IPancakeSwapRouter(_pancakeSwapRouter);

pair = IPancakeSwapFactory(router.factory()).createPair(
usdtAddress,
address(this)
);

registerAddress[address(this)] = true;

_name = "OUTLETS";
_symbol = "OUTLETS";
_decimals = 18;
_totalSupply = 100000000 * 10**18;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);

}

/**
* @dev Returns the bep token owner.
*/
function getOwner() external view returns (address) {
return owner();
}

/**
* @dev Returns the token decimals.
*/
function decimals() external view returns (uint8) {
return _decimals;
}

/**
* @dev Returns the token symbol.
*/
function symbol() external view returns (string memory) {
return _symbol;
}

/**
* @dev Returns the token name.
*/
function name() external view returns (string memory) {
return _name;
}

/**
* @dev See {BEP20-totalSupply}.
*/
function totalSupply() external view returns (uint256) {
return _totalSupply;
}

/**
* @dev See {BEP20-balanceOf}.
*/
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}

/**
* return true; need register
* return false; not need register
*/
function checkNeedRegister(address account) external view returns (bool) {

if(!registerAddress[account]){
return true;
}else{
return false;
}
}

/* find recommender address by search address */
function findRecommendAddress(address account) external view returns (address) {
require(registerAddress[account], "Not register");
require(account != address(this) , "This is contract address");
require(recomRelation[account] != address(0) , "Not in recommend relation");
return recomRelation[account];
}


/**
* to do register address
*/
function doRegister(address recom_address) external returns (bool) {

require(!registerAddress[_msgSender()], "Have been registered");
require(registerAddress[recom_address], "Recommend adreess not exsit");
require(recomRelation[_msgSender()] == address(0), "Have in recom relation");

registerAddress[_msgSender()] = true;
recomRelation[_msgSender()] = recom_address;

return true;
}


/**
* @dev See {BEP20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) external returns (bool) {

_transfer(_msgSender(), recipient, amount, owner());

return true;
}


function _transfer(address sender, address recipient, uint256 amount,address owner) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");

uint256 recipientAmount = amount;

if(sender != owner){

if(sender == pair){ //LP buy
uint256 transaction_send_rate;
(transaction_send_rate) = _transactionReward(sender,recipient,amount);
_liquidity(sender,liquidity_address,amount * liquidityRate / 1000);

uint256 DaoRate = HdFee - transaction_send_rate - liquidityRate;

_daoAward(sender,dao_address,amount * DaoRate / 1000);
recipientAmount = amount * (1000-HdFee) / 1000;

}else if(recipient == pair){ //LP sell

_destory(sender,address(0),amount * destoryRate / 1000);
_consensus(sender,consensus_address,amount * consensusRate / 1000);
uint256 DaoRate = HdFee - destoryRate - consensusRate;
_daoAward(sender,dao_address,amount * DaoRate / 1000);

recipientAmount = amount * (1000-HdFee) / 1000;
}
}

_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(recipientAmount);

emit Transfer(sender, recipient, recipientAmount);

}

/*trade award total 4 %*/
function _transactionReward(address sender,address buyer_account,uint256 amount) internal returns (uint256){
uint256 have_send_rate = 0;
if(!registerAddress[buyer_account]){
return (have_send_rate);
}

for(uint8 i=0;i<3;i ){
if(i>=3){break;}

address recom_address = recomRelation[buyer_account];

if(recom_address == address(0) || recom_address == address(this)){
break;
}
bool shouldSendAward =_balances[recom_address] >= transAwardGetStart;

if(shouldSendAward){
have_send_rate = transAwardArr[i];
uint256 getTrAward = amount * transAwardArr[i] / 1000;
_balances[recom_address] = _balances[recom_address].add(getTrAward);

emit Transfer(sender, recom_address, amount * transAwardArr[i] / 1000);
}

buyer_account = recom_address;
}


return (have_send_rate);

}


// in dao pool
function _daoAward(address account, address to,uint256 amount) internal {

_balances[to] = _balances[to].add(amount);

emit Transfer(account, to, amount);

emit Daopool(account,to, amount);
}

//in consensus address
function _consensus(address account, address to,uint256 amount) internal {

_balances[to] = _balances[to].add(amount);

emit Transfer(account, to, amount);
}


//in liquidity address
function _liquidity(address account, address to,uint256 amount) internal {
_balances[to] = _balances[to].add(amount);

emit Transfer(account, to, amount);
}


//destory
function _destory(address account, address to,uint256 amount) internal {

_balances[to] = _balances[to].add(amount);

emit Transfer(account, to, amount);
}

//set hd fee fang zhi za pan
function setHdFee(uint256 fee) public onlyOwner returns (bool) {
require(fee >= 100 && fee <= 200,"Fee amount invalid, need 100 to 200");
HdFee = fee;
return true;
}

function getHdFee() external view returns (uint256) {
return HdFee;
}

// set recom award get start symbol balance
function setTransAwardGetStart(uint256 amount) public onlyOwner returns (bool) {
transAwardGetStart = amount * 10 ** 18;
return true;
}


function getTransAwardGetStart() external view returns (uint256) {
return transAwardGetStart;
}

function getLpPair() external view returns (address) {
return pair;
}

//pledge miner
function pledgeMiner(address recipient, uint256 amount,uint256 pledge_id) external returns (bool) {

_pledgeMiner(_msgSender(), recipient, amount,pledge_id);

return true;
}

function _pledgeMiner(address sender, address recipient, uint256 amount,uint256 pledge_id) internal {
require(sender != address(0), "BEP20: pledge from the zero address");
require(recipient != address(0), "BEP20: pledge to the zero address");
require(sender != pair, "BEP20: pledge from the pair address");
require(recipient != pair, "BEP20: pledge to the pair address");

_balances[sender] = _balances[sender].sub(amount, "BEP20: pledge amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);

emit PledgeMiner(sender, recipient, amount,pledge_id);
}

/**
* @dev See {BEP20-allowance}.
*/
function allowance(address owner, address spender) external view returns (uint256) {
return _allowances[owner][spender];
}

/**
* @dev See {BEP20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) external returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}


/**
* @dev See {BEP20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {BEP20};
*
* 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) external returns (bool) {
_transfer(sender, recipient, amount,owner());
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: 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 {BEP20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public 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 {BEP20-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 returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}

/**
* @dev Creates `amount` tokens and assigns them to `msg.sender`, increasing
* the total supply.
*
* Requirements
*
* - `msg.sender` must be the token owner
*/


/**
* @dev Burn `amount` tokens and decreasing the total supply.
*/
function burn(uint256 amount) public returns (bool) {
_burn(_msgSender(), amount);
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`.
*/




/**
* @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 {
require(account != address(0), "BEP20: burn from the zero address");

_balances[account] = _balances[account].sub(amount, "BEP20: 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 is 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 {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");

_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}

/**
* @dev Destroys `amount` tokens from `account`.`amount` is then deducted
* from the caller's allowance.
*
* See {_burn} and {_approve}.
*/
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance"));
}

}