Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

library BytesLib    - function concat(bytes memory _preByte ...    - function concatStorage(bytes storage ...    - function slice(bytes _bytes, uint _st ...    - function toAddress(bytes _bytes, uint ...    - function toUint(bytes _bytes, uint _s ...    - function equal(bytes memory _preBytes ...    - function equalStorage(bytes storage _ ...  contract Token    - function totalSupply()    - function by the compiler.    - function balanceOf(address _owner)    - function transfer(address _to, uint25 ...    - function transferFrom(address _from, ...    - function approve(address _spender, ui ...    - function allowance(address _owner, ad ...  contract StandardToken is Token    - function transfer(address _to, uint25 ...    - function transferFrom(address _from, ...    - function balanceOf(address _owner)    - function approve(address _spender, ui ...    - function allowance(address _owner, ad ...  contract HumanStandardToken is Sta ...    - function approveAndCall(address _spen ...  contract Ownable    - function transferOwnership(address ne ... library SafeMath    - function mul(uint256 a, uint256 b)    - function div(uint256 a, uint256 b)    - function sub(uint256 a, uint256 b)    - function add(uint256 a, uint256 b)  contract MintAndBurnToken is Stand ... *    - function mint(address _to, uint256 _a ...    - function finishMinting()    - function burn(uint256 _value)    - function _burn(address _who, uint256 ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-06-19
*/

pragma solidity 0.4.24;

// File: contracts/BytesLib.sol

library BytesLib {
    function concat(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bytes) {
        bytes memory tempBytes;

        assembly {
            // Get a location of some free memory and store it in tempBytes as
            // Solidity does for memory variables.
            tempBytes := mload(0x40)

            // Store the length of the first bytes array at the beginning of
            // the memory for tempBytes.
            let length := mload(_preBytes)
            mstore(tempBytes, length)

            // Maintain a memory counter for the current write location in the
            // temp bytes array by adding the 32 bytes for the array length to
            // the starting location.
            let mc := add(tempBytes, 0x20)
            // Stop copying when the memory counter reaches the length of the
            // first bytes array.
            let end := add(mc, length)

            for {
                // Initialize a copy counter to the start of the _preBytes data,
                // 32 bytes into its memory.
                let cc := add(_preBytes, 0x20)
            } lt(mc, end) {
                // Increase both counters by 32 bytes each iteration.
                mc := add(mc, 0x20)
                cc := add(cc, 0x20)
            } {
                // Write the _preBytes data into the tempBytes memory 32 bytes
                // at a time.
                mstore(mc, mload(cc))
            }

            // Add the length of _postBytes to the current length of tempBytes
            // and store it as the new length in the first 32 bytes of the
            // tempBytes memory.
            length := mload(_postBytes)
            mstore(tempBytes, add(length, mload(tempBytes)))

            // Move the memory counter back from a multiple of 0x20 to the
            // actual end of the _preBytes data.
            mc := end
            // Stop copying when the memory counter reaches the new combined
            // length of the arrays.
            end := add(mc, length)

            for {
                let cc := add(_postBytes, 0x20)
            } lt(mc, end) {
                mc := add(mc, 0x20)
                cc := add(cc, 0x20)
            } {
                mstore(mc, mload(cc))
            }

            // Update the free-memory pointer by padding our last write location
            // to 32 bytes: add 31 bytes to the end of tempBytes to move to the
            // next 32 byte block, then round down to the nearest multiple of
            // 32. If the sum of the length of the two arrays is zero then add 
            // one before rounding down to leave a blank 32 bytes (the length block with 0).
            mstore(0x40, and(
              add(add(end, iszero(add(length, mload(_preBytes)))), 31),
              not(31) // Round down to the nearest 32 bytes.
            ))
        }

        return tempBytes;
    }

    function concatStorage(bytes storage _preBytes, bytes memory _postBytes) internal {
        assembly {
            // Read the first 32 bytes of _preBytes storage, which is the length
            // of the array. (We don't need to use the offset into the slot
            // because arrays use the entire slot.)
            let fslot := sload(_preBytes_slot)
            // Arrays of 31 bytes or less have an even value in their slot,
            // while longer arrays have an odd value. The actual length is
            // the slot divided by two for odd values, and the lowest order
            // byte divided by two for even values.
            // If the slot is even, bitwise and the slot with 255 and divide by
            // two to get the length. If the slot is odd, bitwise and the slot
            // with -1 and divide by two.
            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
            let mlength := mload(_postBytes)
            let newlength := add(slength, mlength)
            // slength can contain both the length and contents of the array
            // if length < 32 bytes so let's prepare for that
            // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
            switch add(lt(slength, 32), lt(newlength, 32))
            case 2 {
                // Since the new array still fits in the slot, we just need to
                // update the contents of the slot.
                // uint256(bytes_storage) = uint256(bytes_storage) + uint256(bytes_memory) + new_length
                sstore(
                    _preBytes_slot,
                    // all the modifications to the slot are inside this
                    // next block
                    add(
                        // we can just add to the slot contents because the
                        // bytes we want to change are the LSBs
                        fslot,
                        add(
                            mul(
                                div(
                                    // load the bytes from memory
                                    mload(add(_postBytes, 0x20)),
                                    // zero all bytes to the right
                                    exp(0x100, sub(32, mlength))
                                ),
                                // and now shift left the number of bytes to
                                // leave space for the length in the slot
                                exp(0x100, sub(32, newlength))
                            ),
                            // increase length by the double of the memory
                            // bytes length
                            mul(mlength, 2)
                        )
                    )
                )
            }
            case 1 {
                // The stored value fits in the slot, but the combined value
                // will exceed it.
                // get the keccak hash to get the contents of the array
                mstore(0x0, _preBytes_slot)
                let sc := add(keccak256(0x0, 0x20), div(slength, 32))

                // save new length
                sstore(_preBytes_slot, add(mul(newlength, 2), 1))

                // The contents of the _postBytes array start 32 bytes into
                // the structure. Our first read should obtain the `submod`
                // bytes that can fit into the unused space in the last word
                // of the stored array. To get this, we read 32 bytes starting
                // from `submod`, so the data we read overlaps with the array
                // contents by `submod` bytes. Masking the lowest-order
                // `submod` bytes allows us to add that value directly to the
                // stored value.

                let submod := sub(32, slength)
                let mc := add(_postBytes, submod)
                let end := add(_postBytes, mlength)
                let mask := sub(exp(0x100, submod), 1)

                sstore(
                    sc,
                    add(
                        and(
                            fslot,
                            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00
                        ),
                        and(mload(mc), mask)
                    )
                )

                for {
                    mc := add(mc, 0x20)
                    sc := add(sc, 1)
                } lt(mc, end) {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } {
                    sstore(sc, mload(mc))
                }

                mask := exp(0x100, sub(mc, end))

                sstore(sc, mul(div(mload(mc), mask), mask))
            }
            default {
                // get the keccak hash to get the contents of the array
                mstore(0x0, _preBytes_slot)
                // Start copying to the last used word of the stored array.
                let sc := add(keccak256(0x0, 0x20), div(slength, 32))

                // save new length
                sstore(_preBytes_slot, add(mul(newlength, 2), 1))

                // Copy over the first `submod` bytes of the new data as in
                // case 1 above.
                let slengthmod := mod(slength, 32)
                let mlengthmod := mod(mlength, 32)
                let submod := sub(32, slengthmod)
                let mc := add(_postBytes, submod)
                let end := add(_postBytes, mlength)
                let mask := sub(exp(0x100, submod), 1)

                sstore(sc, add(sload(sc), and(mload(mc), mask)))
                
                for { 
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } lt(mc, end) {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } {
                    sstore(sc, mload(mc))
                }

                mask := exp(0x100, sub(mc, end))

                sstore(sc, mul(div(mload(mc), mask), mask))
            }
        }
    }

    function slice(bytes _bytes, uint _start, uint _length) internal  pure returns (bytes) {
        require(_bytes.length >= (_start + _length));

        bytes memory tempBytes;

        assembly {
            switch iszero(_length)
            case 0 {
                // Get a location of some free memory and store it in tempBytes as
                // Solidity does for memory variables.
                tempBytes := mload(0x40)

                // The first word of the slice result is potentially a partial
                // word read from the original array. To read it, we calculate
                // the length of that partial word and start copying that many
                // bytes into the array. The first word we copy will start with
                // data we don't care about, but the last `lengthmod` bytes will
                // land at the beginning of the contents of the new array. When
                // we're done copying, we overwrite the full first word with
                // the actual length of the slice.
                let lengthmod := and(_length, 31)

                // The multiplication in the next line is necessary
                // because when slicing multiples of 32 bytes (lengthmod == 0)
                // the following copy loop was copying the origin's length
                // and then ending prematurely not copying everything it should.
                let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
                let end := add(mc, _length)

                for {
                    // The multiplication in the next line has the same exact purpose
                    // as the one above.
                    let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
                } lt(mc, end) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    mstore(mc, mload(cc))
                }

                mstore(tempBytes, _length)

                //update free-memory pointer
                //allocating the array padded to 32 bytes like the compiler does now
                mstore(0x40, and(add(mc, 31), not(31)))
            }
            //if we want a zero-length slice let's just return a zero-length array
            default {
                tempBytes := mload(0x40)

                mstore(0x40, add(tempBytes, 0x20))
            }
        }

        return tempBytes;
    }

    function toAddress(bytes _bytes, uint _start) internal  pure returns (address) {
        require(_bytes.length >= (_start + 20));
        address tempAddress;

        assembly {
            tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)
        }

        return tempAddress;
    }

    function toUint(bytes _bytes, uint _start) internal  pure returns (uint256) {
        require(_bytes.length >= (_start + 32));
        uint256 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x20), _start))
        }

        return tempUint;
    }

    function equal(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) {
        bool success = true;

        assembly {
            let length := mload(_preBytes)

            // if lengths don't match the arrays are not equal
            switch eq(length, mload(_postBytes))
            case 1 {
                // cb is a circuit breaker in the for loop since there's
                //  no said feature for inline assembly loops
                // cb = 1 - don't breaker
                // cb = 0 - break
                let cb := 1

                let mc := add(_preBytes, 0x20)
                let end := add(mc, length)

                for {
                    let cc := add(_postBytes, 0x20)
                // the next line is the loop condition:
                // while(uint(mc < end) + cb == 2)
                } eq(add(lt(mc, end), cb), 2) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    // if any of these checks fails then arrays are not equal
                    if iszero(eq(mload(mc), mload(cc))) {
                        // unsuccess:
                        success := 0
                        cb := 0
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }

        return success;
    }

    function equalStorage(bytes storage _preBytes, bytes memory _postBytes) internal view returns (bool) {
        bool success = true;

        assembly {
            // we know _preBytes_offset is 0
            let fslot := sload(_preBytes_slot)
            // Decode the length of the stored array like in concatStorage().
            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
            let mlength := mload(_postBytes)

            // if lengths don't match the arrays are not equal
            switch eq(slength, mlength)
            case 1 {
                // slength can contain both the length and contents of the array
                // if length < 32 bytes so let's prepare for that
                // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
                if iszero(iszero(slength)) {
                    switch lt(slength, 32)
                    case 1 {
                        // blank the last byte which is the length
                        fslot := mul(div(fslot, 0x100), 0x100)

                        if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) {
                            // unsuccess:
                            success := 0
                        }
                    }
                    default {
                        // cb is a circuit breaker in the for loop since there's
                        //  no said feature for inline assembly loops
                        // cb = 1 - don't breaker
                        // cb = 0 - break
                        let cb := 1

                        // get the keccak hash to get the contents of the array
                        mstore(0x0, _preBytes_slot)
                        let sc := keccak256(0x0, 0x20)

                        let mc := add(_postBytes, 0x20)
                        let end := add(mc, mlength)

                        // the next line is the loop condition:
                        // while(uint(mc < end) + cb == 2)
                        for {} eq(add(lt(mc, end), cb), 2) {
                            sc := add(sc, 1)
                            mc := add(mc, 0x20)
                        } {
                            if iszero(eq(sload(sc), mload(mc))) {
                                // unsuccess:
                                success := 0
                                cb := 0
                            }
                        }
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }

        return success;
    }
}

// File: contracts/Token.sol

// Abstract contract for the full ERC 20 Token standard
// https://github.com/ethereum/EIPs/issues/20
pragma solidity 0.4.24;

contract Token {
    /* This is a slight change to the ERC20 base standard.
    function totalSupply() constant returns (uint256 supply);
    is replaced with:
    uint256 public totalSupply;
    This automatically creates a getter function for the totalSupply.
    This is moved to the base contract since public getter functions are not
    currently recognised as an implementation of the matching abstract
    function by the compiler.
    */
    /// total amount of tokens
    uint256 public totalSupply;

    /// @param _owner The address from which the balance will be retrieved
    /// @return The balance
    function balanceOf(address _owner) constant public returns (uint256 balance);

    /// @notice send `_value` token to `_to` from `msg.sender`
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /// @return Whether the transfer was successful or not
    function transfer(address _to, uint256 _value) public returns (bool success);

    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
    /// @param _from The address of the sender
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /// @return Whether the transfer was successful or not
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);

    /// @notice `msg.sender` approves `_spender` to spend `_value` tokens
    /// @param _spender The address of the account able to transfer the tokens
    /// @param _value The amount of tokens to be approved for transfer
    /// @return Whether the approval was successful or not
    function approve(address _spender, uint256 _value) public returns (bool success);

    /// @param _owner The address of the account owning tokens
    /// @param _spender The address of the account able to transfer the tokens
    /// @return Amount of remaining tokens allowed to spent
    function allowance(address _owner, address _spender) public constant returns (uint256 remaining);

    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}

// File: contracts/StandardToken.sol

/*
You should inherit from StandardToken or, for a token like you would want to
deploy in something like Mist, see HumanStandardToken.sol.
(This implements ONLY the standard functions and NOTHING else.
If you deploy this, you won't have anything useful.)

Implements ERC 20 Token standard: https://github.com/ethereum/EIPs/issues/20
.*/
pragma solidity 0.4.24;



contract StandardToken is Token {

    function transfer(address _to, uint256 _value) public returns (bool success) {
        //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.
        //require(balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]);
        require(balances[msg.sender] >= _value);
        balances[msg.sender] -= _value;
        balances[_to] += _value;
        emit Transfer(msg.sender, _to, _value);
        return true;
    }

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

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

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

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

    mapping (address => uint256) balances;
    mapping (address => mapping (address => uint256)) allowed;
}

// File: contracts/HumanStandardToken.sol

/*
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.

In other words. This is intended for deployment in something like a Token Factory or Mist wallet, and then used by humans.
Imagine coins, currencies, shares, voting weight, etc.
Machine-based, rapid creation of many tokens would not necessarily need these extra features or will be minted in other manners.

1) Initial Finite Supply (upon creation one specifies how much is minted).
2) In the absence of a token registry: Optional Decimal, Symbol & Name.
3) Optional approveAndCall() functionality to notify a contract if an approval() has occurred.

.*/



pragma solidity 0.4.24;

contract HumanStandardToken is StandardToken {

    /* 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.
    */
    string public name;                   //fancy name: eg Simon Bucks
    uint8 public decimals;                //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;                 //An identifier: eg SBX
    string public version = 'H0.1';       //human 0.1 standard. Just an arbitrary versioning scheme.

    constructor(
        uint256 _initialAmount,
        string _tokenName,
        uint8 _decimalUnits,
        string _tokenSymbol
        ) public {
        balances[msg.sender] = _initialAmount;               // Give the creator all initial tokens
        totalSupply = _initialAmount;                        // Update total supply
        name = _tokenName;                                   // Set the name for display purposes
        decimals = _decimalUnits;                            // Amount of decimals for display purposes
        symbol = _tokenSymbol;                               // Set the symbol for display purposes
    }

    /* Approves and then calls the receiving contract */
    function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
        allowed[msg.sender][_spender] = _value;
        emit Approval(msg.sender, _spender, _value);

        //call the receiveApproval function on the contract you want to be notified. This crafts the function signature manually so one doesn't have to include a contract in here just for this.
        //receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
        //it is assumed that when does this that the call *should* succeed, otherwise one would use vanilla approve instead.
        require(_spender.call(bytes4(bytes32(keccak256("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData));
        return true;
    }
}

// File: contracts/OZ_Ownable.sol

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
  address public owner;


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


  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  constructor() public {
    owner = msg.sender;
  }

  /**
   * @dev Throws if called by any account other than the owner.
   */
  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }

  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param newOwner The address to transfer ownership to.
   */
  function transferOwnership(address newOwner) public onlyOwner {
    require(newOwner != address(0));
    emit OwnershipTransferred(owner, newOwner);
    owner = newOwner;
  }

}

// File: contracts/SafeMath.sol

/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {
  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }

  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    // assert(b > 0); // Solidity automatically throws when dividing by 0
    uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
    return c;
  }

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

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

// File: contracts/MintAndBurnToken.sol

/**
 * @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
 */
contract MintAndBurnToken is StandardToken, Ownable {
  event Mint(address indexed to, uint256 amount);
  event MintFinished();

  bool public mintingFinished = false;


  modifier canMint() {
    require(!mintingFinished);
    _;
  }

/* 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.
    */
    string public name;                   //fancy name: eg Simon Bucks
    uint8 public decimals;                //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;                 //An identifier: eg SBX
    string public version = 'H0.1';       //human 0.1 standard. Just an arbitrary versioning scheme.

    constructor(
        string _tokenName,
        uint8 _decimalUnits,
        string _tokenSymbol
        ) public {
        name = _tokenName;                                   // Set the name for display purposes
        decimals = _decimalUnits;                            // Amount of decimals for display purposes
        symbol = _tokenSymbol;                               // Set the symbol for display purposes
    }

  /**
   * @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) onlyOwner canMint public returns (bool) {
    totalSupply = SafeMath.add(_amount, totalSupply);
    balances[_to] = SafeMath.add(_amount,balances[_to]);
    emit Mint(_to, _amount);
    emit Transfer(address(0), _to, _amount);
    return true;
  }

  /**
   * @dev Function to stop minting new tokens.
   * @return True if the operation was successful.
   */
  function finishMinting() onlyOwner canMint public returns (bool) {
    mintingFinished = true;
    emit MintFinished();
    return true;
  }

  // -----------------------------------
  // BURN FUNCTIONS BELOW
  // https://github.com/OpenZeppelin/openzeppelin-solidity/blob/master/contracts/token/ERC20/BurnableToken.sol
  // -----------------------------------

  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) onlyOwner public {
    _burn(msg.sender, _value);
  }

  function _burn(address _who, uint256 _value) internal {
    require(_value <= balances[_who]);
    // 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

    balances[_who] = SafeMath.sub(balances[_who],_value);
    totalSupply = SafeMath.sub(totalSupply,_value);
    emit Burn(_who, _value);
    emit Transfer(_who, address(0), _value);
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":true,"inputs":[],"name":"mintingFinished","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_spender","type":"address"},{"name":"_value","type":"uint256"}],"name":"approve","outputs":[{"name":"success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_from","type":"address"},{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"transferFrom","outputs":[{"name":"success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_amount","type":"uint256"}],"name":"mint","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_value","type":"uint256"}],"name":"burn","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"version","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"}],"name":"balanceOf","outputs":[{"name":"balance","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"finishMinting","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"transfer","outputs":[{"name":"success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"},{"name":"_spender","type":"address"}],"name":"allowance","outputs":[{"name":"remaining","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[{"name":"_tokenName","type":"string"},{"name":"_decimalUnits","type":"uint8"},{"name":"_tokenSymbol","type":"string"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"name":"to","type":"address"},{"indexed":false,"name":"amount","type":"uint256"}],"name":"Mint","type":"event"},{"anonymous":false,"inputs":[],"name":"MintFinished","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"burner","type":"address"},{"indexed":false,"name":"value","type":"uint256"}],"name":"Burn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"previousOwner","type":"address"},{"indexed":true,"name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"_from","type":"address"},{"indexed":true,"name":"_to","type":"address"},{"indexed":false,"name":"_value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"_owner","type":"address"},{"indexed":true,"name":"_spender","type":"address"},{"indexed":false,"name":"_value","type":"uint256"}],"name":"Approval","type":"event"}]

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

0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000001200000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000005424f4f54590000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005424f4f5459000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _tokenName (string): BOOTY
Arg [1] : _decimalUnits (uint8): 18
Arg [2] : _tokenSymbol (string): BOOTY

-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000012
Arg [2] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [4] : 424f4f5459000000000000000000000000000000000000000000000000000000
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [6] : 424f4f5459000000000000000000000000000000000000000000000000000000

26889:3216:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27024:35;;8:9:-1;5:2;;;30:1;27;20:12;5:2;27024:35:0;;;;;;;;;;;;;;;;;;;;;;27473:18;;8:9:-1;5:2;;;30:1;27;20:12;5:2;27473:18:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;27473:18:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20981:214;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;20981:214:0;-1:-1:-1;;;;;20981:214:0;;;;;;;17324:26;;8:9:-1;5:2;;;30:1;27;20:12;5:2;17324:26:0;;;;;;;;;;;;;;;;;;;;20235:611;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;20235:611:0;-1:-1:-1;;;;;20235:611:0;;;;;;;;;;;;27545:21;;8:9:-1;5:2;;;30:1;27;20:12;5:2;27545:21:0;;;;;;;;;;;;;;;;;;;;;;;28586:297;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;28586:297:0;-1:-1:-1;;;;;28586:297:0;;;;;;;29548:85;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;29548:85:0;;;;;;;27807:30;;8:9:-1;5:2;;;30:1;27;20:12;5:2;27807:30:0;;;;20854:119;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;20854:119:0;-1:-1:-1;;;;;20854:119:0;;;;;29003:144;;8:9:-1;5:2;;;30:1;27;20:12;5:2;29003:144:0;;;;24909:20;;8:9:-1;5:2;;;30:1;27;20:12;5:2;24909:20:0;;;;;;;;-1:-1:-1;;;;;24909:20:0;;;;;;;;;;;;;;27740;;8:9:-1;5:2;;;30:1;27;20:12;5:2;27740:20:0;;;;19604:623;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;19604:623:0;-1:-1:-1;;;;;19604:623:0;;;;;;;21203:146;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;21203:146:0;-1:-1:-1;;;;;21203:146:0;;;;;;;;;;25524:178;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;25524:178:0;-1:-1:-1;;;;;25524:178:0;;;;;27024:35;;;;;;;;;:::o;27473:18::-;;;;;;;;;;;;;;;-1:-1:-1;;27473:18:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;20981:214::-;21081:10;21048:12;21073:19;;;:7;:19;;;;;;;;-1:-1:-1;;;;;21073:29:0;;;;;;;;;;;:38;;;21127;;;;;;;21048:12;;21073:29;;21081:10;;21127:38;;;;;;;;-1:-1:-1;21183:4:0;20981:214;;;;:::o;17324:26::-;;;;:::o;20235:611::-;-1:-1:-1;;;;;20589:15:0;;20317:12;20589:15;;;:8;:15;;;;;;:25;-1:-1:-1;20589:25:0;;;:65;;-1:-1:-1;;;;;;20618:14:0;;;;;;:7;:14;;;;;;;;20633:10;20618:26;;;;;;;;:36;-1:-1:-1;20618:36:0;20589:65;20581:74;;;;;;;;-1:-1:-1;;;;;20666:13:0;;;;;;;:8;:13;;;;;;;;:23;;;;;;20700:15;;;;;;;;;:25;;;;;;;20736:7;:14;;;;;20751:10;20736:26;;;;;;;;:36;;;;;;;20788:28;;;;;;;20666:13;;20700:15;;-1:-1:-1;;;;;;;;;;;20788:28:0;;;;;;;;;-1:-1:-1;20834:4:0;20235:611;;;;;:::o;27545:21::-;;;;;;:::o;28586:297::-;25337:5;;28664:4;;-1:-1:-1;;;;;25337:5:0;25323:10;:19;25315:28;;;;;;27103:15;;;;;;;27102:16;27094:25;;;;;;28691:34;28704:7;28713:11;;28691:12;:34::i;:::-;28677:11;:48;;;-1:-1:-1;;;;;28769:13:0;;;;:8;:13;;;;;;28748:35;;28761:7;;28748:12;:35::i;:::-;-1:-1:-1;;;;;28732:13:0;;;;;;:8;:13;;;;;;;;;:51;;;;28795:18;;;;;;;28732:13;;28795:18;;;;;;;;;28825:34;;;;;;;;-1:-1:-1;;;;;28825:34:0;;;28842:1;;-1:-1:-1;;;;;;;;;;;28825:34:0;;;;;;;;-1:-1:-1;28873:4:0;28586:297;;;;:::o;29548:85::-;25337:5;;-1:-1:-1;;;;;25337:5:0;25323:10;:19;25315:28;;;;;;29602:25;29608:10;29620:6;29602:5;:25::i;:::-;29548:85;:::o;27807:30::-;;;;;;;;;;;;;;;-1:-1:-1;;27807:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20854:119;-1:-1:-1;;;;;20949:16:0;20914:15;20949:16;;;:8;:16;;;;;;;20854:119::o;29003:144::-;25337:5;;29062:4;;-1:-1:-1;;;;;25337:5:0;25323:10;:19;25315:28;;;;;;27103:15;;;;;;;27102:16;27094:25;;;;;;29075:15;:22;;-1:-1:-1;;29075:22:0;;;;;29109:14;;;;29075:22;;29109:14;-1:-1:-1;29137:4:0;29003:144;:::o;24909:20::-;;;-1:-1:-1;;;;;24909:20:0;;:::o;27740:::-;;;;;;;;;;;;;;;-1:-1:-1;;27740:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19604:623;20051:10;19667:12;20042:20;;;:8;:20;;;;;;:30;-1:-1:-1;20042:30:0;20034:39;;;;;;20093:10;20084:20;;;;:8;:20;;;;;;;;:30;;;;;;;-1:-1:-1;;;;;20125:13:0;;;;;;;;;:23;;;;;;20164:33;;;;;;;20125:13;;20093:10;-1:-1:-1;;;;;;;;;;;20164:33:0;;;;;;;;;;-1:-1:-1;20215:4:0;19604:623;;;;:::o;21203:146::-;-1:-1:-1;;;;;21316:15:0;;;21281:17;21316:15;;;:7;:15;;;;;;;;:25;;;;;;;;;;;;;21203:146::o;25524:178::-;25337:5;;-1:-1:-1;;;;;25337:5:0;25323:10;:19;25315:28;;;;;;-1:-1:-1;;;;;25601:22:0;;;;25593:31;;;;;;25657:5;;25636:37;;-1:-1:-1;;;;;25636:37:0;;;;25657:5;;25636:37;;25657:5;;25636:37;25680:5;:16;;-1:-1:-1;;25680:16:0;-1:-1:-1;;;;;25680:16:0;;;;;;;;;;25524:178::o;26410:133::-;26468:7;26496:5;;;26515:6;;;;26508:14;;;;26536:1;26410:133;-1:-1:-1;;;26410:133:0:o;29639:463::-;-1:-1:-1;;;;;29718:14:0;;;;;;:8;:14;;;;;;29708:24;;;29700:33;;;;;;-1:-1:-1;;;;;29945:14:0;;;;;;:8;:14;;;;;;29932:35;;29960:6;29932:12;:35::i;:::-;-1:-1:-1;;;;;29915:14:0;;;;;;:8;:14;;;;;:52;;;;30001:11;29988:32;;30013:6;29988:12;:32::i;:::-;29974:11;:46;30032:18;;;;;;;;-1:-1:-1;;;;;30032:18:0;;;;;;;;;;;;;30062:34;;;;;;;;30085:1;;-1:-1:-1;;;;;30062:34:0;;;-1:-1:-1;;;;;;;;;;;30062:34:0;;;;;;;;29639:463;;:::o;26291:113::-;26349:7;26372:6;;;;26365:14;;;;-1:-1:-1;26393:5:0;;;26291:113::o

bzzr://7f582d67e99587113a2fcc4a1b03e6a3503de85e27b3a3900b7be0015e96162a