contract Caerus is ERC20Detailed, Ownable {
    using SafeMath for uint256;

    address public lastBuyer;                       //The last address to purchase Caerus.

    string constant tokenName = "Caerus";
    string constant tokenSymbol = "CRS";
    uint8 constant tokenDecimals = 18;
    uint8 public titheRate;                         // The fee % taken on transfers, distributed to LastBuyer.
    uint256 public maxbuyorder;
    uint256 public _totalSupply;                    // 5,500,000 CRS
    uint256 public deploymentTime;

    mapping (address => uint256) private _balances;
    mapping (address => mapping (address => uint256)) private _allowances;
    mapping (address => bool) public whitelistedAddress;        // Immune to Tithe on transfers
    mapping (address => bool) public blacklistedAddress;        // Cannot purchase CRS

    modifier isNotBlacklisted(address recipient) {
        require(!blacklistedAddress[recipient]);
        _;
    }

    constructor() public payable ERC20Detailed(tokenName, tokenSymbol, tokenDecimals) {
        _mint(msg.sender, 5500000000000000000000000);
        _totalSupply = 5500000000000000000000000;
        lastBuyer = msg.sender;
        whitelistAdd(msg.sender);
        maxbuyorder = 45000000000000000000000;
        titheRate = 10;
        deploymentTime = now;
        }

    /**
     * @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`.
     *
     *
     * Function has been modified.
     *
     * A check is performed to determine if the transfer is for a buy or sell.
     * If Buying: Transfer and become the new lastBuyer.
     * If Selling: Transfer, pay 10% Fee (Tithe) to the current lastBuyer.
     *
     * Checks if the address calling the function is whitelisted. If it is, then the Tithe is 0 for the tx.
     * 
     */

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

        uint tokensbeforetransfer = _balances[tx.origin];
        uint Tithe = (amount / 100) * titheRate;

        if (isWhiteListed(msg.sender) == true || isWhiteListed(tx.origin) == true) {
            Tithe = 0;
        }
        
        if ((deploymentTime + 10 minutes) > now) {
            if (isWhiteListed(tx.origin) == false) {
                require(amount < maxbuyorder);}
            }

        uint tokenstotransfer = amount.sub(Tithe);

        _balances[sender] -= amount;
        _balances[recipient] += amount.sub(Tithe);
        _balances[lastBuyer] += Tithe;

        if (tokensbeforetransfer < _balances[tx.origin]) {
            lastBuyer = tx.origin;
            emit Transfer(sender, recipient, tokenstotransfer);
        } 
            else {
                emit Transfer(sender, recipient, tokenstotransfer);
                emit Transfer(sender, lastBuyer, Tithe);
            }
    }

    /**
     * @dev Checks if an address is whitelisted
     */
    function isWhiteListed(address _address) internal view returns(bool) {
        return whitelistedAddress[_address];
    }

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

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

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

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

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

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20};
     *
     * 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) public returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: 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 {IERC20-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 {IERC20-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, "ERC20: decreased allowance below zero"));
        return true;
    }


     /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal onlyOwner {
        require(account != address(0), "ERC20: mint to the zero address");

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, 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), "ERC20: burn from the zero address");

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

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

    /**
     * @dev Adds an address as whitelisted
     */
    function whitelistAdd(address _address) public onlyOwner {
        whitelistedAddress[_address] = true;
    }

    /**
     * @dev Removes an address as whitelisted
     */
    function whitelistRemove(address _address) public onlyOwner {
        whitelistedAddress[_address] = false;
    }

    /**
     * @dev Adds an address as whitelisted
     */
    function blacklistAdd(address _address) public onlyOwner {
        blacklistedAddress[_address] = true;
    }

    /**
     * @dev Removes an address as blacklisted
     */
    function blacklistRemove(address _address) public onlyOwner {
        blacklistedAddress[_address] = false;
    }

    /**
     * @dev Sets the Tithe rate
     */
    function setTithe(uint8 newtithe) public onlyOwner {
         titheRate = newtithe;
    }

}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
    _transfer(sender, recipient, amount);
    _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
    return true;
}

/**
 * @dev See {IERC20-transferFrom}.
 *
 * Emits an {Approval} event indicating the updated allowance. This is not
 * required by the EIP. See the note at the beginning of {ERC20};
 *
 * 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`.
 */