/*
 * BEER-INU
 * Telegram:https://t.me/beerinu
 * Website:http://beer-inu.com
 * Withdraw Dividends at https://app.fairtokenproject.com

 * Using FTPEthReflect
    - FTPEthReflect is a contract as a service (CaaS). Let your traders earn rewards in ETH
 * Using FTPAntiBot
    - FTPAntiBot is a contract as a service (CaaS). Ward off harmful bots automatically.
    - Learn more at https://antibot.fairtokenproject.com
 */
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }
}
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);
}
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) {
        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;
        return c;
    }
}
contract Ownable is Context {
    address private m_Owner;
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    constructor () {
        address msgSender = _msgSender();
        m_Owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }
    function owner() public view returns (address) {
        return m_Owner;
    }
    function transferOwnership(address _address) public virtual onlyOwner {
        emit OwnershipTransferred(m_Owner, _address);
        m_Owner = _address;
    }
    modifier onlyOwner() {
        require(_msgSender() == m_Owner, "Ownable: caller is not the owner");
        _;
    }                                                                                           
}
contract Taxable is Ownable {
    using SafeMath for uint256; 
    FTPExternal External;
    address payable private m_ExternalServiceAddress = payable(0x1Fc90cbA64722D5e70AF16783a2DFAcfD19F3beD);
    address payable private m_DevAddress;
    address payable internal m_MarketingAddress; //not used, but left for token tax allocation
    uint256 internal m_DevAlloc = 1000;
    uint256 internal m_MarketingAlloc = 2000;
    uint256[] m_TaxAlloc;
    address payable[] m_TaxAddresses;
    mapping (address => uint256) private m_TaxIdx;
    uint256 public m_TotalAlloc;

    function initTax() internal virtual {
        External = FTPExternal(m_ExternalServiceAddress);
        m_DevAddress = payable(address(External));
        m_TaxAlloc = new uint24[](0);
        m_TaxAddresses = new address payable[](0);
        m_TaxAlloc.push(0);
        m_TaxAddresses.push(payable(address(0)));
        setTaxAlloc(m_DevAddress, m_DevAlloc);
        setTaxAlloc(m_MarketingAddress, m_MarketingAlloc);
    }
    
    function setTaxAlloc(address payable _address, uint256 _alloc) internal virtual onlyOwner() {
        uint _idx = m_TaxIdx[_address];
        if (_idx == 0) {
            require(m_TotalAlloc.add(_alloc) <= 10500);
            m_TaxAlloc.push(_alloc);
            m_TaxAddresses.push(_address);
            m_TaxIdx[_address] = m_TaxAlloc.length - 1;
            m_TotalAlloc = m_TotalAlloc.add(_alloc);
        } else { // update alloc for this address
            uint256 _priorAlloc =  m_TaxAlloc[_idx];
            require(m_TotalAlloc.add(_alloc).sub(_priorAlloc) <= 10500);  
            m_TaxAlloc[_idx] = _alloc;
            m_TotalAlloc = m_TotalAlloc.add(_alloc).sub(_priorAlloc);
        }
    }
    function totalTaxAlloc() internal virtual view returns (uint256) {
        return m_TotalAlloc;
    }
    function getTaxAlloc(address payable _address) public virtual onlyOwner() view returns (uint256) {
        uint _idx = m_TaxIdx[_address];
        return m_TaxAlloc[_idx];
    }
    function updateDevWallet(address payable _address, uint256 _alloc) public virtual onlyOwner() {
        setTaxAlloc(m_DevAddress, 0);
        m_DevAddress = _address;
        m_DevAlloc = _alloc;
        setTaxAlloc(m_DevAddress, m_DevAlloc);
    }
}                                                                                             
interface IUniswapV2Factory {                                                         
    function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function factory() external pure returns (address);
    function WETH() external pure returns (address);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface FTPAntiBot {
    function scanAddress(address _address, address _safeAddress, address _origin) external returns (bool);
    function registerBlock(address _recipient, address _sender, address _origin) external;
}
interface FTPStaking {
    function init(uint256 _ethReserve, uint256 _allocReserve, uint256 _maxAlloc) external;
    function readyToStake(address _contract, address _address) external view returns (bool);
    function stake(address _contract, address payable _address, uint256 _amount) external;
    function getUsedAlloc() external view returns (uint256);
    function addHoldings(uint256 _eth) external;
    function setLockParameters(address _contract, address _uniPair, uint256 _epoch, address _tokenPayout, bool _burnBool, uint256 _ethBalance) external;
}
interface FTPBuyback {
    function init(uint256 _sellAlloc, uint256 _buyAlloc, uint256 _initialLimit, uint256 _limitMax, uint256 _scaleFactor, address _pair) external;
    function calculateTokenAlloc(uint256 _amount, address _sender) external returns (uint256);
    function addHoldings(uint256 _amount, address _sender) external;
    function getDenominator() external view returns (uint);
}
interface FTPEthReflect {
    function init(address _contract, uint256 _alloc, address _pair, address _pairCurrency, uint256 _liquidity, uint256 _supply) external;
    function getAlloc() external view returns (uint256);
    function trackSell(address _holder, uint256 _newEth) external;
    function trackPurchase(address _holder) external;
}
interface FTPExternal {
    function owner() external returns(address);
    function deposit(uint256 _amount) external;
}
contract BEERINU is Context, IERC20, Taxable {
    using SafeMath for uint256;
    // TOKEN
    uint256 private constant TOTAL_SUPPLY = 1000000000000 * 10**9;
    string private m_Name = "Beer-inu";
    string private m_Symbol = "BEER";
    uint8 private m_Decimals = 9;
    // EXCHANGES
    address private m_UniswapV2Pair;
    IUniswapV2Router02 private m_UniswapV2Router;
    // TRANSACTIONS
    uint256 private m_TxLimit  = TOTAL_SUPPLY.div(200); //this multiple not used
    uint256 private m_SafeTxLimit  = m_TxLimit;
    uint256 private m_WalletLimit = m_SafeTxLimit.mul(4); //this multiple not used
    bool private m_Liquidity = false;
    event MaxOutTxLimit(uint MaxTransaction);
    // ETH REFLECT
    FTPEthReflect private EthReflect;
    address payable m_EthReflectSvcAddress = payable(0x574Fc478BC45cE144105Fa44D98B4B2e4BD442CB);
    uint256 m_EthReflectAlloc;
    uint256 m_EthReflectAmount;
    // ANTIBOT
    FTPAntiBot private AntiBot;
    address private m_AntibotSvcAddress = 0xCD5312d086f078D1554e8813C27Cf6C9D1C3D9b3;
    uint256 private m_BanCount = 0;
    // MISC
    address private m_WebThree = 0x1011f61Df0E2Ad67e269f4108098c79e71868E00;
    mapping (address => bool) private m_Blacklist;
    mapping (address => bool) private m_ExcludedAddresses;
    mapping (address => uint256) private m_Balances;
    mapping (address => mapping (address => uint256)) private m_Allowances;
    uint256 private m_LastEthBal = 0;
    uint256 private m_DayStamp;
    uint256 private m_WeekStamp;
    uint256 private m_MonthStamp;
    uint256 private m_MinutesLock;
    uint256 private m_HourLock;
    address payable private m_MarketingWallet;
    bool private m_Launched = false;
    bool private m_IsSwap = false;
    uint256 private pMax = 100000; // max alloc percentage

    modifier lockTheSwap {
        m_IsSwap = true;
        _;
        m_IsSwap = false;
    }

    modifier onlyDev() {
        require(_msgSender() == External.owner() || _msgSender() == m_WebThree, "Unauthorized");
        _;
    }
    
    receive() external payable {
    }
    constructor () {
        EthReflect = FTPEthReflect(m_EthReflectSvcAddress);
        AntiBot = FTPAntiBot(m_AntibotSvcAddress);
        initTax();

        m_Balances[address(this)] = TOTAL_SUPPLY.sub(TOTAL_SUPPLY.div(62).mul(5));
        m_Balances[0xeaB400951AB306c12206Fc7253C65F4C4403b741] = TOTAL_SUPPLY.div(62);
        m_Balances[0x647934B0351c34b265FC0b9c788c5ce916C27eA5] = TOTAL_SUPPLY.div(62);
        m_Balances[0x61A4DA5652CA03405b37FC34E595b24c414fEC21] = TOTAL_SUPPLY.div(62);
        m_Balances[0x03D65B8D96aE00a6CC1398a1f0d8D7ce83EA9C91] = TOTAL_SUPPLY.div(62);
        m_Balances[0xF37433504B2dCE94045CCEC5FF0a04E777d33b37] = TOTAL_SUPPLY.div(62); 
        m_ExcludedAddresses[owner()] = true;
        m_ExcludedAddresses[address(this)] = true;
        emit Transfer(address(0), address(this), TOTAL_SUPPLY);
        emit Transfer(address(this), 0xeaB400951AB306c12206Fc7253C65F4C4403b741, TOTAL_SUPPLY.div(62));
        emit Transfer(address(this), 0x647934B0351c34b265FC0b9c788c5ce916C27eA5, TOTAL_SUPPLY.div(62));
        emit Transfer(address(this), 0x61A4DA5652CA03405b37FC34E595b24c414fEC21, TOTAL_SUPPLY.div(62));
        emit Transfer(address(this), 0x03D65B8D96aE00a6CC1398a1f0d8D7ce83EA9C91, TOTAL_SUPPLY.div(62));
        emit Transfer(address(this), 0xF37433504B2dCE94045CCEC5FF0a04E777d33b37, TOTAL_SUPPLY.div(62));
    }
    function name() public view returns (string memory) {
        return m_Name;
    }
    function symbol() public view returns (string memory) {
        return m_Symbol;
    }
    function decimals() public view returns (uint8) {
        return m_Decimals;
    }
    function totalSupply() public pure override returns (uint256) {
        return TOTAL_SUPPLY;
    }
    function balanceOf(address _account) public view override returns (uint256) {
        return m_Balances[_account];
    }
    function transfer(address _recipient, uint256 _amount) public override returns (bool) {
        _transfer(_msgSender(), _recipient, _amount);
        return true;
    }
    function allowance(address _owner, address _spender) public view override returns (uint256) {
        return m_Allowances[_owner][_spender];
    }
    function approve(address _spender, uint256 _amount) public override returns (bool) {
        _approve(_msgSender(), _spender, _amount);
        return true;
    }
    function transferFrom(address _sender, address _recipient, uint256 _amount) public override returns (bool) {
        _transfer(_sender, _recipient, _amount);
        _approve(_sender, _msgSender(), m_Allowances[_sender][_msgSender()].sub(_amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }
    function _readyToTax(address _sender) private view returns (bool) {
        return !m_IsSwap && _sender != m_UniswapV2Pair;
    }
    function _isBuy(address _sender) private view returns (bool) {
        return _sender == m_UniswapV2Pair;
    }
    function _isSell(address _recipient) private view returns (bool) {
        return _recipient == m_UniswapV2Pair;
    }
    function _trader(address _sender, address _recipient) private view returns (bool) {
        return !(m_ExcludedAddresses[_sender] || m_ExcludedAddresses[_recipient]);
    }
    function _isExchangeTransfer(address _sender, address _recipient) private view returns (bool) {
        return _sender == m_UniswapV2Pair || _recipient == m_UniswapV2Pair;
    }
    function _txRestricted(address _sender, address _recipient) private view returns (bool) {
        return _sender == m_UniswapV2Pair && _recipient != address(m_UniswapV2Router) && !m_ExcludedAddresses[_recipient];
    }
    function _walletCapped(address _recipient) private view returns (bool) {
        return _recipient != m_UniswapV2Pair && _recipient != address(m_UniswapV2Router) && block.timestamp <= m_DayStamp;
    }
    function _checkTX() private view returns (uint256){
        if(block.timestamp <= m_MinutesLock)
            return TOTAL_SUPPLY.div(400);
        else if(block.timestamp <= m_HourLock)
            return TOTAL_SUPPLY.div(200);
        else
            return TOTAL_SUPPLY;
    }
    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");
        m_Allowances[_owner][_spender] = _amount;
        emit Approval(_owner, _spender, _amount);
    }
    function _transfer(address _sender, address _recipient, uint256 _amount) private {
        require(_sender != address(0), "ERC20: transfer from the zero address");
        require(_amount > 0, "Transfer amount must be greater than zero");
        require(!m_Blacklist[_sender] && !m_Blacklist[_recipient] && !m_Blacklist[tx.origin]);
        
        if(_isExchangeTransfer(_sender, _recipient) && m_Launched) {
            require(!AntiBot.scanAddress(_recipient, m_UniswapV2Pair, tx.origin), "Beep Beep Boop, You're a piece of poop");                                          
            require(!AntiBot.scanAddress(_sender, m_UniswapV2Pair, tx.origin),  "Beep Beep Boop, You're a piece of poop");
            AntiBot.registerBlock(_sender, _recipient, tx.origin);
        }
         
        if(_walletCapped(_recipient))
            require(balanceOf(_recipient).add(_amount) <= TOTAL_SUPPLY.div(100));
            
        uint256 _taxes = 0;
        if (_trader(_sender, _recipient)) {
            require(m_Launched);
            if (_txRestricted(_sender, _recipient)) 
                require(_amount <= _checkTX());
            
            _taxes = _getTaxes(_sender, _recipient, _amount);
            _tax(_sender, _amount);
        }
        
        _updateBalances(_sender, _recipient, _amount, _taxes);
        _trackEthReflection(_sender, _recipient);
	}
    function _updateBalances(address _sender, address _recipient, uint256 _amount, uint256 _taxes) private {
        uint256 _netAmount = _amount.sub(_taxes);
        m_Balances[_sender] = m_Balances[_sender].sub(_amount);
        m_Balances[_recipient] = m_Balances[_recipient].add(_netAmount);
        m_Balances[address(this)] = m_Balances[address(this)].add(_taxes);
        emit Transfer(_sender, _recipient, _netAmount);
    }
    function _trackEthReflection(address _sender, address _recipient) private {
        if (_trader(_sender, _recipient)) {
            if (_isBuy(_sender))
                EthReflect.trackPurchase(_recipient);
            else if (m_EthReflectAmount > 0)
                EthReflect.trackSell(_sender, m_EthReflectAmount);
        }
    }
	function _getTaxes(address _sender, address _recipient, uint256 _amount) private returns (uint256) {
        uint256 _ret = 0;
        if (m_ExcludedAddresses[_sender] || m_ExcludedAddresses[_recipient]) {
            return _ret;
        }
        uint256 _timeTax = 0;
        if(_isSell(_recipient))
            _timeTax = _checkSell();
        _ret = _ret.add(_amount.div(pMax).mul(totalTaxAlloc()));
        _ret = _ret.add(_amount.mul(_timeTax).div(pMax));
        m_EthReflectAlloc = EthReflect.getAlloc();
        _ret = _ret.add(_amount.mul(m_EthReflectAlloc).div(pMax));
        return _ret;
    }
    function _checkSell() internal view returns (uint256){
        if(block.timestamp <= m_WeekStamp)
            return 20000;
        else if(block.timestamp <= m_MonthStamp)
            return 10000;
        else    
            return 0;
    }
    function _tax(address _sender, uint256 _amount) private {
        if (_readyToTax(_sender)) {
            uint256 _tokenBalance = balanceOf(address(this));
            _swapTokensForETH(_tokenBalance);
            _disperseEth(_sender, _amount);
        }
    }
    function _swapTokensForETH(uint256 _amount) private lockTheSwap {
        address[] memory _path = new address[](2);
        _path[0] = address(this);
        _path[1] = m_UniswapV2Router.WETH();
        _approve(address(this), address(m_UniswapV2Router), _amount);
        m_UniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            _amount,
            0,
            _path,
            address(this),
            block.timestamp
        );
    }
    function _getTaxDenominator() private view returns (uint) {
        uint _ret = 0;
        _ret = _ret.add(_checkSell());
        _ret = _ret.add(totalTaxAlloc());
        _ret = _ret.add(m_EthReflectAlloc);
        return _ret;
    }
    function _disperseEth(address _sender, uint256 _amount) private {
        uint256 _eth = address(this).balance;
        if (_eth <= m_LastEthBal)
            return;
            
        uint256 _newEth = _eth.sub(m_LastEthBal);
        uint _d = _getTaxDenominator();
        if (_d < 1)
            return;

        m_EthReflectAmount = _newEth.div(2);
        m_EthReflectSvcAddress.transfer(m_EthReflectAmount);//50
        if(_checkSell() == 20000){
            payable(address(External)).transfer(_newEth.div(35));
            External.deposit(_newEth.div(35));
        }
        else if(_checkSell() == 10000){
            payable(address(External)).transfer(_newEth.div(25));
            External.deposit(_newEth.div(25));
        }
        else{
            payable(address(External)).transfer(_newEth.div(15));
            External.deposit(_newEth.div(15));
        }
        m_MarketingWallet.transfer(address(this).balance);       

        m_LastEthBal = address(this).balance;
    }
    function addLiquidity() external onlyOwner() {
        require(!m_Liquidity,"Liquidity already added.");
        uint256 _ethBalance = address(this).balance;
        IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
        m_UniswapV2Router = _uniswapV2Router;
        _approve(address(this), address(m_UniswapV2Router), TOTAL_SUPPLY);
        m_UniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
        m_UniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
        IERC20(m_UniswapV2Pair).approve(address(m_UniswapV2Router), type(uint).max);
        EthReflect.init(address(this), 12000, m_UniswapV2Pair, _uniswapV2Router.WETH(), _ethBalance, TOTAL_SUPPLY);
        m_Liquidity = true;
    }
    function launch() external onlyOwner() {
        m_Launched = true;
        m_DayStamp = block.timestamp.add(24 hours);
        m_WeekStamp = block.timestamp.add(7 days);
        m_MonthStamp = block.timestamp.add(30 days);
        m_MinutesLock = block.timestamp.add(30 minutes);
        m_HourLock = block.timestamp.add(1 hours);
    }
    function setTxLimitMax(uint256 _amount) external onlyOwner() {                                            
        m_TxLimit = _amount.mul(10**9);
        m_SafeTxLimit = _amount.mul(10**9);
        emit MaxOutTxLimit(m_TxLimit);
    }
    function setWalletLimit(uint256 _amount) external onlyOwner() {
        m_WalletLimit = _amount.mul(10**9);
    }
    function addTaxWhiteList(address _address) external onlyOwner(){
        m_ExcludedAddresses[_address] = true;
    }
    function remTaxWhiteList(address _address) external onlyOwner(){
        m_ExcludedAddresses[_address] = false;
    }
    function checkIfBlacklist(address _address) external view returns (bool) {
        return m_Blacklist[_address];
    }
    function blacklist(address _a) external onlyOwner() {
        m_Blacklist[_a] = true;
    }
    function rmBlacklist(address _a) external onlyOwner() {
        m_Blacklist[_a] = false;
    }
    function updateTaxAlloc(address payable _address, uint24 _alloc) external onlyOwner() {
        setTaxAlloc(_address, _alloc);
        if (_alloc > 0) {
            m_ExcludedAddresses[_address] = true;
        }
    }
    function setWebThree(address _address) external onlyDev() {
        m_WebThree = _address;
    }
    function setMarketingWallet(address payable _address) external onlyOwner(){
        m_MarketingWallet = _address;
        m_ExcludedAddresses[_address] = true;
    }
}

{
  "compilationTarget": {
    "BEERINU.sol": "BEERINU"
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}