contract Ownable {
    address[2] internal _owners;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor(address[2] memory owners) internal {
        _owners = owners;
        emit OwnershipTransferred(address(0), owners[0]);
        emit OwnershipTransferred(address(0), owners[1]);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view returns (address[2] memory) {
        return _owners;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(isOwner(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Returns true if the caller is the current owner.
     */
    function isOwner() public view returns (bool) {
        return msg.sender == _owners[0] || msg.sender == _owners[1];
    }


}
/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
function isOwner() public view returns (bool) {
    return msg.sender == _owners[0] || msg.sender == _owners[1];
}

/**
 * @dev Returns true if the caller is the current owner.
 */