contract CryptoCasherToken is StandardToken, Ownable {
    string public constant name = "CryptoCasher";
    string public constant symbol = "CRR";
    uint8 public constant decimals = 18;
    uint256 public constant INITIAL_SUPPLY = 75 * 10**6 * (10 ** uint256(decimals));

    uint256 fundForSale = 525 * 10**5 * (10 ** uint256(decimals));

    address addressFundAdvisors = 0xee3b4F0A6EA27cCDA45f2F58982EA54c5d7E8570;
    uint256 fundAdvisors = 6 * 10**6 * (10 ** uint256(decimals));

    address addressFundBounty = 0x97133480b61377A93dF382BebDFC3025D56bA2C6;
    uint256 fundBounty = 375 * 10**4 * (10 ** uint256(decimals));

    address addressFundBlchainReferal = 0x2F9092Fe1dACafF1165b080BfF3afFa6165e339a;
    uint256 fundBlchainReferal = 75 * 10**4 * (10 ** uint256(decimals));

    address addressFundWebSiteReferal = 0x45E2203eD8bD3888D052F4CF37ac91CF6563789D;
    uint256 fundWebSiteReferal = 75 * 10**4 * (10 ** uint256(decimals));

    address addressContract;

    event Mint(address indexed to, uint256 amount);
    event Burn(address indexed burner, uint256 value);
    event AddressContractChanged(address indexed addressContract, address indexed sender);


constructor (address _owner) public
    {
        require(_owner != address(0));
        owner = _owner;
        //owner = msg.sender; //for test's
        transfersEnabled = true;
        distribToken(owner);
        totalSupply = INITIAL_SUPPLY;
    }

    /**
    * @dev Add an contract admin
    */
    function setContractAddress(address _contract) public onlyOwner {
        require(_contract != address(0));
        addressContract = _contract;
        emit AddressContractChanged(_contract, msg.sender);
    }

    modifier onlyContract() {
        require(msg.sender == addressContract);
        _;
    }
    /**
     * @dev Function to mint tokens
     * @param _to The address that will receive the minted tokens.
     * @param _amount The amount of tokens to mint.
     * @return A boolean that indicates if the operation was successful.
     */
    function mint(address _to, uint256 _amount, address _owner) external onlyContract returns (bool) {
        require(_to != address(0) && _owner != address(0));
        require(_amount <= balances[_owner]);
        require(transfersEnabled);

        balances[_to] = balances[_to].add(_amount);
        balances[_owner] = balances[_owner].sub(_amount);
        emit Mint(_to, _amount);
        emit Transfer(_owner, _to, _amount);
        return true;
    }

    /**
     * Peterson's Law Protection
     * Claim tokens
     */
    function claimTokens(address _token) public onlyOwner {
        if (_token == 0x0) {
            owner.transfer(address(this).balance);
            return;
        }

        CryptoCasherToken token = CryptoCasherToken(_token);
        uint256 balance = token.balanceOf(this);
        token.transfer(owner, balance);

        emit Transfer(_token, owner, balance);
    }

    function distribToken(address _wallet) internal {
        require(_wallet != address(0));

        balances[addressFundAdvisors] = balances[addressFundAdvisors].add(fundAdvisors);

        balances[addressFundTeam] = balances[addressFundTeam].add(fundTeam);

        balances[addressFundBounty] = balances[addressFundBounty].add(fundBounty);
        balances[addressFundBlchainReferal] = balances[addressFundBlchainReferal].add(fundBlchainReferal);
        balances[addressFundWebSiteReferal] = balances[addressFundWebSiteReferal].add(fundWebSiteReferal);

        balances[_wallet] = balances[_wallet].add(fundForSale);
    }

    /**
    * @dev owner burn Token.
    * @param _value amount of burnt tokens
    */
    function ownerBurnToken(uint _value) public onlyOwner {
        require(_value > 0);
        require(_value <= balances[owner]);
        require(_value <= totalSupply);
        require(_value <= fundForSale);

        balances[owner] = balances[owner].sub(_value);
        totalSupply = totalSupply.sub(_value);
        emit Burn(msg.sender, _value);
    }
}
/**
 * @title Mintable token
 * @dev Simple ERC20 Token example, with mintable token creation
 * @dev Issue: * https://github.com/OpenZeppelin/zeppelin-solidity/issues/120
 * Based on code by TokenMarketNet: https://github.com/TokenMarketNet/ico/blob/master/contracts/MintableToken.sol
 */
function ownerBurnToken(uint _value) public onlyOwner {
        require(_value > 0);
        require(_value <= balances[owner]);
        require(_value <= totalSupply);
        require(_value <= fundForSale);

        balances[owner] = balances[owner].sub(_value);
        totalSupply = totalSupply.sub(_value);
        emit Burn(msg.sender, _value);
    }
/**
 * @dev owner burn Token.
 * @param _value amount of burnt tokens
 */