// SPDX-License-Identifier: UNLICENSED 
pragma solidity 0.8.9;     

contract RMath {

    function btoi(uint a)
        internal pure
        returns (uint)
    {
        return a / 10**18;
    }

    function bfloor(uint a)
        internal pure
        returns (uint)
    {
        return btoi(a) * 10**18;
    }

    function badd(uint a, uint b)
        internal pure
        returns (uint)
    {
        uint c = a + b;
        require(c >= a, "ERR_ADD_OVERFLOW");
        return c;
    }

    function bsub(uint a, uint b)
        internal pure
        returns (uint)
    {
        (uint c, bool flag) = bsubSign(a, b);
        require(!flag, "ERR_SUB_UNDERFLOW");
        return c;
    }

    function bsubSign(uint a, uint b)
        internal pure
        returns (uint, bool)
    {
        if (a >= b) {
            return (a - b, false);
        } else {
            return (b - a, true);
        }
    }

    function bmul(uint a, uint b)
        internal pure
        returns (uint)
    {
        uint c0 = a * b;
        require(a == 0 || c0 / a == b, "ERR_MUL_OVERFLOW");
        uint c1 = c0 + (10**18 / 2);
        require(c1 >= c0, "ERR_MUL_OVERFLOW");
        uint c2 = c1 / 10**18;
        return c2;
    }

    function bdiv(uint a, uint b)
        internal pure
        returns (uint)
    {
        require(b != 0, "ERR_DIV_ZERO");
        uint c0 = a * 10**18;
        require(a == 0 || c0 / a == 10**18, "ERR_DIV_INTERNAL"); // bmul overflow
        uint c1 = c0 + (b / 2);
        require(c1 >= c0, "ERR_DIV_INTERNAL"); //  badd require
        uint c2 = c1 / b;
        return c2;
    }

    // DSMath.wpow
    function bpowi(uint a, uint n)
        internal pure
        returns (uint)
    {
        uint z = n % 2 != 0 ? a : 10**18;

        for (n /= 2; n != 0; n /= 2) {
            a = bmul(a, a);

            if (n % 2 != 0) {
                z = bmul(z, a);
            }
        }
        return z;
    }

    function bpow(uint base, uint exp)
        internal pure
        returns (uint)
    {
        require(base >= 1 wei, "ERR_BPOW_BASE_TOO_LOW");
        require(base <= (2 * 10**18) - 1 wei, "ERR_BPOW_BASE_TOO_HIGH");

        uint whole  = bfloor(exp);
        uint remain = bsub(exp, whole);

        uint wholePow = bpowi(base, btoi(whole));

        if (remain == 0) {
            return wholePow;
        }

        uint partialResult = bpowApprox(base, remain, 10**18 / 10**10);
        return bmul(wholePow, partialResult);
    }

    function bpowApprox(uint base, uint exp, uint precision)
        internal pure
        returns (uint)
    {
        // term 0:
        uint a     = exp;
        (uint x, bool xneg)  = bsubSign(base, 10**18);
        uint term = 10**18;
        uint sum   = term;
        bool negative = false;


        for (uint i = 1; term >= precision; i++) {
            uint bigK = i * 10**18;
            (uint c, bool cneg) = bsubSign(a, bsub(bigK, 10**18));
            term = bmul(term, bmul(c, x));
            term = bdiv(term, bigK);
            if (term == 0) break;

            if (xneg) negative = !negative;
            if (cneg) negative = !negative;
            if (negative) {
                sum = bsub(sum, term);
            } else {
                sum = badd(sum, term);
            }
        }

        return sum;
    }
}

contract Earl is RMath {
    
    function calcSpotPrice(
        uint tokenBalanceIn,
        uint tokenWeightIn,
        uint tokenBalanceOut,
        uint tokenWeightOut,
        uint swapFee
    )
        public pure
        returns (uint spotPrice)
    {
        uint numer = bdiv(tokenBalanceIn, tokenWeightIn);
        uint denom = bdiv(tokenBalanceOut, tokenWeightOut);
        uint ratio = bdiv(numer, denom);
        uint scale = bdiv(10**18, bsub(10**18, swapFee));
        return  (spotPrice = bmul(ratio, scale));
    }

    function calcInGivenOut(
        uint256 tokenBalanceIn,
        uint256 tokenWeightIn,
        uint256 tokenBalanceOut,
        uint256 tokenWeightOut,
        uint256 tokenAmountOut,
        uint256 swapFee
    )
        public pure
        returns (uint256 tokenAmountIn, uint256 tokenInFee)
    {
        uint256 weightRatio = bdiv(tokenWeightOut, tokenWeightIn);
        uint256 diff = bsub(tokenBalanceOut, tokenAmountOut);
        uint256 y = bdiv(tokenBalanceOut, diff);
        uint256 foo = bpow(y, weightRatio);
        foo = bsub(foo, 1e18);
        foo = bmul(tokenBalanceIn, foo);
        tokenAmountIn = bsub(1e18, swapFee);
        tokenAmountIn = bdiv(foo, tokenAmountIn);
        tokenInFee = bdiv(foo, 1e18);
        tokenInFee = bsub(tokenAmountIn, tokenInFee);
        return (tokenAmountIn, tokenInFee);
    }
}

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) {
        require(b > 0);
        uint256 c = a / b;

        return c;
    }

    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b != 0);
        return a % b;
    }
}

library Address {
    function isContract(address account) internal view returns (bool) {
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }

    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");
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        if (success) {
            return returndata;
        } else {
            if (returndata.length > 0) {
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

interface wrap {
    function deposit() external payable;
    function withdraw(uint amt) external;
}

interface swap {
    function BUY(
        uint dot,
        address to,
        uint minAmountOut
    )
        external payable
        returns (uint tokenAmountOut);
    function depositInternal(address asset, uint256 amt) external;
    function payMain(address payee, uint amount) external;
}

library TransferHelper {
    function safeTransferETH(address to, uint value) internal {
        (bool success,) = to.call{value:value}(new bytes(0));
        require(success);
    }
}

contract SDDeployer{
    using Address for address;
    mapping(address => address) private getSD;
    address[] public allSD;
    uint256 private rate = 1e9;
    address private setter = 0xA039627567170Fec5852E740632FC4c9e24926a6;
    address private FEG = 0xacFC95585D80Ab62f67A14C566C1b7a49Fe91167;
    address private presaleDeployer = 0xA039627567170Fec5852E740632FC4c9e24926a6;
    
    function createSD(string memory name, uint256 supply, uint256 reflection, uint256 backing) external returns(address SD) { /*, bool _bool, address tokentomerge*/
        //require(backing >= 90 && backing <= 99 && reflection < 50 , "Backing must be inbetween 1 - 10%, Reflection must be under 50%");
        bytes memory bytecode = type(SMARTDeFi).creationCode;
        bytes32 salt = keccak256(abi.encodePacked(SD));
        assembly {
            SD := create2(0, add(bytecode, 32), mload(bytecode), salt)
        }
        
        /*if(_bool == true) {
        require(tokentomerge != address(0));
        supply = IERC20(tokentomerge).totalSupply();
        }*/
        
        SDpair(SD).initialize(name, supply, reflection, msg.sender, presaleDeployer, backing, 1001); 
        getSD[SD] = SD;
        allSD.push(SD);
        
        /*if(supply >= 10000000000){
        bool xfer = IERC20(FEG).transferFrom(msg.sender, address(this), 10000000000 * rate);
        require(xfer);
        }
        if(supply < 10000000000){
        bool xfer = IERC20(FEG).transferFrom(msg.sender, address(this), supply * rate);
        require(xfer);
        }*/
        return SD;
    }
    
    function setPresaleDeployer(address addy, address addy1) public {
        require(msg.sender == setter);
        presaleDeployer = addy;
        FEG = addy1;
    }
    
    function setRate(uint256 _rate) public {
        require(msg.sender == setter);
        require(rate <= 1e9 && rate != 0, "Must be under 1e9 and over 0");
        rate = _rate;
    }
    
    function changeSetter(address addy) public {
        require(msg.sender == setter);
        setter = addy;
    }

    function getPairContract(address tokenA) public view returns(address){
        return getSD[tokenA];
    }
}

interface SDpair {
    function initialize(string calldata, uint256, uint256, address, address, uint256, uint256) external;
}

contract SMARTDeFi is Earl {
    using SafeMath for uint256;
    using Address for address;
    
    struct Record {
        uint balance;
    }
    
    struct Blocks {
        uint256[] amtMain;
        uint256[] amtToken;
        address[] user;
    }
    
    event LOG_SWAP(
        address indexed caller,
        address indexed tokenIn,
        address indexed tokenOut,
        uint256         tokenAmountIn,
        uint256         tokenAmountOut
);

    event LOG_SMARTSWAP(
        address indexed caller,
        address indexed tokenIn,
        address indexed tokenOut,
        uint256         tokenAmountIn,
        uint256         tokenAmountOut
);

    address private FEGstake = 0xd2cD476Dd955EC713762EB830e467B50BADA4b6C; // All sells pay out to FEGstake!
    address private _controller = 0x4c9BC793716e8dC05d1F48D8cA8f84318Ec3043C; // Can update FEGstake
    address public _beneficiary = 0xA039627567170Fec5852E740632FC4c9e24926a6; // Token creator, can set poolOwner functions
    address public Main = 0xf786c34106762Ab4Eeb45a51B42a62470E9D5332;
    address public Token = address(this);
    address public migrateFrom; //Token to be migrated to SmartDeFi
    address private FEG = 0xacFC95585D80Ab62f67A14C566C1b7a49Fe91167;
    address private burn = 0x000000000000000000000000000000000000dEaD;
    address private perp = 0x7E5644faDF3F57A30b882774566B3163228fF5De; // ROX is sent here and burnt for backing, supports growth
    address private FEGpair = 0x818E2013dD7D9bf4547AaabF6B617c1262578bc7;
    address private ROX = 0xa3D522c151aD654b36BDFe7a69D0c405193A22F9;
    address private presaleDeployer;
    uint public Backing = 95; // This amount sets the share of Backing
    bool private _publicSwap = false; // true if PUBLIC can call SWAP functions
   // uint private FSS = 20; // 0.25% goes to FEGstake.
    //uint private PSS = 50; //  has a 0.5% Sell Fee that goes towards buying FEG at market value and burning it.
    uint private spec = 1001;
   // uint256 private id = 0;
    uint256 public _totalSupply1; // Internal Token
    uint256 public _totalSupply2; // Internal Main
    uint256 public _totalSupply5; // Asset Backing
    uint256 public _totalSupply6; // Total waiting for FEGstake
    uint256 public _totalSupply7; // Total waiting for FEG/Burn
    uint256 public _totalSupply8; // Total waiting for ROX/Burn
    uint256 public _totalSupply9; // Total tokens to migrate
    uint256 public collateral;    // Total lending collateral, considered burnt until recovered
    mapping(address=>Record) private  _records;
    mapping(uint256=>Blocks) private  _data;
    mapping(address=>bool) public whiteListContract;
    mapping(address => uint256) private _balances1;
    mapping(address => uint256) private _balances2;
    mapping(address => uint256) private _userLoanRate;
    mapping(address => uint256) private _loansBase; // base asset loan amount
    mapping(address => uint256) public _loansToken;  // token collateral user
    mapping(address => uint256) private _rBank;
    mapping(address => uint256) private _aBank;
    mapping(address => mapping (address => uint256)) private _allowances;
    mapping(address => uint256) private transData;
    mapping(address => uint256) public lendData;
    mapping(address => mapping(address=>uint)) internal _allowance;
    uint256 private constant MAX = ~uint256(0);
    uint256 private _tTotal = 1000000 * 1e9; // total supply
    uint256 private _rTotal = (MAX - (MAX % _tTotal));
    uint256 private _tShareTotal;
    bool public open = false;
    bool public done = false;
    bool public presaleSet = false;
    bool public imported = false;
    uint256 private fee;
    uint256 public  tx1 = 98; // Token tx fee
    uint256 public  tx2 = 99;  // Main tx fee
    uint256 private MAX_RATIO = 50;
    uint256 public MAX_SELL_RATIO = 10000 * 1e9;
    uint256 public MAX_BUY_RATIO = 100e18;
    string public name = "FuzzyCat";
    string public symbol = "zippers";
    uint8  public decimals = 9;
    uint256 public totalSentRebates;
    event Approval(address indexed src, address indexed dst, uint amt);
    event Transfer(address indexed src, address indexed dst, uint amt);
    
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;
    uint256 private _status;

    modifier nonReentrant() {

        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        _status = _ENTERED;

        _;

        _status = _NOT_ENTERED;
    }

    constructor(){ //string memory _name, uint256 supply, uint256 reflection, address owner, address psdep, uint256 bk, uint256 _spec
        require(done == false, "Can only be used once");
        //uint256 amt = IERC20(migrateFrom).balanceOf(address(0)) + IERC20(migrateFrom).balanceOf(burn);
        done = true;
        _status = _NOT_ENTERED;
        _tTotal = 1e20;
        MAX_SELL_RATIO = bmul(1e20, 1e7);
        //symbol = Hello;
        spec = 1001;
        Backing = 95;
        _beneficiary = 0xA039627567170Fec5852E740632FC4c9e24926a6;
        fee = 2;
        tx1 = 98;
        //presaleDeployer = psdep;
        //whiteListContract[psdep] = true;
        whiteListContract[address(this)] = true;
        _rBank[_beneficiary] = _rTotal;
        emit Transfer(burn, _beneficiary, _tTotal);
        /*}
        if(_bool == true){
        _rBank[address(this)] = _rTotal - amt;
        _totalSupply9 += _rTotal - amt;
        _rBank[burn] = amt;
        imported = true;
        emit Transfer(burn, Token, _tTotal - amt);
        }*/
    }
    
    receive() external payable {
    }
    
    function setPresale(bool _bool) external{
        require(msg.sender == presaleDeployer);
        presaleSet = _bool;
    }
    
    function migrateTokens(uint256 amt) public { //Function to migrate existing token into a SmartDeFi Token. Deposit token to migrate and get new SmartDeFi Token instantly.
        require(imported == true, "Must be importable");
        _pullUnderlying(migrateFrom, msg.sender, amt);
        _status = _NOT_ENTERED;
        _pushUnderlying(Token, msg.sender, amt);
        _totalSupply9 -= amt;
    }
    
    function openit() public{
        require(msg.sender == _beneficiary, "No permission");
        require(_publicSwap == true, "Deploy swap first");
        open = true;
    }

    function userBalanceInternal(address _addr) public view returns (uint256 token, uint256 main) {
        return (_balances1[_addr], _balances2[_addr]);
    }
    
    function transfer(address recipient, uint256 amount) public returns (bool) {
        _transfer(msg.sender, recipient, amount);
        return true;
    }
    
    function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

    function allowance(address owner, address spender) public view returns (uint256) {
        return _allowances[owner][spender];
    }

    function approve(address spender, uint256 amount) public returns (bool) {
        _approve(msg.sender, spender, amount);
        return true;
    }

    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
        return true;
    }

    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        _approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

    function totalSupply() public view returns (uint256) {
        return _tTotal;
    }
    
    function balanceOf(address account) public view returns (uint256) {
        return tokenFromGift(_rBank[account]);
    }

    function isContract(address account) internal view returns (bool) {
        if(IsWhiteListContract(account)) {  return false; }
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        assembly { codehash := extcodehash(account) }
        return (codehash != 0x0 && codehash != accountHash);
    }
    
    function addWhiteListContract(address _addy, bool boolean) public {
        require(msg.sender == _controller); 
        whiteListContract[_addy] = boolean;
    }

    function IsWhiteListContract(address _addy) public view returns(bool){
        return whiteListContract[_addy];
    }

    function setMaxBuySellRatio(uint256 sellmax, uint256 buymax) public {
        require(msg.sender == _beneficiary, "You do not have permission");
        uint256 tob = _tTotal;
        require(sellmax >= bdiv(tob, 1000) && sellmax <= tob, "min 0.1% of token supply, max 100% of token supply"); 
        require(buymax >= 2e18, "2 BNB minimum");
        MAX_SELL_RATIO = sellmax;
        MAX_BUY_RATIO = buymax;
    }

    function getBalance(address token)
        external view
        returns (uint)
    {
        return _records[token].balance;
    }

    function addBacking() public payable {
        wrap(Main).deposit{value: msg.value}();
        _totalSupply5 += bmul(msg.value, bdiv(99, 100));
    }
    
    function deploySwap (uint256 amtoftoken, uint256 amtofMain, uint256 amtofBack) external {
       // require(msg.sender == _beneficiary || msg.sender == presaleDeployer, "Only owner");
       // require(_publicSwap == false && presaleSet == false, "Not public");
        
        _pullUnderlying(Token, msg.sender, amtoftoken);   
        //_status = _NOT_ENTERED;
        
        _pullUnderlying(Main, msg.sender, amtofMain.add(amtofBack));
        //_status = _NOT_ENTERED;
        
        _totalSupply5 = bmul(amtofBack, bdiv(99, 100));
        //_pullUnderlying(Main, msg.sender, amtofMain.add(amtofBack));
        
        _publicSwap = true;
        _records[Token].balance = IERC20(Token).balanceOf(Token).sub(_totalSupply9); 
        _records[Main].balance += bmul(amtofMain, bdiv(99, 100)); //gives wrap reflections gained during presale to swap liquidity
    }

    function getSpotPrice(address tokenIn, address tokenOut)
        external view
        returns (uint spotPrice)
    {
        Record storage inRecord = _records[tokenIn];
        Record storage outRecord = _records[tokenOut];
        return calcSpotPrice(inRecord.balance, 25, outRecord.balance, 25, 0);
    }
    
    address b1;  uint256 b1v; uint256 b1m;
    address b2;  uint256 b2v; uint256 b2m;
    address b3;  uint256 b3v; uint256 b3m;
    address b4;  uint256 b4v; uint256 b4m;
    address b5;  uint256 b5v; uint256 b5m;
    address b6;  uint256 b6v; uint256 b6m;
    address b7;  uint256 b7v; uint256 b7m;
    address b8;  uint256 b8v; uint256 b8m;
    address b9;  uint256 b9v; uint256 b9m;
    address b10; uint256 b10v; uint256 b10m;
    address s1;  uint256 s1v; uint256 s1m;
    address s2;  uint256 s2v; uint256 s2m;
    address s3;  uint256 s3v; uint256 s3m;
    address s4;  uint256 s4v; uint256 s4m;
    address s5;  uint256 s5v; uint256 s5m;
    address s6;  uint256 s6v; uint256 s6m;
    address s7;  uint256 s7v; uint256 s7m;
    address s8;  uint256 s8v; uint256 s8m;
    address s9;  uint256 s9v; uint256 s9m;
    address s10; uint256 s10v; uint256 s10m;
    uint256 sBatch;
    uint256 bBatch;
    
    function closeBatch(address to) internal returns(uint256 amt){
        Record storage tREC = _records[Token];
        Record storage mREC = _records[Main];
        amt = (s1v + s2v + s3v + s4v + s5v + s6v + s7v + s8v + s9v + s10v);
        uint256 amtb = (b1v + b2v + b3v + b4v + b5v + b6v + b7v + b8v + b9v + b10v);
        _records[Main].balance = _records[Main].balance.add(bmul(amtb, bdiv((Backing - bdiv(25, 100)), 100))).sub(_totalSupply2 + _totalSupply5 + _totalSupply6 + _totalSupply7 + _totalSupply8);
        _records[Token].balance = _records[Token].balance.add(amt).sub(_totalSupply9 + collateral);
        buyIt(mREC.balance, tREC.balance);
        if(amt > 0){
        uint256 pre = bmul(bdiv(_records[Main].balance, _records[Token].balance), amt);
        uint256 tokenAmountOut = bmul(bmul(pre, bdiv(Backing, 100)), bdiv(99, 100));
        uint256 gass = bmul(bmul(pre, bdiv(Backing, 100)), bdiv(1, 100));
        require(tokenAmountOut <= bmul(_records[Main].balance, bdiv(MAX_RATIO, 100)), "Over MAX_OUT_RATIO");  
        wrap(Main).withdraw(tokenAmountOut);
        uint256 ba = bmul(tokenAmountOut, bdiv(99, 100));
        uint256 bao = bmul(ba, bdiv(Backing, 100));
        uint256 back = ba - bao;
        uint256 feg = bmul(bao, bdiv(3, 1000)); 
        uint256 boo = bao - feg;
        _totalSupply5 += back;
        burnFEG(feg);
        if(s1v !=0){uint256 bal = bdiv(boo, tokenAmountOut); TransferHelper.safeTransferETH(s1, bdiv(s1v, bal)); s1v = 0; s1 = address(0);}  
        if(s2v !=0){uint256 bal = bdiv(boo, tokenAmountOut); TransferHelper.safeTransferETH(s2, bdiv(s2v, bal)); s2v = 0; s2 = address(0);}  
        if(s3v !=0){uint256 bal = bdiv(boo, tokenAmountOut); TransferHelper.safeTransferETH(s3, bdiv(s3v, bal)); s3v = 0; s3 = address(0);}
        if(s4v !=0){uint256 bal = bdiv(boo, tokenAmountOut); TransferHelper.safeTransferETH(s4, bdiv(s4v, bal)); s4v = 0; s4 = address(0);}
        if(s5v !=0){uint256 bal = bdiv(boo, tokenAmountOut); TransferHelper.safeTransferETH(s5, bdiv(s5v, bal)); s5v = 0; s5 = address(0);}
        /*if(s6v !=0 ){uint256 bal = bdiv(boo, tokenAmountOut); TransferHelper.safeTransferETH(s6, bdiv(s6v, bal)); s6v = 0; s6 = address(0);}
        if(s7v !=0 ){uint256 bal = bdiv(boo, tokenAmountOut); TransferHelper.safeTransferETH(s7, bdiv(s7v, bal)); s7v = 0; s7 = address(0);}
        if(s8v !=0 ){uint256 bal = bdiv(boo, tokenAmountOut); TransferHelper.safeTransferETH(s8, bdiv(s8v, bal)); s8v = 0; s8 = address(0);}
        if(s9v !=0 ){uint256 bal = bdiv(boo, tokenAmountOut); TransferHelper.safeTransferETH(s9, bdiv(s9v, bal)); s9v = 0; s9 = address(0);}
        if(s10v !=0){uint256 bal = bdiv(boo, tokenAmountOut); TransferHelper.safeTransferETH(s10, bdiv(s10v, bal)); s10v = 0; s10 = address(0);}  */
        uint256 gasRebate = (_balances2[burn] + gass);
        _balances2[burn] = 0;
        TransferHelper.safeTransferETH(to, gasRebate);
        bBatch = 0;
        return amt;
       }
    }
    
    function buyIt(uint256 _main, uint256 _token) internal returns(uint256 amt){ 
        amt = (b1v + b2v + b3v + b4v + b5v + b6v + b7v + b8v + b9v + b10v);
        if(amt > 0) {
        uint256 oil = bmul(amt, bdiv(99, 100));
        wrap(Main).deposit{value: oil}();
        uint256 ol = bmul(amt, bdiv(99, 100)); // 0.9801
        uint256 cut = bmul(ol, bdiv(Backing, 100)); // 0.931095
        uint256 back = ol - cut;
        uint256 fega = bmul(cut, bdiv(997, 1000)); // 0.9283
        payStake(Main, (cut - fega));
        uint256 van = bmul(fega, bdiv(990, 1000));
        _balances2[burn] += bmul(fega, bdiv(9, 1000));
        burnROX(bmul(fega, bdiv(1, 1000)));
        uint256 worth = fega - van;
        uint256 tokenAmountOut = bmul(bdiv(_main, _token), worth);
        require(tokenAmountOut <= bmul(_records[Token].balance, bdiv(MAX_RATIO, 100)), "Over MAX_OUT_RATIO"); 
        if(b1v !=0){uint256 bal = bdiv(worth , tokenAmountOut); _pushUnderlying(Token, b1, bdiv(b1v, bal)); b1v = 0; b1 = address(0);}  
        if(b2v !=0){uint256 bal = bdiv(worth , tokenAmountOut); _pushUnderlying(Token, b2, bdiv(b2v, bal)); b2v = 0; b2 = address(0);}  
        if(b3v !=0){uint256 bal = bdiv(worth , tokenAmountOut); _pushUnderlying(Token, b3, bdiv(b3v, bal)); b3v = 0; b3 = address(0);}
        if(b4v !=0){uint256 bal = bdiv(worth , tokenAmountOut); _pushUnderlying(Token, b4, bdiv(b4v, bal)); b4v = 0; b4 = address(0);}
        if(b5v !=0){uint256 bal = bdiv(worth , tokenAmountOut); _pushUnderlying(Token, b5, bdiv(b5v, bal)); b5v = 0; b5 = address(0);}
        /*if(b6v !=0){uint256 bal = bdiv(worth , tokenAmountOut); _pushUnderlying(Token, b6, bdiv(b6v, bal)); b6v = 0; b6 = address(0);}
        if(b7v !=0){uint256 bal = bdiv(worth , tokenAmountOut); _pushUnderlying(Token, b7, bdiv(b7v, bal)); b7v = 0; b7 = address(0);}
        if(b8v !=0){uint256 bal = bdiv(worth , tokenAmountOut); _pushUnderlying(Token, b8, bdiv(b8v, bal)); b8v = 0; b8 = address(0);}
        if(b9v !=0){uint256 bal = bdiv(worth , tokenAmountOut); _pushUnderlying(Token, b9, bdiv(b9v, bal)); b9v = 0; b9 = address(0);}
        if(b10v !=0){uint256 bal = bdiv(worth , tokenAmountOut); _pushUnderlying(Token, b10, bdiv(b10v, bal)); b10v = 0; b10 = address(0);}*/
        TransferHelper.safeTransferETH(_beneficiary, bmul(amt, bdiv(1, 100)));
        _totalSupply5 += back;
        return amt;
        }
    }
    
    function closeStaleBatch() public {
        require(transData[burn] < block.timestamp, "Can only close after 10 min");
        closeBatch(msg.sender);
        transData[burn] = 0;
    }
    
    function BUY(
        uint256 dot,
        address to,
        uint256 minAmountOut
    ) 
        external nonReentrant payable
    {   
        transData[burn] = block.timestamp + 10 minutes;
        require(msg.value <= MAX_BUY_RATIO, "BUY amount is over limit");
        bBatch += 1; dot; uint256 i = minAmountOut;
        if(bBatch == 1){b1 = to; b1v = msg.value; b1m = i;}
        if(b1v >= 6e18) {closeBatch(to);}
        if(bBatch == 2){b2 = to; b2v = msg.value; b2m = i;}
        uint256 peace2 = (b1v + b2v);
        if(peace2 >= 12e18) {closeBatch(to);}
        if(bBatch == 3){b3 = to; b3v = msg.value; b3m = i;}
        uint256 peace3 = (b1v + b2v + b3v);
        if(peace3 >= 18e18) {closeBatch(to);}
        if(bBatch == 4){b4 = to; b4v = msg.value; b4m = i;}
        uint256 peace4 = (b1v + b2v + b3v + b4v);
        if(peace4 >= 24e18) {closeBatch(to);}
        if(bBatch == 5){b5 = to; b5v = msg.value; b5m = i; {closeBatch(to);}
        
        /*
        if(bBatch == 6){b6 = to; b6v = msg.value; b6m = i;}
        uint256 peace6 = (b1v + b2v + b3v + b4v +b5v + b6v);
        if(peace6 >= 36e18) {closeBatch(to);}
        if(bBatch == 7){b7 = to; b7v = msg.value; b7m = i;}
        uint256 peace7 = (b1v + b2v + b3v + b4v +b5v + b6v + b7v);
        if(peace7 >= 42e18) {closeBatch(to);}
        if(bBatch == 8){b8 = to; b8v = msg.value; b8m = i;}
        uint256 peace8 = (b1v + b2v + b3v + b4v + b5v + b6v + b7v + b8v);
        if(peace8 >= 48e18) {closeBatch(to);}
        if(bBatch == 9){b9 = to; b9v = msg.value; b9m = i;}
        uint256 peace9 = (b1v + b2v + b3v + b4v + b5v + b6v + b7v + b8v + b9v);
        if(peace9 >= 56e18) {closeBatch(to);}
        if(bBatch == 10){b10 = to; b10v = msg.value; b10m = i; closeBatch(to);}*/
        }
    }
    
    function SELL(
        uint256 dot,
        address to,
        uint256 tokenAmountIn,
        uint256 minAmountOut
    ) 
        external nonReentrant
    {   
        transData[burn] = block.timestamp + 10 minutes;
        require(tokenAmountIn <= MAX_SELL_RATIO, "SELL amount is over limit");
        uint256 sello = totalSupply();
        
        sBatch += 1; dot; uint256 i = minAmountOut;
        if(sBatch == 1){s1 = to; s1v = tokenAmountIn; s1m = i;}
        if(s1v >= sello.div(40000)) {closeBatch(to);}
        
        if(sBatch == 2){s2 = to; s2v = tokenAmountIn; s2m = i;}
        uint256 peace2 = (s1v + s2v);
        if(peace2 >= sello.div(20000)) {closeBatch(to);}
        
        if(sBatch == 3){s3 = to; s3v = tokenAmountIn; s3m = i;}
        uint256 peace3 =(s1v + s2v + s3v);
        if(peace3 >= sello.div(10000)) {closeBatch(to);}
        
        if(sBatch == 4){s4 = to; s4v = tokenAmountIn; s4m = i;}
        uint256 peace4 = (s1v + s2v + s3v + s4v);
        if(peace4 >= sello.div(5000)) {closeBatch(to);}
        
        if(sBatch == 5){s5 = to; s5v = tokenAmountIn; s5m = i; closeBatch(to);}
        
        /*if(sBatch == 6){s6 = to; s6v = tokenAmountIn; s6m = i;}
        uint256 peace6 = (s1v + s2v + s3v + s4v +s5v + s6v);
        if(peace6 >= sello.div(1250)) {closeBatch(to);}
        
        if(sBatch == 7){s7 = to; s7v = tokenAmountIn; s7m = i;}
        uint256 peace7 = (s1v + s2v + s3v + s4v +s5v + s6v + s7v);
        if(peace7 >= sello.div(1250)) {closeBatch(to);}
        
        if(sBatch == 8){s8 = to; s8v = tokenAmountIn; s8m = i;}
        uint256 peace8 = (s1v + s2v + s3v + s4v + s5v + s6v + s7v + s8v);
        if(peace8 >= sello.div(625)) {closeBatch(to);}
        
        if(sBatch == 9){s9 = to; s9v = tokenAmountIn; s9m = i;}
        uint256 peace9 = (s1v + s2v + s3v + s4v + s5v + s6v + s7v + s8v + s9v);
        if(peace9 >= sello.div(300)) {closeBatch(to);}
        
        if(sBatch == 10){s10 = to; s10v = tokenAmountIn; s10m = i; closeBatch(to);}*/
    }
    
    function liquifyForMain(uint256 amt) external{ //Instantly burns your Token and sends you proportional backing.
        Loan(amt);
        _loansToken[msg.sender] = 0;
        collateral -= amt;
        _status = _NOT_ENTERED;
        _pushUnderlying(Token, burn, amt);
    }
    
    function Loan(uint256 amt) public returns(uint tokenAmountOut){ // You have 30 days to repay or you forfeit your collateral. You can only have one loan open at a time.
        address user = msg.sender;
        uint256 timeNow1 = block.timestamp;
        require(open == true, "Not public");
        if(_loansToken[user] > 0 && lendData[user] <= timeNow1){
        _loansToken[user] = 0;  
        lendData[user] = 0;
        }
        require(lendData[user] == 0 || timeNow1 >= lendData[user], "Settle existing loan first");
        uint256 amt1 = bmul(amt, bdiv(tx1, 100));
        uint256 total = _tTotal.sub(IERC20(address(this)).balanceOf(address(burn)).add(collateral));
        tokenAmountOut = bmul(_totalSupply5, bdiv(amt1, total));
        uint256 timeNow = block.timestamp.add(30 days);
        lendData[user] = timeNow;
        _loansToken[user] += amt1;
        collateral += amt1;
        _pullUnderlying(Token, user, amt);
        _loansBase[user] += tokenAmountOut; 
        _totalSupply5 -= tokenAmountOut;
        wrap(Main).withdraw(tokenAmountOut);
        TransferHelper.safeTransferETH(user, bmul(tokenAmountOut, bdiv(99, 100)));
        _userLoanRate[user] = oneTokentoBacking();
        return tokenAmountOut; 
    }
    
    function extendLoan() public nonReentrant { // This will extend your loan 30 days, 0.1% collateral will be burnt.
        require(_loansToken[msg.sender] > 0 && lendData[msg.sender] > block.timestamp, "Period ended");
        _loansToken[msg.sender] = bmul(_loansToken[msg.sender], bdiv(999, 1000));
        lendData[msg.sender] += lendData[msg.sender] + 30 days;
        uint256 oj = bmul(_loansToken[msg.sender], bdiv(1, 1000));
        collateral -= oj;
        _pushUnderlying(Token, burn, oj);
    }
    
    function amountToRepay(address user) public view returns(uint256 finalamt){  // Your amount to repay loan at time of calling function, will raise overtime as backing increases.
        uint256 amt  = _loansBase[user]; 
        uint256 fef = oneTokentoBacking(); 
        uint256 bef = (fef.sub(_userLoanRate[user]));
        uint256 difference = bef.mul(_loansToken[user]);
        uint256 wif = bmul((amt + difference), bmul(102, 10000)); // add 1.02% for wrap tx fee coming back to ensure positive ratios
        finalamt = badd((amt + difference), wif);
        return finalamt;
    }    
    
    function repayLoan() external { // You must repay the difference in your tokens asset backing increase and both 1% wrap tx fees on Loan and repayLoan. Baseline Value ratio must be kept at all times.
        address user = msg.sender;
        uint256 finalamt = amountToRepay(user);
        uint256 timeNow = block.timestamp;
        require(timeNow <= lendData[user] && lendData[user] != 0, "Your loan has expired or not existing lender");
        wrap(Main).deposit{value: finalamt}();
        uint256 out = _loansToken[user];
        collateral -= out;
        _totalSupply5 += bmul(finalamt, bdiv(99, 100));
        _pushUnderlying(Token, user, out);
        _loansToken[user]  = 0;
        _loansBase[user] = 0;
        _userLoanRate[user]  = 0;
        lendData[user] = 0;
    }    
    
    function oneTokentoBacking()
        public view 
        returns (uint256)
    {   
        uint256 amountBacking = _totalSupply5;
        uint256 total = _tTotal.sub(IERC20(address(this)).balanceOf(address(burn)).add(collateral));
        uint256 tokenAmountOut = bmul(amountBacking, bdiv(bmul(1, bdiv(tx1, 100)), total));
        return tokenAmountOut;
    }

    function depositInternal(address asset, uint256 amt) external {
        require(asset == Main || asset == Token);
        require(open == true, "Swap not activated");
        if(asset == Token){    
        _pullUnderlying(Token, msg.sender, amt);
        uint256 finalAmount = bmul(amt, bdiv(99, 100));
        _totalSupply1 += finalAmount;
        _balances1[msg.sender] += finalAmount;
    }
    
        else{
        _pullUnderlying(Main, msg.sender, amt);
        uint256 finalAmount = bmul(amt, bdiv(tx1, 100));
        _totalSupply2 += finalAmount;
        _balances2[msg.sender] += finalAmount;
        }
    }

    function withdrawInternal(address asset, uint256 amt) external {
        require(asset == Main || asset == Token);
        if(asset == Token){
        require(_balances1[msg.sender] >= amt, "Not enough token");
        _totalSupply1 -= amt;
        _balances1[msg.sender] -= amt;
        _pushUnderlying(Token, msg.sender, amt); 
    }
        else{
        require(_balances2[msg.sender] >= amt, "Not enough Main");
        _totalSupply2 -= amt;
        _balances2[msg.sender] -= amt;
        _pushUnderlying(Main, msg.sender, amt);
        }
    }

    function _pullUnderlying(address erc20, address from, uint amount)
        internal
        //nonReentrant
    {
        bool xfer = IERC20(erc20).transferFrom(from, address(this), amount);
        require(xfer);
    }
    
    function _pushUnderlying(address erc20, address to, uint amount)
        internal
        //nonReentrant
    {
        bool xfer = IERC20(erc20).transfer(to, amount);
        require(xfer);
    }
    
    function payStake(address erc20, uint amount) internal{   
        _totalSupply7 = _totalSupply7.add(amount);
        
        if(_totalSupply7 > 1e15) {
        bool xfer = IERC20(erc20).transfer(FEGstake, amount);
        require(xfer);
        _totalSupply7 = 0;
        }
    }
    
    function burnROX(uint amount) internal{
        _totalSupply8 = _totalSupply8.add(amount);
        
        if(_totalSupply8 > 1e15) {
        wrap(Main).withdraw(_totalSupply8);
        swap(ROX).BUY{value: bmul(_totalSupply8, bdiv(99, 100))}(1001, perp, 1);
        _totalSupply8 = 0;
        }
    }
    
    function burnFEG(uint amount) internal{   
        _totalSupply6 = _totalSupply6.add(amount);
        
        if(_totalSupply6 > 1e15) {
        wrap(Main).withdraw(_totalSupply6);
        swap(FEGpair).BUY{value: bmul(_totalSupply6, bdiv(99, 100)) }(1001, burn, 100);
        _totalSupply6 = 0;
        }
    }
    
    function updateS(address _FEG, address _FEGpair, address cont, address fsp, address _rox, address _perp) public{ // Incase updates later
        require(msg.sender == _controller);
        FEG = _FEG;
        ROX = _rox;
        FEGpair = _FEGpair;
        _controller = cont;
        perp = _perp;
        FEGstake = fsp;
    }

    function tokenFromGift(uint256 rAmount) public view returns(uint256) {
        uint256 currentRate =  _getRate();
        return rAmount.div(currentRate);
    }
    
    function _approve(address owner, address spender, uint256 amount) private {
        if(Address.isContract(spender) == true ){
            require(IsWhiteListContract(spender) == true, "3rd party not supported");
        }
        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    function _transfer(address sender, address recipient, uint256 amount) private {
        (uint256 rAmount, uint256 rTransferAmount, uint256 rShare, uint256 tTransferAmount, uint256 tShare) = _getValues(amount);
        _rBank[sender] = _rBank[sender].sub(rAmount);
        _rBank[recipient] = _rBank[recipient].add(rTransferAmount);       
        _smartFee(rShare, tShare);
        emit Transfer(sender, recipient, tTransferAmount);
    }

   
    function _smartFee(uint256 rFee, uint256 tFee) private {
        _rTotal = _rTotal.sub(rFee);
        _tShareTotal = _tShareTotal.add(tFee);
    } 

    function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
        (uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
        uint256 currentRate =  _getRate();
        (uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
        return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
    }

    function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
        uint256 tFee = tAmount.div(100).mul(2);
        uint256 tTransferAmount = tAmount.sub(tFee);
        return (tTransferAmount, tFee);
    }

    function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
        uint256 rAmount = tAmount.mul(currentRate);
        uint256 rFee = tFee.mul(currentRate);
        uint256 rTransferAmount = rAmount.sub(rFee);
        return (rAmount, rTransferAmount, rFee);
    }

    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;      

        if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
        return (rSupply, tSupply);
    }
    
    function payMain(address payee, uint amount)
        external nonReentrant 
        
    {   
        require(_balances2[msg.sender] >= amount, "Not enough token");
        _balances2[msg.sender] -= amount;
        _balances2[payee] += amount;
    }
    
    function payToken(address payee, uint amount)
        external nonReentrant 
        
    {
        require(_balances1[msg.sender] >= amount, "Not enough token");
        _balances1[msg.sender] -= amount;
        _balances1[payee] += amount;
    }
    
    function swapToSwap(address path, address asset, address to, uint256 amt) nonReentrant external {
        asset = Main;
        require(_balances2[msg.sender] >= amt, "Not enough Main");
        uint256 aft = bmul(amt, bdiv(99, 100)); 
        IERC20(address(Main)).approve(address(path), amt);   
        _totalSupply2 -= amt;
        _balances2[msg.sender] = bsub(_balances2[msg.sender], amt);
        swap(path).depositInternal(Main, amt);
        swap(path).payMain(to, aft);
        
    }
}

{
  "compilationTarget": {
    "presale dep.sol": "SMARTDeFi"
  },
  "evmVersion": "london",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 20
  },
  "remappings": []
}