contract Yumerium is owned, TokenERC20 {

    address public saleAddress;
    

    mapping (address => bool) public frozenAccount;

    

    event Buy(address indexed to, uint256 value);

    

    event Sell(address indexed from, uint256 value);

    event Sale(address indexed to, uint256 value);
 

    /* This generates a public event on the blockchain that will notify clients */

 

    event FrozenFunds(address target, bool frozen);

    

    function Yumerium() public {

        balanceOf[this] = totalSupply; 


    }
    
    
    function sale(address _to, uint256 _value) public {
        require (msg.sender == saleAddress);
        require (balanceOf[this] >= _value);
        
        balanceOf[this] -= _value;
        balanceOf[_to] += _value;
        Sale(_to, _value);
    }
    
    
    function privateSale(address _to, uint256 _value) onlyOwner public {
        require (balanceOf[this] >= _value);
        
        balanceOf[this] -= _value;
        balanceOf[_to] += _value;
        Sale(_to, _value);
    }
    
    
    
    function changeSaleAddress(address _saleAddress) onlyOwner public {
        saleAddress = _saleAddress;
    }
 

    /* Internal transfer, only can be called by this contract */

 

    function _transfer(address _from, address _to, uint _value) internal {

 

        require (_to != 0x0);                               // Prevent transfer to 0x0 address. Use burn() instead

 

        require (balanceOf[_from] >= _value);               // Check if the sender has enough

 

        require (balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows

 

        require(!frozenAccount[_from]);                     // Check if sender is frozen

 

        require(!frozenAccount[_to]);                       // Check if recipient is frozen

 

        balanceOf[_from] -= _value;                         // Subtract from the sender

 

        balanceOf[_to] += _value;                           // Add the same to the recipient

 

        Transfer(_from, _to, _value);

        

    }

 

 

 

    /// @notice Create `mintedAmount` tokens and send it to `target`

 

    /// @param target Address to receive the tokens

 

    /// @param mintedAmount the amount of tokens it will receive

 

    function mintToken(address target, uint256 mintedAmount) onlyOwner public {

 

        balanceOf[target] += mintedAmount;

 

        totalSupply += mintedAmount;

 

        Transfer(0, this, mintedAmount);

 

        Transfer(this, target, mintedAmount);

 

    }

 

 

 

    /// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens

 

    /// @param target Address to be frozen

 

    /// @param freeze either to freeze it or not

 

    function freezeAccount(address target, bool freeze) onlyOwner public {

 

        frozenAccount[target] = freeze;

 

        FrozenFunds(target, freeze);

 

    }

 

 


    

    

    function sell(uint256 amount) payable public {

        _transfer(msg.sender, owner, amount);


        Sell(msg.sender, amount);

    }

 

 

 

}
/******************************************/
function mintToken(address target, uint256 mintedAmount) onlyOwner public {

 

    balanceOf[target] += mintedAmount;

 

    totalSupply += mintedAmount;

 

    Transfer(0, this, mintedAmount);

 

    Transfer(this, target, mintedAmount);

 

}

/// @notice Create `mintedAmount` tokens and send it to `target`
/// @param target Address to receive the tokens
/// @param mintedAmount the amount of tokens it will receive