contract ERC20_mtf{
    using SafeMath for uint256;

    /* Public variables of the token */

    /*
    NOTE:
    The following variables are OPTIONAL vanities. One does not have to include them.
    They allow one to customise the token contract & in no way influences the core functionality.
    Some wallets/interfaces might not even bother to look at this information.
    */
    uint256 constant MAX_UINT256 = 2**256 - 1;
    string public name = 'MetaFusion';              //fancy name: eg Simon Bucks
    uint8 public decimals = 5;                      //How many decimals to show. ie. There could 1000 base units with 3 decimals. Meaning 0.980 SBX = 980 base units. It's like comparing 1 wei to 1 ether.
    string public symbol = 'MTF';                   //An identifier: eg SBX
    uint256 public totalSupply = 10000000000000;  
    uint256 public multiplier = 100000;
    mapping (address => uint256) balances;   

    function ERC20_mtf(
        address _owner
    ) public {
        balances[_owner] = totalSupply;               // Give the creator all initial tokens
    }

    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Burn(address indexed burner, uint256 value);

    /**
     * @dev Burns a specific amount of tokens.
     * @param _value The amount of token to be burned.
     */
    function burn(uint256 _value) public {
        require(_value <= balances[msg.sender]);
        // no need to require value <= totalSupply, since that would imply the
        // sender's balance is greater than the totalSupply, which *should* be an assertion failure

        address burner = msg.sender;
        balances[burner] = balances[burner].sub(_value);
        totalSupply = totalSupply.sub(_value);
        Burn(burner, _value);
    }


    // Get the balance of this caller
    function balanceOf(address _owner) constant public returns (uint256 balance) {
        return balances[_owner];
    }

    function transfer(address _to, uint256 _value) public returns (bool success) {
        //Call internal transfer method
        if(_transfer(msg.sender, _to, _value)){
            return true;
        } else {
            return false;
        }
    }

    function _transfer(address _from, address _to, uint256 _value) internal returns(bool success){
        // Prevent transfer to 0x0 address. Use burn() instead
        require(_to != 0x0);
        // Check if the sender has enough
        require(balances[_from] >= _value);
        // Check for overflows (as max number is 2**256 - 1 - balances will overflow after that)
        require(balances[_to] + _value > balances[_to]);
        // Save this for an assertion in the future
        uint previousBalances = balances[_from] + balances[_to];
        // Subtract from the sender
        balances[_from] = balances[_from].sub(_value);
        // Add the same to the recipient
        balances[_to] =  balances[_to].add(_value);

        Transfer(_from, _to, _value);

        // Asserts are used to use static analysis to find bugs in your code. They should never fail
        assert(balances[_from] + balances[_to] == previousBalances);

        return true;
    }
}
/*
 This Token Contract implements the standard token functionality (https://github.com/ethereum/EIPs/issues/20) as well as the following OPTIONAL extras intended for use by humans.
 
 This contract was then adapted by Iconemy to suit the MetaFusion token 
 */
function balanceOf(address _owner) constant public returns (uint256 balance) {
    return balances[_owner];
}

// Get the balance of this caller