contract Ownable {
     address public owner;
     address public pendingOwner;
     address public manager;

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

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

     /**
      * @dev Modifier throws if called by any account other than the manager.
      */
     modifier onlyManager() {
         require(msg.sender == manager);
         _;
     }

     /**
      * @dev Modifier throws if called by any account other than the pendingOwner.
      */
     modifier onlyPendingOwner() {
         require(msg.sender == pendingOwner);
         _;
     }

     constructor() public {
         owner = msg.sender;
     }

     /**
      * @dev Allows the current owner to set the pendingOwner address.
      * @param newOwner The address to transfer ownership to.
      */
     function transferOwnership(address newOwner) public onlyOwner {
         pendingOwner = newOwner;
     }

     /**
      * @dev Allows the pendingOwner address to finalize the transfer.
      */
     function claimOwnership() public onlyPendingOwner {
         emit OwnershipTransferred(owner, pendingOwner);
         owner = pendingOwner;
         pendingOwner = address(0);
     }

     /**
      * @dev Sets the manager address.
      * @param _manager The manager address.
      */
     function setManager(address _manager) public onlyOwner {
         require(_manager != address(0));
         manager = _manager;
     }

 }
/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
function transferOwnership(address newOwner) public onlyOwner {
         pendingOwner = newOwner;
     }
/**
 * @dev Allows the current owner to set the pendingOwner address.
 * @param newOwner The address to transfer ownership to.
 */