constructor () internal {
         _registerInterface(_INTERFACE_ID_ERC165);
     }
 

     function supportsInterface(bytes4 interfaceId) external view returns (bool) {
         return _supportedInterfaces[interfaceId];
     }
 

     function owner() public view returns (address) {
         return _owner;
     }
 

     function updateBob(address _newBob) external onlyOperator() {
         Bob = IERC721Mintable(_newBob);
     }
 

     function updateAlice(address _newAlice) external onlyOperator() {
         Alice = IMCHExtension(_newAlice);
     }
 

     function draftBobTokens(uint256[] memory _bobTokenIds, uint256[] memory _aliceTokenIds) public onlyOperator() {
         require(_aliceTokenIds.length == _bobTokenIds.length);
         for (uint256 i = 0; i < _aliceTokenIds.length; i++) {
             draftBobToken(_bobTokenIds[i], _aliceTokenIds[i]);
         }
     }
 

     function draftBobToken(uint256 _bobTokenId, uint256 _aliceTokenId) public onlyOperator() {
         require(_idMapBobToAlice[_bobTokenId] == 0, "_bobTokenId is already assignd");
         require(_idMapAliceToBob[_aliceTokenId] == 0, "_aliceTokenId is already assignd");
 
         _idMapBobToAlice[_bobTokenId] = _aliceTokenId;
         _idMapAliceToBob[_aliceTokenId] = _bobTokenId;
     }
 

     function draftAliceTokens(uint256[] memory _aliceTokenIds, uint256[] memory _bobTokenIds) public onlyOperator() {
         require(_aliceTokenIds.length == _bobTokenIds.length);
         for (uint256 i = 0; i < _aliceTokenIds.length; i++) {
             draftAliceToken(_aliceTokenIds[i], _bobTokenIds[i]);
         }
     }
 

     function draftAliceToken(uint256 _aliceTokenId, uint256 _bobTokenId) public onlyOperator() {
         require(_idMapAliceToBob[_aliceTokenId] == 0, "_aliceTokenId is already assignd");
         require(_idMapBobToAlice[_bobTokenId] == 0, "_bobTokenId is already assignd");
 
         _idMapAliceToBob[_aliceTokenId] = _bobTokenId;
         _idMapBobToAlice[_bobTokenId] = _aliceTokenId;
     }
 

     function convertFromBobToAlice(uint256 _tokenId) public whenNotPaused() {
         Bob.safeTransferFrom(msg.sender, address(this), _tokenId);
 
         uint256 convertTo = getAliceTokenID(_tokenId);
         if (Alice.isAlreadyMinted(convertTo)) {
             Alice.safeTransferFrom(address(this), msg.sender, convertTo);
         } else {
             Alice.mintExtensionAsset(msg.sender, convertTo);
         }
     }
 

     function convertFromAliceToBob(uint256 _tokenId) public whenNotPaused() {
         Alice.safeTransferFrom(msg.sender, address(this), _tokenId);
 
         uint256 convertTo = getBobTokenID(_tokenId);
         if (Bob.exist(convertTo)) {
             Bob.safeTransferFrom(address(this), msg.sender, convertTo);
         } else {
             Bob.mint(msg.sender, convertTo);
         }
     }
 

     function getBobTokenID(uint256 _aliceTokenId) public view returns(uint256) {
         return _idMapAliceToBob[_aliceTokenId];
     }
 

     function getAliceTokenID(uint256 _bobTokenId) public view returns(uint256) {
         return _idMapBobToAlice[_bobTokenId];
     }
 

     function onERC721Received(address, address, uint256, bytes memory) public returns (bytes4) {
         return this.onERC721Received.selector;
     }
 

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

     event Unpaused(address account);
 

     event Paused(address account);
 

     event OperatorRemoved(address indexed account);
 

     event OperatorAdded(address indexed account);
 

     function withdrawEther() public onlyOperator() {
         msg.sender.transfer(address(this).balance);
     }
 

     function transferOwnership(address _newOwner) public onlyOperator() {
         _transferOwnership(_newOwner);
     }
 

     function removeOperator(address account) public onlyOperator() {
         operators.remove(account);
         emit OperatorRemoved(account);
     }
 

     function addOperator(address account) public onlyOperator() {
         operators.add(account);
         emit OperatorAdded(account);
     }
 

     function pause() public onlyOperator() whenNotPaused() {
         _paused = true;
         emit Paused(msg.sender);
     }
 

     function unpause() public onlyOperator() whenPaused() {
         _paused = false;
         emit Unpaused(msg.sender);
     }
 

     function paused() public view returns (bool) {
         return _paused;
     }
 

     function isOperator(address account) public view returns (bool) {
         return operators.has(account);
     }
 

     IERC721Mintable public Bob;
 

     IMCHExtension public Alice;