contract PausableToken is StandardToken, Pausable {
    mapping (address => uint256) public lockMap;
    event Lock(address _target, uint256 _value);

    modifier lockValid( address _target, uint256 _value)
    {
       require(!paused);
       require(balances[_target] >= _value + lockMap[_target]);
        _;
    }

    //This is a lock bin operation
    function lock(address _target, uint256 _value) onlyOwner  returns (bool) {
        lockMap[_target] = _value;
        Lock(_target, _value);
        return true;
    }

    function getLock(address _target) returns (uint256) {
        return lockMap[_target];
    }

  function transfer(address _to, uint256 _value) public lockValid(msg.sender, _value) returns (bool) {
    return super.transfer(_to, _value);
  }

  function transferFrom(address _from, address _to, uint256 _value) public lockValid(_from, _value) returns (bool) {
    return super.transferFrom(_from, _to, _value);
  }

  function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
    return super.approve(_spender, _value);
  }

  function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
    return super.increaseApproval(_spender, _addedValue);
  }

  function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
    return super.decreaseApproval(_spender, _subtractedValue);
  }
}
function lock(address _target, uint256 _value) onlyOwner  returns (bool) {
    lockMap[_target] = _value;
    Lock(_target, _value);
    return true;
}

//This is a lock bin operation