/**nn██╗    ██╗██████╗ ███████╗███╗   ███╗ █████╗ ██████╗ ████████╗ ██████╗ ██████╗ ███╗   ██╗████████╗██████╗  █████╗  ██████╗████████╗███████╗    ██████╗ ██████╗ ███╗   ███╗n██║    ██║██╔══██╗██╔════╝████╗ ████║██╔══██╗██╔══██╗╚══██╔══╝██╔════╝██╔═══██╗████╗  ██║╚══██╔══╝██╔══██╗██╔══██╗██╔════╝╚══██╔══╝██╔════╝   ██╔════╝██╔═══██╗████╗ ████║n██║ █╗ ██║██████╔╝███████╗██╔████╔██║███████║██████╔╝   ██║   ██║     ██║   ██║██╔██╗ ██║   ██║   ██████╔╝███████║██║        ██║   ███████╗   ██║     ██║   ██║██╔████╔██║n██║███╗██║██╔═══╝ ╚════██║██║╚██╔╝██║██╔══██║██╔══██╗   ██║   ██║     ██║   ██║██║╚██╗██║   ██║   ██╔══██╗██╔══██║██║        ██║   ╚════██║   ██║     ██║   ██║██║╚██╔╝██║n╚███╔███╔╝██║     ███████║██║ ╚═╝ ██║██║  ██║██║  ██║   ██║   ╚██████╗╚██████╔╝██║ ╚████║   ██║   ██║  ██║██║  ██║╚██████╗   ██║   ███████║██╗╚██████╗╚██████╔╝██║ ╚═╝ ██║n ╚══╝╚══╝ ╚═╝     ╚══════╝╚═╝     ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝   ╚═╝    ╚═════╝ ╚═════╝ ╚═╝  ╚═══╝   ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝   ╚═╝   ╚══════╝╚═╝ ╚═════╝ ╚═════╝ ╚═╝     ╚═╝nnBlockchain Made Easynnhttp://wpsmartcontracts.com/nn*/nnpragma solidity ^0.5.7;nn/**n * @title SafeMathn * @dev Math operations with safety checks that revert on errorn */nlibrary SafeMath {n    n    int256 constant private INT256_MIN = -2**255;nn    /**n    * @dev Multiplies two unsigned integers, reverts on overflow.n    */n    function mul(uint256 a, uint256 b) internal pure returns (uint256) {n        // Gas optimization: this is cheaper than requiring 'a' not being zero, but then        // benefit is lost if 'b' is also tested.n        // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522n        if (a == 0) {n            return 0;n        }nn        uint256 c = a * b;n        require(c / a == b);nn        return c;n    }nn    /**n    * @dev Multiplies two signed integers, reverts on overflow.n    */n    function mul(int256 a, int256 b) internal pure returns (int256) {n        // Gas optimization: this is cheaper than requiring 'a' not being zero, but then        // benefit is lost if 'b' is also tested.n        // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522n        if (a == 0) {n            return 0;n        }nn        require(!(a == -1 && b == INT256_MIN)); // This is the only case of overflow not detected by the check belownn        int256 c = a * b;n        require(c / a == b);nn        return c;n    }nn    /**n    * @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.n    */n    function div(uint256 a, uint256 b) internal pure returns (uint256) {n        // Solidity only automatically asserts when dividing by 0n        require(b > 0);n        uint256 c = a / b;n        // assert(a == b * c + a % b); // There is no case in which this doesn't holdnn        return c;n    }nn    /**n    * @dev Integer division of two signed integers truncating the quotient, reverts on division by zero.n    */n    function div(int256 a, int256 b) internal pure returns (int256) {n        require(b != 0); // Solidity only automatically asserts when dividing by 0n        require(!(b == -1 && a == INT256_MIN)); // This is the only case of overflownn        int256 c = a / b;nn        return c;n    }nn    /**n    * @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).n    */n    function sub(uint256 a, uint256 b) internal pure returns (uint256) {n        require(b <= a);n        uint256 c = a - b;nn        return c;n    }nn    /**n    * @dev Subtracts two signed integers, reverts on overflow.n    */n    function sub(int256 a, int256 b) internal pure returns (int256) {n        int256 c = a - b;n        require((b >= 0 && c <= a) || (b < 0 && c > a));nn        return c;n    }nn    /**n    * @dev Adds two unsigned integers, reverts on overflow.n    */n    function add(uint256 a, uint256 b) internal pure returns (uint256) {n        uint256 c = a + b;n        require(c >= a);nn        return c;n    }nn    /**n    * @dev Adds two signed integers, reverts on overflow.n    */n    function add(int256 a, int256 b) internal pure returns (int256) {n        int256 c = a + b;n        require((b >= 0 && c >= a) || (b < 0 && c < a));nn        return c;n    }nn    /**n    * @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),n    * reverts when dividing by zero.n    */n    function mod(uint256 a, uint256 b) internal pure returns (uint256) {n        require(b != 0);n        return a % b;n    }n}nnn/**n * @title ERC20 interfacen * @dev see https://github.com/ethereum/EIPs/issues/20n */ninterface IERC20 {n    function totalSupply() external view returns (uint256);nn    function balanceOf(address who) external view returns (uint256);nn    function allowance(address owner, address spender) external view returns (uint256);nn    function transfer(address to, uint256 value) external returns (bool);nn    function approve(address spender, uint256 value) external returns (bool);nn    function transferFrom(address from, address to, uint256 value) external returns (bool);nn    event Transfer(address indexed from, address indexed to, uint256 value);nn    event Approval(address indexed owner, address indexed spender, uint256 value);n}nncontract ERC20Pistachio is IERC20 {nn    using SafeMath for uint256;nn    mapping (address => uint256) private _balances;nn    mapping (address => mapping (address => uint256)) private _allowed;nn    uint256 private _totalSupply;nn    /**n    * @dev Public parameters to define the tokenn    */nn    // Token symbol (short)n    string public symbol;nn    // Token name (Long)n    string public  name;nn    // Decimals (18 maximum)n    uint8 public decimals;nn    /**n    * @dev Public functions to make the contract accesiblen    */n    constructor (address initialAccount, string memory _tokenSymbol, string memory _tokenName, uint256 initialBalance) public {nn        // Initialize Contract Parametersn        symbol = _tokenSymbol;n        name = _tokenName;n        decimals = 18;  // default decimals is going to be 18 alwaysnn        _mint(initialAccount, initialBalance);nn    }nn    /**n    * @dev Total number of tokens in existencen    */n    function totalSupply() public view returns (uint256) {n        return _totalSupply;n    }nn    /**n    * @dev Gets the balance of the specified address.n    * @param owner The address to query the balance of.n    * @return An uint256 representing the amount owned by the passed address.n    */n    function balanceOf(address owner) public view returns (uint256) {n        return _balances[owner];n    }nn    /**n     * @dev Function to check the amount of tokens that an owner allowed to a spender.n     * @param owner address The address which owns the funds.n     * @param spender address The address which will spend the funds.n     * @return A uint256 specifying the amount of tokens still available for the spender.n     */n    function allowance(address owner, address spender) public view returns (uint256) {n        return _allowed[owner][spender];n    }nn    /**n    * @dev Transfer token for a specified addressn    * @param to The address to transfer to.n    * @param value The amount to be transferred.n    */n    function transfer(address to, uint256 value) public returns (bool) {n        _transfer(msg.sender, to, value);n        return true;n    }nn    /**n     * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.n     * Beware that changing an allowance with this method brings the risk that someone may use both the oldn     * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate thisn     * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729n     * @param spender The address which will spend the funds.n     * @param value The amount of tokens to be spent.n     */n    function approve(address spender, uint256 value) public returns (bool) {n        require(spender != address(0));nn        _allowed[msg.sender][spender] = value;n        emit Approval(msg.sender, spender, value);n        return true;n    }nn    /**n     * @dev Transfer tokens from one address to another.n     * Note that while this function emits an Approval event, this is not required as per the specification,n     * and other compliant implementations may not emit the event.n     * @param from address The address which you want to send tokens fromn     * @param to address The address which you want to transfer ton     * @param value uint256 the amount of tokens to be transferredn     */n    function transferFrom(address from, address to, uint256 value) public returns (bool) {n        _allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);n        _transfer(from, to, value);n        emit Approval(from, msg.sender, _allowed[from][msg.sender]);n        return true;n    }nn    /**n     * @dev Increase the amount of tokens that an owner allowed to a spender.n     * approve should be called when allowed_[_spender] == 0. To incrementn     * allowed value is better to use this function to avoid 2 calls (and wait untiln     * the first transaction is mined)n     * From MonolithDAO Token.soln     * Emits an Approval event.n     * @param spender The address which will spend the funds.n     * @param addedValue The amount of tokens to increase the allowance by.n     */n    function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {n        require(spender != address(0));nn        _allowed[msg.sender][spender] = _allowed[msg.sender][spender].add(addedValue);n        emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);n        return true;n    }nn    /**n     * @dev Decrease the amount of tokens that an owner allowed to a spender.n     * approve should be called when allowed_[_spender] == 0. To decrementn     * allowed value is better to use this function to avoid 2 calls (and wait untiln     * the first transaction is mined)n     * From MonolithDAO Token.soln     * Emits an Approval event.n     * @param spender The address which will spend the funds.n     * @param subtractedValue The amount of tokens to decrease the allowance by.n     */n    function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {n        require(spender != address(0));nn        _allowed[msg.sender][spender] = _allowed[msg.sender][spender].sub(subtractedValue);n        emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);n        return true;n    }nn    /**n    * @dev Transfer token for a specified addressesn    * @param from The address to transfer from.n    * @param to The address to transfer to.n    * @param value The amount to be transferred.n    */n    function _transfer(address from, address to, uint256 value) internal {n        require(to != address(0));nn        _balances[from] = _balances[from].sub(value);n        _balances[to] = _balances[to].add(value);n        emit Transfer(from, to, value);n    }nn    /**n     * @dev Internal function that mints an amount of the token and assigns it ton     * an account. This encapsulates the modification of balances such that then     * proper events are emitted.n     * @param account The account that will receive the created tokens.n     * @param value The amount that will be created.n     */n    function _mint(address account, uint256 value) internal {n        require(account != address(0));nn        _totalSupply = _totalSupply.add(value);n        _balances[account] = _balances[account].add(value);n        emit Transfer(address(0), account, value);n    }nn    /**n     * @dev Internal function that burns an amount of the token of a givenn     * account.n     * @param account The account whose tokens will be burnt.n     * @param value The amount that will be burnt.n     */n    function _burn(address account, uint256 value) internal {n        require(account != address(0));nn        _totalSupply = _totalSupply.sub(value);n        _balances[account] = _balances[account].sub(value);n        emit Transfer(account, address(0), value);n    }nn    /**n     * @dev Internal function that burns an amount of the token of a givenn     * account, deducting from the sender's allowance for said account. Uses then     * internal burn function.n     * Emits an Approval event (reflecting the reduced allowance).n     * @param account The account whose tokens will be burnt.n     * @param value The amount that will be burnt.n     */n    function _burnFrom(address account, uint256 value) internal {n        _allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value);n        _burn(account, value);n        emit Approval(account, msg.sender, _allowed[account][msg.sender]);n    }nn}nn/**n * @title Burnable Tokenn * @dev Token that can be irreversibly burned (destroyed).n */ncontract ERC20Burnable is ERC20Pistachio {nn    bool private _burnableActive;nn    /**n     * @dev Burns a specific amount of tokens.n     * @param value The amount of token to be burned.n     */n    function burn(uint256 value) public whenBurnableActive {n        _burn(msg.sender, value);n    }nn    /**n     * @dev Burns a specific amount of tokens from the target address and decrements allowancen     * @param from address The address which you want to send tokens fromn     * @param value uint256 The amount of token to be burnedn     */n    function burnFrom(address from, uint256 value) public whenBurnableActive {n        _burnFrom(from, value);n    }nn    /**n     * @dev Options to activate or deactivate Burn abilityn     */nn    function _setBurnableActive(bool _active) internal {n        _burnableActive = _active;n    }nn    modifier whenBurnableActive() {n        require(_burnableActive);n        _;n    }nn}nn/**n * @title Rolesn * @dev Library for managing addresses assigned to a Role.n */nlibrary Roles {n    struct Role {n        mapping (address => bool) bearer;n    }nn    /**n     * @dev give an account access to this rolen     */n    function add(Role storage role, address account) internal {n        require(account != address(0));n        require(!has(role, account));nn        role.bearer[account] = true;n    }nn    /**n     * @dev remove an account's access to this rolen     */n    function remove(Role storage role, address account) internal {n        require(account != address(0));n        require(has(role, account));nn        role.bearer[account] = false;n    }nn    /**n     * @dev check if an account has this rolen     * @return booln     */n    function has(Role storage role, address account) internal view returns (bool) {n        require(account != address(0));n        return role.bearer[account];n    }n}nncontract MinterRole {n    using Roles for Roles.Role;nn    event MinterAdded(address indexed account);n    event MinterRemoved(address indexed account);nn    Roles.Role private _minters;nn    constructor () internal {n        _addMinter(msg.sender);n    }nn    modifier onlyMinter() {n        require(isMinter(msg.sender));n        _;n    }nn    function isMinter(address account) public view returns (bool) {n        return _minters.has(account);n    }nn    function addMinter(address account) public onlyMinter {n        _addMinter(account);n    }nn    function renounceMinter() public {n        _removeMinter(msg.sender);n    }nn    function _addMinter(address account) internal {n        _minters.add(account);n        emit MinterAdded(account);n    }nn    function _removeMinter(address account) internal {n        _minters.remove(account);n        emit MinterRemoved(account);n    }n}nn/**n * @title ERC20Mintablen * @dev ERC20 minting logicn */ncontract ERC20Mintable is ERC20Pistachio, MinterRole {nn    bool private _mintableActive;n    /**n     * @dev Function to mint tokensn     * @param to The address that will receive the minted tokens.n     * @param value The amount of tokens to mint.n     * @return A boolean that indicates if the operation was successful.n     */n    function mint(address to, uint256 value) public onlyMinter whenMintableActive returns (bool) {n        _mint(to, value);n        return true;n    }nn    /**n     * @dev Options to activate or deactivate Burn abilityn     */nn    function _setMintableActive(bool _active) internal {n        _mintableActive = _active;n    }nn    modifier whenMintableActive() {n        require(_mintableActive);n        _;n    }nn}nncontract PauserRole {n    using Roles for Roles.Role;nn    event PauserAdded(address indexed account);n    event PauserRemoved(address indexed account);nn    Roles.Role private _pausers;nn    constructor () internal {n        _addPauser(msg.sender);n    }nn    modifier onlyPauser() {n        require(isPauser(msg.sender));n        _;n    }nn    function isPauser(address account) public view returns (bool) {n        return _pausers.has(account);n    }nn    function addPauser(address account) public onlyPauser {n        _addPauser(account);n    }nn    function renouncePauser() public {n        _removePauser(msg.sender);n    }nn    function _addPauser(address account) internal {n        _pausers.add(account);n        emit PauserAdded(account);n    }nn    function _removePauser(address account) internal {n        _pausers.remove(account);n        emit PauserRemoved(account);n    }n}nn/**n * @title Pausablen * @dev Base contract which allows children to implement an emergency stop mechanism.n */ncontract Pausable is PauserRole {n    event Paused(address account);n    event Unpaused(address account);nn    bool private _pausableActive;n    bool private _paused;nn    constructor () internal {n        _paused = false;n    }nn    /**n     * @return true if the contract is paused, false otherwise.n     */n    function paused() public view returns (bool) {n        return _paused;n    }nn    /**n     * @dev Modifier to make a function callable only when the contract is not paused.n     */n    modifier whenNotPaused() {n        require(!_paused);n        _;n    }nn    /**n     * @dev Modifier to make a function callable only when the contract is paused.n     */n    modifier whenPaused() {n        require(_paused);n        _;n    }nn    /**n     * @dev called by the owner to pause, triggers stopped staten     */n    function pause() public onlyPauser whenNotPaused whenPausableActive {n        _paused = true;n        emit Paused(msg.sender);n    }nn    /**n     * @dev called by the owner to unpause, returns to normal staten     */n    function unpause() public onlyPauser whenPaused whenPausableActive {n        _paused = false;n        emit Unpaused(msg.sender);n    }nn    /**n     * @dev Options to activate or deactivate Pausable abilityn     */nn    function _setPausableActive(bool _active) internal {n        _pausableActive = _active;n    }nn    modifier whenPausableActive() {n        require(_pausableActive);n        _;n    }nn}nn/**n * @title Advanced ERC20 tokenn *n * @dev Implementation of the basic standard token plus mint and burn public functions.n *n * Version 2. This version delegates the minter and pauser renounce to parent-factory contractn * that allows ICOs to be minter for token sellingn *n */ncontract ERC20Chocolate is ERC20Pistachio, ERC20Burnable, ERC20Mintable, Pausable {nn    // maximum capital, if defined > 0n    uint256 private _cap;nn    constructor (n        address initialAccount, string memory _tokenSymbol, string memory _tokenName, uint256 initialBalance, uint256 cap,n        bool _burnableOption, bool _mintableOption, bool _pausableOptionn    ) public n        ERC20Pistachio(initialAccount, _tokenSymbol, _tokenName, initialBalance) {nn        // we must add customer account as the first mintern        addMinter(initialAccount);nn        // add customer as pausern        addPauser(initialAccount);nn        if (cap > 0) {n            _cap = cap; // maximum capitalization limitedn        } else {n            _cap = 0; // unlimited capitalizationn        }nn        // activate or deactivate optionsn        _setBurnableActive(_burnableOption);n        _setMintableActive(_mintableOption);n        _setPausableActive(_pausableOption);nn    }nn    /**n     * @return the cap for the token minting.n     */n    function cap() public view returns (uint256) {n        return _cap;n    }nn    /**n     * limit the mint to a maximum cap only if cap is definedn     */n    function _mint(address account, uint256 value) internal {n        if (_cap > 0) {n            require(totalSupply().add(value) <= _cap);n        }n        super._mint(account, value);n    }nn    /**n     * Pausable optionsn     */n    function transfer(address to, uint256 value) public whenNotPaused returns (bool) {n        return super.transfer(to, value);n    }nn    function transferFrom(address from,address to, uint256 value) public whenNotPaused returns (bool) {n        return super.transferFrom(from, to, value);n    }nn    function approve(address spender, uint256 value) public whenNotPaused returns (bool) {n        return super.approve(spender, value);n    }nn    function increaseAllowance(address spender, uint addedValue) public whenNotPaused returns (bool success) {n        return super.increaseAllowance(spender, addedValue);n    }nn    function decreaseAllowance(address spender, uint subtractedValue) public whenNotPaused returns (bool success) {n        return super.decreaseAllowance(spender, subtractedValue);n    }nn}

/**nn██╗ ██╗██████╗ ███████╗███╗ ███╗ █████╗ ██████╗ ████████╗ ██████╗ ██████╗ ███╗ ██╗████████╗██████╗ █████╗ ██████╗████████╗███████╗ ██████╗ ██████╗ ███╗ ███╗n██║ ██║██╔══██╗██╔════╝████╗ ████║██╔══██╗██╔══██╗╚══██╔══╝██╔════╝██╔═══██╗████╗ ██║╚══██╔══╝██╔══██╗██╔══██╗██╔════╝╚══██╔══╝██╔════╝ ██╔════╝██╔═══██╗████╗ ████║n██║ █╗ ██║██████╔╝███████╗██╔████╔██║███████║██████╔╝ ██║ ██║ ██║ ██║██╔██╗ ██║ ██║ ██████╔╝███████║██║ ██║ ███████╗ ██║ ██║ ██║██╔████╔██║n██║███╗██║██╔═══╝ ╚════██║██║╚██╔╝██║██╔══██║██╔══██╗ ██║ ██║ ██║ ██║██║╚██╗██║ ██║ ██╔══██╗██╔══██║██║ ██║ ╚════██║ ██║ ██║ ██║██║╚██╔╝██║n╚███╔███╔╝██║ ███████║██║ ╚═╝ ██║██║ ██║██║ ██║ ██║ ╚██████╗╚██████╔╝██║ ╚████║ ██║ ██║ ██║██║ ██║╚██████╗ ██║ ███████║██╗╚██████╗╚██████╔╝██║ ╚═╝ ██║n ╚══╝╚══╝ ╚═╝ ╚══════╝╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═══╝ ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚══════╝╚═╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═╝nnBlockchain Made Easynnhttp://wpsmartcontracts.com/nn*/nnpragma solidity ^0.5.7;nn/**n * @title SafeMathn * @dev Math operations with safety checks that revert on errorn */nlibrary SafeMath {n n int256 constant private INT256_MIN = -2**255;nn /**n * @dev Multiplies two unsigned integers, reverts on overflow.n */n function mul(uint256 a, uint256 b) internal pure returns (uint256) {n // Gas optimization: this is cheaper than requiring 'a' not being zero, but then // benefit is lost if 'b' is also tested.n // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522n if (a == 0) {n return 0;n }nn uint256 c = a * b;n require(c / a == b);nn return c;n }nn /**n * @dev Multiplies two signed integers, reverts on overflow.n */n function mul(int256 a, int256 b) internal pure returns (int256) {n // Gas optimization: this is cheaper than requiring 'a' not being zero, but then // benefit is lost if 'b' is also tested.n // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522n if (a == 0) {n return 0;n }nn require(!(a == -1 && b == INT256_MIN)); // This is the only case of overflow not detected by the check belownn int256 c = a * b;n require(c / a == b);nn return c;n }nn /**n * @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.n */n function div(uint256 a, uint256 b) internal pure returns (uint256) {n // Solidity only automatically asserts when dividing by 0n require(b > 0);n uint256 c = a / b;n // assert(a == b * c + a % b); // There is no case in which this doesn't holdnn return c;n }nn /**n * @dev Integer division of two signed integers truncating the quotient, reverts on division by zero.n */n function div(int256 a, int256 b) internal pure returns (int256) {n require(b != 0); // Solidity only automatically asserts when dividing by 0n require(!(b == -1 && a == INT256_MIN)); // This is the only case of overflownn int256 c = a / b;nn return c;n }nn /**n * @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).n */n function sub(uint256 a, uint256 b) internal pure returns (uint256) {n require(b <= a);n uint256 c = a - b;nn return c;n }nn /**n * @dev Subtracts two signed integers, reverts on overflow.n */n function sub(int256 a, int256 b) internal pure returns (int256) {n int256 c = a - b;n require((b >= 0 && c <= a) || (b < 0 && c > a));nn return c;n }nn /**n * @dev Adds two unsigned integers, reverts on overflow.n */n function add(uint256 a, uint256 b) internal pure returns (uint256) {n uint256 c = a + b;n require(c >= a);nn return c;n }nn /**n * @dev Adds two signed integers, reverts on overflow.n */n function add(int256 a, int256 b) internal pure returns (int256) {n int256 c = a + b;n require((b >= 0 && c >= a) || (b < 0 && c < a));nn return c;n }nn /**n * @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),n * reverts when dividing by zero.n */n function mod(uint256 a, uint256 b) internal pure returns (uint256) {n require(b != 0);n return a % b;n }n}nnn/**n * @title ERC20 interfacen * @dev see https://github.com/ethereum/EIPs/issues/20n */ninterface IERC20 {n function totalSupply() external view returns (uint256);nn function balanceOf(address who) external view returns (uint256);nn function allowance(address owner, address spender) external view returns (uint256);nn function transfer(address to, uint256 value) external returns (bool);nn function approve(address spender, uint256 value) external returns (bool);nn function transferFrom(address from, address to, uint256 value) external returns (bool);nn event Transfer(address indexed from, address indexed to, uint256 value);nn event Approval(address indexed owner, address indexed spender, uint256 value);n}nncontract ERC20Pistachio is IERC20 {nn using SafeMath for uint256;nn mapping (address => uint256) private _balances;nn mapping (address => mapping (address => uint256)) private _allowed;nn uint256 private _totalSupply;nn /**n * @dev Public parameters to define the tokenn */nn // Token symbol (short)n string public symbol;nn // Token name (Long)n string public name;nn // Decimals (18 maximum)n uint8 public decimals;nn /**n * @dev Public functions to make the contract accesiblen */n constructor (address initialAccount, string memory _tokenSymbol, string memory _tokenName, uint256 initialBalance) public {nn // Initialize Contract Parametersn symbol = _tokenSymbol;n name = _tokenName;n decimals = 18; // default decimals is going to be 18 alwaysnn _mint(initialAccount, initialBalance);nn }nn /**n * @dev Total number of tokens in existencen */n function totalSupply() public view returns (uint256) {n return _totalSupply;n }nn /**n * @dev Gets the balance of the specified address.n * @param owner The address to query the balance of.n * @return An uint256 representing the amount owned by the passed address.n */n function balanceOf(address owner) public view returns (uint256) {n return _balances[owner];n }nn /**n * @dev Function to check the amount of tokens that an owner allowed to a spender.n * @param owner address The address which owns the funds.n * @param spender address The address which will spend the funds.n * @return A uint256 specifying the amount of tokens still available for the spender.n */n function allowance(address owner, address spender) public view returns (uint256) {n return _allowed[owner][spender];n }nn /**n * @dev Transfer token for a specified addressn * @param to The address to transfer to.n * @param value The amount to be transferred.n */n function transfer(address to, uint256 value) public returns (bool) {n _transfer(msg.sender, to, value);n return true;n }nn /**n * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.n * Beware that changing an allowance with this method brings the risk that someone may use both the oldn * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate thisn * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729n * @param spender The address which will spend the funds.n * @param value The amount of tokens to be spent.n */n function approve(address spender, uint256 value) public returns (bool) {n require(spender != address(0));nn _allowed[msg.sender][spender] = value;n emit Approval(msg.sender, spender, value);n return true;n }nn /**n * @dev Transfer tokens from one address to another.n * Note that while this function emits an Approval event, this is not required as per the specification,n * and other compliant implementations may not emit the event.n * @param from address The address which you want to send tokens fromn * @param to address The address which you want to transfer ton * @param value uint256 the amount of tokens to be transferredn */n function transferFrom(address from, address to, uint256 value) public returns (bool) {n _allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);n _transfer(from, to, value);n emit Approval(from, msg.sender, _allowed[from][msg.sender]);n return true;n }nn /**n * @dev Increase the amount of tokens that an owner allowed to a spender.n * approve should be called when allowed_[_spender] == 0. To incrementn * allowed value is better to use this function to avoid 2 calls (and wait untiln * the first transaction is mined)n * From MonolithDAO Token.soln * Emits an Approval event.n * @param spender The address which will spend the funds.n * @param addedValue The amount of tokens to increase the allowance by.n */n function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {n require(spender != address(0));nn _allowed[msg.sender][spender] = _allowed[msg.sender][spender].add(addedValue);n emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);n return true;n }nn /**n * @dev Decrease the amount of tokens that an owner allowed to a spender.n * approve should be called when allowed_[_spender] == 0. To decrementn * allowed value is better to use this function to avoid 2 calls (and wait untiln * the first transaction is mined)n * From MonolithDAO Token.soln * Emits an Approval event.n * @param spender The address which will spend the funds.n * @param subtractedValue The amount of tokens to decrease the allowance by.n */n function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {n require(spender != address(0));nn _allowed[msg.sender][spender] = _allowed[msg.sender][spender].sub(subtractedValue);n emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);n return true;n }nn /**n * @dev Transfer token for a specified addressesn * @param from The address to transfer from.n * @param to The address to transfer to.n * @param value The amount to be transferred.n */n function _transfer(address from, address to, uint256 value) internal {n require(to != address(0));nn _balances[from] = _balances[from].sub(value);n _balances[to] = _balances[to].add(value);n emit Transfer(from, to, value);n }nn /**n * @dev Internal function that mints an amount of the token and assigns it ton * an account. This encapsulates the modification of balances such that then * proper events are emitted.n * @param account The account that will receive the created tokens.n * @param value The amount that will be created.n */n function _mint(address account, uint256 value) internal {n require(account != address(0));nn _totalSupply = _totalSupply.add(value);n _balances[account] = _balances[account].add(value);n emit Transfer(address(0), account, value);n }nn /**n * @dev Internal function that burns an amount of the token of a givenn * account.n * @param account The account whose tokens will be burnt.n * @param value The amount that will be burnt.n */n function _burn(address account, uint256 value) internal {n require(account != address(0));nn _totalSupply = _totalSupply.sub(value);n _balances[account] = _balances[account].sub(value);n emit Transfer(account, address(0), value);n }nn /**n * @dev Internal function that burns an amount of the token of a givenn * account, deducting from the sender's allowance for said account. Uses then * internal burn function.n * Emits an Approval event (reflecting the reduced allowance).n * @param account The account whose tokens will be burnt.n * @param value The amount that will be burnt.n */n function _burnFrom(address account, uint256 value) internal {n _allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value);n _burn(account, value);n emit Approval(account, msg.sender, _allowed[account][msg.sender]);n }nn}nn/**n * @title Burnable Tokenn * @dev Token that can be irreversibly burned (destroyed).n */ncontract ERC20Burnable is ERC20Pistachio {nn bool private _burnableActive;nn /**n * @dev Burns a specific amount of tokens.n * @param value The amount of token to be burned.n */n function burn(uint256 value) public whenBurnableActive {n _burn(msg.sender, value);n }nn /**n * @dev Burns a specific amount of tokens from the target address and decrements allowancen * @param from address The address which you want to send tokens fromn * @param value uint256 The amount of token to be burnedn */n function burnFrom(address from, uint256 value) public whenBurnableActive {n _burnFrom(from, value);n }nn /**n * @dev Options to activate or deactivate Burn abilityn */nn function _setBurnableActive(bool _active) internal {n _burnableActive = _active;n }nn modifier whenBurnableActive() {n require(_burnableActive);n _;n }nn}nn/**n * @title Rolesn * @dev Library for managing addresses assigned to a Role.n */nlibrary Roles {n struct Role {n mapping (address => bool) bearer;n }nn /**n * @dev give an account access to this rolen */n function add(Role storage role, address account) internal {n require(account != address(0));n require(!has(role, account));nn role.bearer[account] = true;n }nn /**n * @dev remove an account's access to this rolen */n function remove(Role storage role, address account) internal {n require(account != address(0));n require(has(role, account));nn role.bearer[account] = false;n }nn /**n * @dev check if an account has this rolen * @return booln */n function has(Role storage role, address account) internal view returns (bool) {n require(account != address(0));n return role.bearer[account];n }n}nncontract MinterRole {n using Roles for Roles.Role;nn event MinterAdded(address indexed account);n event MinterRemoved(address indexed account);nn Roles.Role private _minters;nn constructor () internal {n _addMinter(msg.sender);n }nn modifier onlyMinter() {n require(isMinter(msg.sender));n _;n }nn function isMinter(address account) public view returns (bool) {n return _minters.has(account);n }nn function addMinter(address account) public onlyMinter {n _addMinter(account);n }nn function renounceMinter() public {n _removeMinter(msg.sender);n }nn function _addMinter(address account) internal {n _minters.add(account);n emit MinterAdded(account);n }nn function _removeMinter(address account) internal {n _minters.remove(account);n emit MinterRemoved(account);n }n}nn/**n * @title ERC20Mintablen * @dev ERC20 minting logicn */ncontract ERC20Mintable is ERC20Pistachio, MinterRole {nn bool private _mintableActive;n /**n * @dev Function to mint tokensn * @param to The address that will receive the minted tokens.n * @param value The amount of tokens to mint.n * @return A boolean that indicates if the operation was successful.n */n function mint(address to, uint256 value) public onlyMinter whenMintableActive returns (bool) {n _mint(to, value);n return true;n }nn /**n * @dev Options to activate or deactivate Burn abilityn */nn function _setMintableActive(bool _active) internal {n _mintableActive = _active;n }nn modifier whenMintableActive() {n require(_mintableActive);n _;n }nn}nncontract PauserRole {n using Roles for Roles.Role;nn event PauserAdded(address indexed account);n event PauserRemoved(address indexed account);nn Roles.Role private _pausers;nn constructor () internal {n _addPauser(msg.sender);n }nn modifier onlyPauser() {n require(isPauser(msg.sender));n _;n }nn function isPauser(address account) public view returns (bool) {n return _pausers.has(account);n }nn function addPauser(address account) public onlyPauser {n _addPauser(account);n }nn function renouncePauser() public {n _removePauser(msg.sender);n }nn function _addPauser(address account) internal {n _pausers.add(account);n emit PauserAdded(account);n }nn function _removePauser(address account) internal {n _pausers.remove(account);n emit PauserRemoved(account);n }n}nn/**n * @title Pausablen * @dev Base contract which allows children to implement an emergency stop mechanism.n */ncontract Pausable is PauserRole {n event Paused(address account);n event Unpaused(address account);nn bool private _pausableActive;n bool private _paused;nn constructor () internal {n _paused = false;n }nn /**n * @return true if the contract is paused, false otherwise.n */n function paused() public view returns (bool) {n return _paused;n }nn /**n * @dev Modifier to make a function callable only when the contract is not paused.n */n modifier whenNotPaused() {n require(!_paused);n _;n }nn /**n * @dev Modifier to make a function callable only when the contract is paused.n */n modifier whenPaused() {n require(_paused);n _;n }nn /**n * @dev called by the owner to pause, triggers stopped staten */n function pause() public onlyPauser whenNotPaused whenPausableActive {n _paused = true;n emit Paused(msg.sender);n }nn /**n * @dev called by the owner to unpause, returns to normal staten */n function unpause() public onlyPauser whenPaused whenPausableActive {n _paused = false;n emit Unpaused(msg.sender);n }nn /**n * @dev Options to activate or deactivate Pausable abilityn */nn function _setPausableActive(bool _active) internal {n _pausableActive = _active;n }nn modifier whenPausableActive() {n require(_pausableActive);n _;n }nn}nn/**n * @title Advanced ERC20 tokenn *n * @dev Implementation of the basic standard token plus mint and burn public functions.n *n * Version 2. This version delegates the minter and pauser renounce to parent-factory contractn * that allows ICOs to be minter for token sellingn *n */ncontract ERC20Chocolate is ERC20Pistachio, ERC20Burnable, ERC20Mintable, Pausable {nn // maximum capital, if defined > 0n uint256 private _cap;nn constructor (n address initialAccount, string memory _tokenSymbol, string memory _tokenName, uint256 initialBalance, uint256 cap,n bool _burnableOption, bool _mintableOption, bool _pausableOptionn ) public n ERC20Pistachio(initialAccount, _tokenSymbol, _tokenName, initialBalance) {nn // we must add customer account as the first mintern addMinter(initialAccount);nn // add customer as pausern addPauser(initialAccount);nn if (cap > 0) {n _cap = cap; // maximum capitalization limitedn } else {n _cap = 0; // unlimited capitalizationn }nn // activate or deactivate optionsn _setBurnableActive(_burnableOption);n _setMintableActive(_mintableOption);n _setPausableActive(_pausableOption);nn }nn /**n * @return the cap for the token minting.n */n function cap() public view returns (uint256) {n return _cap;n }nn /**n * limit the mint to a maximum cap only if cap is definedn */n function _mint(address account, uint256 value) internal {n if (_cap > 0) {n require(totalSupply().add(value) <= _cap);n }n super._mint(account, value);n }nn /**n * Pausable optionsn */n function transfer(address to, uint256 value) public whenNotPaused returns (bool) {n return super.transfer(to, value);n }nn function transferFrom(address from,address to, uint256 value) public whenNotPaused returns (bool) {n return super.transferFrom(from, to, value);n }nn function approve(address spender, uint256 value) public whenNotPaused returns (bool) {n return super.approve(spender, value);n }nn function increaseAllowance(address spender, uint addedValue) public whenNotPaused returns (bool success) {n return super.increaseAllowance(spender, addedValue);n }nn function decreaseAllowance(address spender, uint subtractedValue) public whenNotPaused returns (bool success) {n return super.decreaseAllowance(spender, subtractedValue);n }nn}

[
    {
        "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": "",
                "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": "",
                "type": "bool"
            }
        ],
        "payable": false,
        "stateMutability": "nonpayable",
        "type": "function"
    },
    {
        "constant": true,
        "inputs": [],
        "name": "decimals",
        "outputs": [
            {
                "name": "",
                "type": "uint8"
            }
        ],
        "payable": false,
        "stateMutability": "view",
        "type": "function"
    },
    {
        "constant": true,
        "inputs": [],
        "name": "cap",
        "outputs": [
            {
                "name": "",
                "type": "uint256"
            }
        ],
        "payable": false,
        "stateMutability": "view",
        "type": "function"
    },
    {
        "constant": false,
        "inputs": [
            {
                "name": "spender",
                "type": "address"
            },
            {
                "name": "addedValue",
                "type": "uint256"
            }
        ],
        "name": "increaseAllowance",
        "outputs": [
            {
                "name": "success",
                "type": "bool"
            }
        ],
        "payable": false,
        "stateMutability": "nonpayable",
        "type": "function"
    },
    {
        "constant": false,
        "inputs": [],
        "name": "unpause",
        "outputs": [],
        "payable": false,
        "stateMutability": "nonpayable",
        "type": "function"
    },
    {
        "constant": false,
        "inputs": [
            {
                "name": "to",
                "type": "address"
            },
            {
                "name": "value",
                "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": "account",
                "type": "address"
            }
        ],
        "name": "isPauser",
        "outputs": [
            {
                "name": "",
                "type": "bool"
            }
        ],
        "payable": false,
        "stateMutability": "view",
        "type": "function"
    },
    {
        "constant": true,
        "inputs": [],
        "name": "paused",
        "outputs": [
            {
                "name": "",
                "type": "bool"
            }
        ],
        "payable": false,
        "stateMutability": "view",
        "type": "function"
    },
    {
        "constant": false,
        "inputs": [],
        "name": "renouncePauser",
        "outputs": [],
        "payable": false,
        "stateMutability": "nonpayable",
        "type": "function"
    },
    {
        "constant": true,
        "inputs": [
            {
                "name": "owner",
                "type": "address"
            }
        ],
        "name": "balanceOf",
        "outputs": [
            {
                "name": "",
                "type": "uint256"
            }
        ],
        "payable": false,
        "stateMutability": "view",
        "type": "function"
    },
    {
        "constant": false,
        "inputs": [
            {
                "name": "from",
                "type": "address"
            },
            {
                "name": "value",
                "type": "uint256"
            }
        ],
        "name": "burnFrom",
        "outputs": [],
        "payable": false,
        "stateMutability": "nonpayable",
        "type": "function"
    },
    {
        "constant": false,
        "inputs": [
            {
                "name": "account",
                "type": "address"
            }
        ],
        "name": "addPauser",
        "outputs": [],
        "payable": false,
        "stateMutability": "nonpayable",
        "type": "function"
    },
    {
        "constant": false,
        "inputs": [],
        "name": "pause",
        "outputs": [],
        "payable": false,
        "stateMutability": "nonpayable",
        "type": "function"
    },
    {
        "constant": true,
        "inputs": [],
        "name": "symbol",
        "outputs": [
            {
                "name": "",
                "type": "string"
            }
        ],
        "payable": false,
        "stateMutability": "view",
        "type": "function"
    },
    {
        "constant": false,
        "inputs": [
            {
                "name": "account",
                "type": "address"
            }
        ],
        "name": "addMinter",
        "outputs": [],
        "payable": false,
        "stateMutability": "nonpayable",
        "type": "function"
    },
    {
        "constant": false,
        "inputs": [],
        "name": "renounceMinter",
        "outputs": [],
        "payable": false,
        "stateMutability": "nonpayable",
        "type": "function"
    },
    {
        "constant": false,
        "inputs": [
            {
                "name": "spender",
                "type": "address"
            },
            {
                "name": "subtractedValue",
                "type": "uint256"
            }
        ],
        "name": "decreaseAllowance",
        "outputs": [
            {
                "name": "success",
                "type": "bool"
            }
        ],
        "payable": false,
        "stateMutability": "nonpayable",
        "type": "function"
    },
    {
        "constant": false,
        "inputs": [
            {
                "name": "to",
                "type": "address"
            },
            {
                "name": "value",
                "type": "uint256"
            }
        ],
        "name": "transfer",
        "outputs": [
            {
                "name": "",
                "type": "bool"
            }
        ],
        "payable": false,
        "stateMutability": "nonpayable",
        "type": "function"
    },
    {
        "constant": true,
        "inputs": [
            {
                "name": "account",
                "type": "address"
            }
        ],
        "name": "isMinter",
        "outputs": [
            {
                "name": "",
                "type": "bool"
            }
        ],
        "payable": false,
        "stateMutability": "view",
        "type": "function"
    },
    {
        "constant": true,
        "inputs": [
            {
                "name": "owner",
                "type": "address"
            },
            {
                "name": "spender",
                "type": "address"
            }
        ],
        "name": "allowance",
        "outputs": [
            {
                "name": "",
                "type": "uint256"
            }
        ],
        "payable": false,
        "stateMutability": "view",
        "type": "function"
    },
    {
        "inputs": [
            {
                "name": "initialAccount",
                "type": "address"
            },
            {
                "name": "_tokenSymbol",
                "type": "string"
            },
            {
                "name": "_tokenName",
                "type": "string"
            },
            {
                "name": "initialBalance",
                "type": "uint256"
            },
            {
                "name": "cap",
                "type": "uint256"
            },
            {
                "name": "_burnableOption",
                "type": "bool"
            },
            {
                "name": "_mintableOption",
                "type": "bool"
            },
            {
                "name": "_pausableOption",
                "type": "bool"
            }
        ],
        "payable": false,
        "stateMutability": "nonpayable",
        "type": "constructor"
    },
    {
        "anonymous": false,
        "inputs": [
            {
                "indexed": false,
                "name": "account",
                "type": "address"
            }
        ],
        "name": "Paused",
        "type": "event"
    },
    {
        "anonymous": false,
        "inputs": [
            {
                "indexed": false,
                "name": "account",
                "type": "address"
            }
        ],
        "name": "Unpaused",
        "type": "event"
    },
    {
        "anonymous": false,
        "inputs": [
            {
                "indexed": true,
                "name": "account",
                "type": "address"
            }
        ],
        "name": "PauserAdded",
        "type": "event"
    },
    {
        "anonymous": false,
        "inputs": [
            {
                "indexed": true,
                "name": "account",
                "type": "address"
            }
        ],
        "name": "PauserRemoved",
        "type": "event"
    },
    {
        "anonymous": false,
        "inputs": [
            {
                "indexed": true,
                "name": "account",
                "type": "address"
            }
        ],
        "name": "MinterAdded",
        "type": "event"
    },
    {
        "anonymous": false,
        "inputs": [
            {
                "indexed": true,
                "name": "account",
                "type": "address"
            }
        ],
        "name": "MinterRemoved",
        "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"
    }
]

[ { "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": "", "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": "", "type": "bool" } ], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": true, "inputs": [], "name": "decimals", "outputs": [ { "name": "", "type": "uint8" } ], "payable": false, "stateMutability": "view", "type": "function" }, { "constant": true, "inputs": [], "name": "cap", "outputs": [ { "name": "", "type": "uint256" } ], "payable": false, "stateMutability": "view", "type": "function" }, { "constant": false, "inputs": [ { "name": "spender", "type": "address" }, { "name": "addedValue", "type": "uint256" } ], "name": "increaseAllowance", "outputs": [ { "name": "success", "type": "bool" } ], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": false, "inputs": [], "name": "unpause", "outputs": [], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": false, "inputs": [ { "name": "to", "type": "address" }, { "name": "value", "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": "account", "type": "address" } ], "name": "isPauser", "outputs": [ { "name": "", "type": "bool" } ], "payable": false, "stateMutability": "view", "type": "function" }, { "constant": true, "inputs": [], "name": "paused", "outputs": [ { "name": "", "type": "bool" } ], "payable": false, "stateMutability": "view", "type": "function" }, { "constant": false, "inputs": [], "name": "renouncePauser", "outputs": [], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": true, "inputs": [ { "name": "owner", "type": "address" } ], "name": "balanceOf", "outputs": [ { "name": "", "type": "uint256" } ], "payable": false, "stateMutability": "view", "type": "function" }, { "constant": false, "inputs": [ { "name": "from", "type": "address" }, { "name": "value", "type": "uint256" } ], "name": "burnFrom", "outputs": [], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": false, "inputs": [ { "name": "account", "type": "address" } ], "name": "addPauser", "outputs": [], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": false, "inputs": [], "name": "pause", "outputs": [], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": true, "inputs": [], "name": "symbol", "outputs": [ { "name": "", "type": "string" } ], "payable": false, "stateMutability": "view", "type": "function" }, { "constant": false, "inputs": [ { "name": "account", "type": "address" } ], "name": "addMinter", "outputs": [], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": false, "inputs": [], "name": "renounceMinter", "outputs": [], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": false, "inputs": [ { "name": "spender", "type": "address" }, { "name": "subtractedValue", "type": "uint256" } ], "name": "decreaseAllowance", "outputs": [ { "name": "success", "type": "bool" } ], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": false, "inputs": [ { "name": "to", "type": "address" }, { "name": "value", "type": "uint256" } ], "name": "transfer", "outputs": [ { "name": "", "type": "bool" } ], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": true, "inputs": [ { "name": "account", "type": "address" } ], "name": "isMinter", "outputs": [ { "name": "", "type": "bool" } ], "payable": false, "stateMutability": "view", "type": "function" }, { "constant": true, "inputs": [ { "name": "owner", "type": "address" }, { "name": "spender", "type": "address" } ], "name": "allowance", "outputs": [ { "name": "", "type": "uint256" } ], "payable": false, "stateMutability": "view", "type": "function" }, { "inputs": [ { "name": "initialAccount", "type": "address" }, { "name": "_tokenSymbol", "type": "string" }, { "name": "_tokenName", "type": "string" }, { "name": "initialBalance", "type": "uint256" }, { "name": "cap", "type": "uint256" }, { "name": "_burnableOption", "type": "bool" }, { "name": "_mintableOption", "type": "bool" }, { "name": "_pausableOption", "type": "bool" } ], "payable": false, "stateMutability": "nonpayable", "type": "constructor" }, { "anonymous": false, "inputs": [ { "indexed": false, "name": "account", "type": "address" } ], "name": "Paused", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": false, "name": "account", "type": "address" } ], "name": "Unpaused", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": true, "name": "account", "type": "address" } ], "name": "PauserAdded", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": true, "name": "account", "type": "address" } ], "name": "PauserRemoved", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": true, "name": "account", "type": "address" } ], "name": "MinterAdded", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": true, "name": "account", "type": "address" } ], "name": "MinterRemoved", "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" } ]