pragma solidity ^0.4.24;

// ------------------------------------------------------------------------------------
// 'XLV BY BITPLOX' Token Contract
//
// Contract Address : 0xAC5FeAA2462Ee9614Dcea47F45330a63DF1BcA8e [Please don't send BNB to this Contract Address because it'll never mint any single Token]
// Symbol : XLV
// Name : XLV BY BITPLOX
// Total Supply : 1,000,000,000 XLV
// Decimals : 8
// Burn : 95% [0x000000000000000000000000000000000000dead]
//
// © By 'XLV BY BITPLOX' With 'XLV' Symbol 2021.
//
// Developed By : https://SoftCode.space Blockchain Developer Team.
//
// Tech Support : https://t.me/SolidityCode [Development | Market Making | Fund Raise | Listing Support]
//
// ------------------------------------------------------------------------------------


contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a b;
require(c >= a);
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
}


contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);

event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}


contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}


contract Owned {
address public owner;
address public newOwner;

event OwnershipTransferred(address indexed _from, address indexed _to);

function Owned() public {
owner = msg.sender;
}

modifier onlyOwner {
require(msg.sender == owner);
_;
}

function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}


contract XLVBYBITPLOX is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;

mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;


function XLVBYBITPLOX() public {
symbol = "XLV";
name = "XLV BY BITPLOX";
decimals = 8;
_totalSupply = 100000000000000000;
balances[0xaB9487F5A05B7967a007aFb5B8fE97Aee2EC85d7] = _totalSupply;
Transfer(address(0), 0xaB9487F5A05B7967a007aFb5B8fE97Aee2EC85d7, _totalSupply);
}


function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}


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


function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
Transfer(msg.sender, to, tokens);
return true;
}


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


function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = safeSub(balances[from], tokens);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
Transfer(from, to, tokens);
return true;
}


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


function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}


function () public payable {
revert();
}


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