CEN

0x0bc61dded5f6710c637cf8288eb6058766ce1921

setOwner keyboard_arrow_up

	function setOwner (address newOwner) public onlyOwner returns (bool){
		if (owner == msg.sender){
			owner = newOwner;
			emit LogOwnerChanged(msg.sender);
			return true;
		}else{
			return false;
		}
	}

_status keyboard_arrow_up

	function _status() view public returns (bool){
		return stopped;
	}

stop keyboard_arrow_up

	function stop() public onlyOwner{
		stopped = true;
	}

start keyboard_arrow_up

	function start() public onlyOwner{
		stopped = false;
	}

balanceOf keyboard_arrow_up

	function balanceOf(address _owner) public view returns (uint256 balance) {
		return balances[_owner];
	}

transfer keyboard_arrow_up

	function transfer(address _to, uint256 _value) stoppable public returns (bool ind) {
		//Default assumes totalSupply can't be over max (2^256 - 1).
		//If your token leaves out totalSupply and can issue more tokens as time goes on, you need to check if it doesn't wrap.
		//Replace the if with this one instead.
		//if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
		require(_to!= address(0));
		require(frozenCheck(msg.sender,_to));
		if (balances[msg.sender] >= _value && _value > 0) {
			balances[msg.sender] = safeSub(balances[msg.sender] , _value);
			balances[_to]  = safeAdd(balances[_to],_value);
			emit Transfer(msg.sender, _to, _value);
			return true;
		} else { return false; }
	}

transferFrom keyboard_arrow_up

	function transferFrom(address _from, address _to, uint256 _value) stoppable public returns (bool success) {
		//same as above. Replace this line with the following if you want to protect against wrapping uints.
		require(frozenCheck(_from,_to));
		require(_to!= address(0));
		if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
			balances[_to]  = safeAdd(balances[_to],_value);
			balances[_from] = safeSub(balances[_from] , _value);
			allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender],_value);
			emit Transfer(_from, _to, _value);
			return true;
		} else { return false; }
	}

approve keyboard_arrow_up

	function approve(address _spender, uint256 _value) stoppable public returns (bool success) {
		require(frozenCheck(_spender,msg.sender));
		require(_spender!= address(0));
		require(_value>0);
		require(allowed[msg.sender][_spender]==0);
		allowed[msg.sender][_spender] = _value;
		emit Approval(msg.sender, _spender, _value);
		return true;
	}

allowance keyboard_arrow_up

	function allowance(address _owner, address _spender) view public returns (uint256 remaining) {
		return allowed[_owner][_spender];
	}

burn keyboard_arrow_up

	function burn(uint256 amount) stoppable onlyOwner public returns (bool){
		if(balances[msg.sender] > amount ){
			balances[msg.sender] = safeSub(balances[msg.sender],amount);
			totalSupply = safeSub(totalSupply,amount);
			emit Burn(msg.sender,amount);
			return true;
		}else{
			return false;
		}
	}

freezeAccount keyboard_arrow_up

	function freezeAccount(address target , bool freeze) onlyOwner public{
		frozenAccount[target] = freeze;
	}

constructor keyboard_arrow_up

	function () stoppable public {
		revert();
	}