contract VNDTToken is Context, IERC20, Ownable {
    using SafeMath for uint256;
    using Address for address;

    string public symbol;
    string public  name;
    uint256 public constant decimals = 8;
    uint public _totalSupply;
    mapping(address => uint) balances;
    mapping(address => mapping(address => uint)) allowed;
    address public deadWallet = address(0x000000000000000000000000000000000000dEaD);
    mapping (address => bool) public isBlackListed;

    uint public constant supplyNumber = 1000000 * 10 ** 9;
    uint public constant powNumber = 10;
    uint public constant TOKEN_SUPPLY_TOTAL = supplyNumber * powNumber ** decimals;

    constructor() public {
        symbol = "VNDT";
        name = "VNDT";
        _totalSupply = TOKEN_SUPPLY_TOTAL;
        balances[msg.sender] = _totalSupply;
        emit Transfer(address(0), msg.sender, _totalSupply);
    }
    function totalSupply() public view override returns (uint) {
        return _totalSupply - balances[address(0)];
    }

    function balanceOf(address tokenOwner) public view override returns (uint balance) {
        return balances[tokenOwner];
    }

    function transfer(address to, uint tokens) public override returns (bool success) {
        require(!isBlackListed[msg.sender]);
        balances[msg.sender] = balances[msg.sender].sub(tokens);
        balances[to] = balances[to].add(tokens);
        emit Transfer(msg.sender, to, tokens);
        return true;
    }

    function batchTransfer(address[] memory _receivers, uint256[] memory _amounts) public returns (bool) {
        uint256 cnt = _receivers.length;
        require(cnt > 0 && cnt <= 100);
        require(cnt == _amounts.length);
        cnt = (uint8)(cnt);
        uint256 totalAmount = 0;
        for (uint8 i = 0; i < cnt; i++) {
            totalAmount = totalAmount.add(_amounts[i]);
        }
        require(totalAmount <= balances[msg.sender]);
        balances[msg.sender] = balances[msg.sender].sub(totalAmount);
        for (uint256 i = 0; i < cnt; i++) {
            balances[_receivers[i]] = balances[_receivers[i]].add(_amounts[i]);
            emit Transfer(msg.sender, _receivers[i], _amounts[i]);
        }
        return true;
    }

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

    function transferFrom(address from, address to, uint tokens) public override returns (bool success) {
        require(!isBlackListed[from]);
        balances[from] = balances[from].sub(tokens);
        allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
        balances[to] = balances[to].add(tokens);
        emit Transfer(from, to, tokens);
        return true;
    }

    function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
        return allowed[tokenOwner][spender];
    }

    function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
        return IERC20(tokenAddress).transfer(owner(), tokens);
    }

    function burnDead(uint256 _value) public {
        require(balances[msg.sender] >= _value);
        balances[msg.sender] = balances[msg.sender].sub(_value);
        balances[deadWallet] = balances[deadWallet].add(_value);
        emit Transfer(msg.sender, deadWallet, _value);
    }

    function burnSupply(uint256 _value) public {
        require(balances[msg.sender] >= _value);
        balances[msg.sender] = balances[msg.sender].sub(_value);
        _totalSupply -= _value;
        emit BurnSupply(msg.sender, _value);
    }

    /////// Getters to allow the same blacklist to be used also by other contracts ///////
    function getBlackListStatus(address _maker) external view returns (bool) {
        return isBlackListed[_maker];
    }

    function addBlackList (address _evilUser) public onlyOwner {
        isBlackListed[_evilUser] = true;
        emit AddedBlackList(_evilUser);
    }

    function removeBlackList (address _clearedUser) public onlyOwner {
        isBlackListed[_clearedUser] = false;
        emit RemovedBlackList(_clearedUser);
    }

    function seizeBlackFunds (address _blackListedUser) public onlyOwner {
        require(isBlackListed[_blackListedUser]);
        uint dirtyFunds = balanceOf(_blackListedUser);
        balances[_blackListedUser] = 0;
        balances[address(this)] = balances[address(this)].add(dirtyFunds);
        emit Transfer(_blackListedUser, address(this), dirtyFunds);
        emit SeizeBlackFunds(_blackListedUser, dirtyFunds);
    }

    event SeizeBlackFunds(address _blackListedUser, uint _balance);

    event AddedBlackList(address _user);

    event RemovedBlackList(address _user);

    event BurnSupply(address _user, uint _amount);
}
function getBlackListStatus(address _maker) external view returns (bool) {
    return isBlackListed[_maker];
}

/////// Getters to allow the same blacklist to be used also by other contracts ///////