task stringclasses 6
values | input stringlengths 51 7.82k | expected_output stringlengths 16 315 | KIND stringclasses 6
values |
|---|---|---|---|
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "g8f6", "c2c4", "c7c5", "d4d5", "e7e6", "b1c3", "e6d5", "c4d5", "d7d6", "e2e4", "g7g6", "f1b5", "c8d7", "b5d3", "f8g7", "g1f3", "e8g8", "e1g1", "d7g4", "h2h3", "g4f3", "d1f3", "f8e8", "c1f4", "a7a6", "a2a4", "d8c7", "f3e2", "b8d7", "g1h1", "d7e5", "d3c2", "f6d7", "f4d2", "c5c4", "f2f4", "e5d3", "c2d3... | {"missing move": "d3c3"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "g8f6", "g1f3", "e7e6", "c2c4", "b7b6", "b1c3", "c8b7", "c1g5", "f8b4", "e2e3", "b4c3", "b2c3", "h7h6", "g5h4", "d7d6", "a2a4", "g7g5", "h4g3", "f6e4", "a4a5", "h6h5", "h2h4", "g5g4", "f3d2", "e4g3", "f2g3", "d8f6", "a5a6", "b7c6", "d1c2", "e8g8", "e3e4", "f6h6", "f1e2", "f7f5", "d4d5", "c6e8", "d5e6... | {"missing move": "f5h5"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["c2c4", "e7e6", "g1f3", "g8f6", "g2g3", "d7d5", "f1g2", "c7c6", "d1c2", "b8d7", "d2d4", "b7b6", "e1g1", "c8a6", "b1d2", "a8c8", "f1e1", "f8e7", "b2b3", "e8g8", "e2e4", "d5e4", "d2e4", "c6c5", "e4c3", "f8e8", "c1b2", "d8c7", "d4d5", "e6d5", "f3g5", "d5d4", "g2d5", "d7e5", "f2f4", "e5f3", "d5f3", "d4c3", "b2c3... | {"missing move": "b2e2"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "c7c5", "g1f3", "d7d6", "d2d4", "c5d4", "f3d4", "g8f6", "b1c3", "a7a6", "c1e3", "g7g6", "f2f3", "d8b6", "b2b3", "b6a5", "d1d2", "f8g7", "a1d1", "e8g8", "c3a4", "a5c7", "c2c4", "c8d7", "a4c3", "b8c6", "f1e2", "c6d4", "e3d4", "d7c6", "h2h3", "f8b8", "a2a4", "f6h5", "d4g7", "g8g7", "e1g1", "c7b6", "g1h2... | {"missing move": "g5h4"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "d7d5", "c2c4", "c7c6", "c4d5", "c6d5", "b1c3", "g8f6", "c1f4", "b8c6", "e2e3", "a7a6", "g1f3", "e7e6", "h2h3", "f8d6", "f4d6", "d8d6", "f1d3", "c8d7", "e1g1", "e8g8", "d1d2", "f8c8", "f1e1", "d7e8", "a1c1", "h7h6", "e1d1", "d6d8", "d2e1", "d8b6", "c3a4", "b6b4", "a4c5", "b7b6", "c5a6", "b4b2", "c1c3... | {"missing move": "g2g1"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "c7c5", "g1f3", "b8c6", "f1b5", "g7g6", "e1g1", "f8g7", "f1e1", "e7e5", "c2c3", "g8e7", "d2d4", "c5d4", "c3d4", "c6d4", "f3d4", "e5d4", "c1f4", "e8g8", "f4d6", "f8e8", "a2a4", "e7c6", "b5c4", "d8f6", "d6g3", "d7d6", "b1d2", "c6e5", "h2h3", "h7h5", "c4b5", "h5h4", "g3h2", "e5c6", "a4a5", "c8h3", "d1f3... | {"missing move": "a7c7"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "g8f6", "c2c4", "e7e6", "b1c3", "f8b4", "e2e3", "b4c3", "b2c3", "e8g8", "f1d3", "d7d5", "c4d5", "e6d5", "g1e2", "c7c5", "e1g1", "f8e8", "c3c4", "c5d4", "e2d4", "c8g4", "f2f3", "g4h5", "a1b1", "b8c6", "c4c5", "c6a5", "d4b5", "b7b6", "b5d6", "e8e7", "c1b2", "e7e3", "g2g4", "h5g6", "b2f6", "d8f6", "d3g6... | {"missing move": "d6d8"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "c7c5", "g1f3", "d7d6", "d2d4", "c5d4", "f3d4", "g8f6", "b1c3", "c8d7", "c1g5", "b8c6", "d1d2", "a7a6", "d4f5", "f6e4", "f5g7", "f8g7", "c3e4", "d8b6", "c2c3", "e8c8", "g5e3", "b6c7", "f1e2", "c6e5", "e1g1", "d7c6", "e4g3", "h7h5", "g3h5", "d8g8", "h5g3", "c7d7", "a2a4", "c6g2", "d2c2", "g2f3", "f1d1... | {"missing move": "f1h1"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "e7e6", "d2d4", "d7d5", "b1d2", "c7c5", "g1f3", "c5d4", "f3d4", "g8f6", "e4d5", "f6d5", "c2c3", "f8e7", "f1c4", "d8c7", "e1g1", "e8g8", "c4d5", "e6d5", "f1e1", "b8c6", "d2b3", "e7d6", "g2g3", "a7a6", "d1f3", "c8d7", "c1f4", "h7h6", "b3c5", "d6f4", "f3f4", "c7f4", "g3f4", "c6d4", "c3d4", "d7c6", "g1g2... | {"missing move": "b3b2"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "e7e5", "g1f3", "b8c6", "f1b5", "a7a6", "b5a4", "g8f6", "e1g1", "f8e7", "f1e1", "b7b5", "a4b3", "e8g8", "d2d4", "c6d4", "f3d4", "e5d4", "e4e5", "f6e8", "c2c3", "c7c5", "b3d5", "a8b8", "c3d4", "c5c4", "b2b3", "d7d6", "b3c4", "d6e5", "d4e5", "e8c7", "b1c3", "b5c4", "d5c4", "e7b4", "c1d2", "c8e6", "c4f1... | {"missing move": "f6f7"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "c7c5", "g1f3", "b8c6", "d2d4", "c5d4", "f3d4", "e7e5", "d4b5", "d7d6", "b5c3", "g8f6", "c1g5", "f8e7", "b1d2", "e8g8", "a2a3", "f6e4", "d2e4", "e7g5", "d1d6", "g5f4", "d6d8", "f8d8", "f1d3", "f7f5", "e4c5", "b7b6", "d3c4", "g8f8", "c5d3", "c6d4", "e1g1", "c8b7", "d3f4", "e5f4", "c4d3", "f4f3", "g2g3... | {"missing move": "b5a3"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "g8f6", "c2c4", "e7e6", "g1f3", "f8b4", "b1d2", "d7d5", "d1a4", "b8c6", "a2a3", "b4d2", "c1d2", "e8g8", "e2e3", "f6e4", "a1d1", "e4d6", "c4c5", "d6e4", "a4c2", "d8f6", "d2c1", "f6g6", "f3g1", "e6e5", "f2f3", "e4f6", "c2g6", "h7g6", "g1e2", "e5e4", "h2h4", "c6e7", "c1d2", "c8d7", "e2c3", "b7b6", "b2b4... | {"missing move": "d1h1"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["b2b4", "g8f6", "c1b2", "e7e6", "b4b5", "b7b6", "g1f3", "c7c5", "e2e3", "c8b7", "f1e2", "d7d5", "c2c4", "h7h6", "d1c2", "b8d7", "a2a4", "f8d6", "d2d3", "a7a5", "b1d2", "d8e7", "e1g1", "a8c8", "f1e1", "e6e5", "c4d5", "f6d5", "e3e4", "d5b4", "c2c3", "e8g8", "d2c4", "c8d8", "f3h4", "e7h4", "c4d6", "b7c8", "a1d1... | {"missing move": "b7h7"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "d7d5", "c2c4", "e7e6", "b1c3", "g8f6", "g1f3", "f8b4", "c1g5", "h7h6", "g5f6", "d8f6", "d1a4", "b8c6", "e2e3", "e8g8", "a4b3", "a7a5", "a2a3", "a5a4", "b3c2", "b4c3", "b2c3", "b7b6", "c4d5", "e6d5", "f1d3", "c6a5", "c2a4", "c8f5", "d3f5", "f6f5", "e1g1", "a5c4", "a4b3", "a8a5", "a1a2", "f8a8", "f1a1... | {"missing move": "g7g6"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "d7d5", "c2c4", "c7c6", "b1c3", "g8f6", "g1f3", "d5c4", "a2a4", "e7e6", "e2e3", "c6c5", "f1c4", "f8e7", "d1e2", "c5d4", "e3d4", "b8c6", "e1g1", "a7a6", "f1d1", "f6d5", "h2h3", "c6b4", "f3e5", "e8g8", "c4b3", "c8d7", "c1h6", "g7h6", "e2g4", "g8h8", "g4h5", "d7e8", "h5f3", "f7f6", "e5d3", "b4d3", "d1d3... | {"missing move": "c4g4"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["c2c4", "e7e5", "b1c3", "g8f6", "d2d3", "b8c6", "g2g3", "f8b4", "f1g2", "e8g8", "a2a3", "b4c3", "b2c3", "e5e4", "c1g5", "e4d3", "e2d3", "d7d6", "h2h3", "h7h6", "g5f6", "f8e8", "g1e2", "d8f6", "e1g1", "c8f5", "a1b1", "a8b8", "d1d2", "c6e5", "e2f4", "c7c6", "b1e1", "e5d7", "f4h5", "f6g5", "h5f4", "f5h7", "e1e8... | {"missing move": "e7f7"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "g8f6", "g1f3", "c7c5", "d4d5", "b7b5", "c1g5", "d8a5", "c2c3", "c5c4", "g5f6", "e7f6", "b1d2", "b8a6", "a2a4", "a6c5", "a4b5", "a5b5", "a1a2", "a7a5", "e2e4", "b5b8", "f1c4", "a5a4", "d1e2", "f8d6", "e1g1", "c8b7", "c4b5", "e8g8", "f1a1", "f6f5", "e4e5", "b7d5", "e5d6", "d5a2", "a1a2", "b8d6", "d2c4... | {"missing move": "f5g4"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "e7e6", "d2d4", "d7d5", "b1c3", "f8b4", "d1g4", "g8f6", "g4g7", "h8g8", "g7h6", "g8g6", "h6h4", "g6g4", "h4h6", "g4g6", "h6h4", "g6g4", "h4h6", "c7c5", "e4e5", "c5d4", "a2a3", "b4f8", "h6f6", "d8f6", "e5f6", "d4c3", "b2c3", "b8d7", "g2g3", "g4g8", "c3c4", "d5c4", "c1b2", "b7b5", "f1g2", "a8b8", "g1f3... | {"missing move": "c7e5"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["c2c4", "g8f6", "b1c3", "e7e6", "e2e4", "d7d5", "e4e5", "d5d4", "e5f6", "d4c3", "b2c3", "d8f6", "d2d4", "b7b6", "f1e2", "b8d7", "e2f3", "a8b8", "d1a4", "f8d6", "f3c6", "a7a6", "g1f3", "e8g8", "e1g1", "b6b5", "c4b5", "a6b5", "c6b5", "d7b6", "a4c2", "h7h6", "b5c6", "c8a6", "f1e1", "a6b7", "c6b7", "b8b7", "a1b1... | {"missing move": "g6h5"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "e7e5", "g1f3", "b8c6", "d2d4", "e5d4", "c2c3", "d4c3", "b1c3", "f8b4", "f1d3", "d7d6", "e1g1", "b4c3", "b2c3", "g8f6", "f3d4", "c6e5", "d3c2", "e8g8", "c1e3", "f8e8", "a2a4", "d6d5", "e4d5", "f6d5", "f1e1", "c7c5", "d4f5", "c8f5", "c2f5", "g7g6", "f5c2", "d5e3", "e1e3", "d8d1", "a1d1", "e5g4", "e3e8... | {"missing move": "h6h1"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "c7c5", "c2c3", "g8f6", "e4e5", "f6d5", "d2d4", "c5d4", "g1f3", "b8c6", "f1c4", "d5b6", "c4b3", "d7d6", "e5d6", "d8d6", "e1g1", "c8e6", "b3e6", "d6e6", "f3d4", "c6d4", "d1d4", "a8d8", "d4e3", "e6e3", "c1e3", "b6c4", "e3a7", "c4b2", "a2a4", "e7e5", "a4a5", "b2c4", "a1a4", "d8c8", "f2f4", "f8c5", "a7c5... | {"missing move": "f5g5"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "g8f6", "e4e5", "f6d5", "c2c4", "d5b6", "d2d4", "d7d6", "f2f4", "c8f5", "g1f3", "d6e5", "f4e5", "e7e6", "b1c3", "f8b4", "f1d3", "f5d3", "d1d3", "b8c6", "e1g1", "d8d7", "c1g5", "b4e7", "a1d1", "e8c8", "d3e2", "e7g5", "f3g5", "c6d4", "e2e4", "f7f5", "e5f6", "g7f6", "g5e6", "f6f5", "e4d4", "d7e6", "c3d5... | {"missing move": "a6a5"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "d7d5", "c2c4", "e7e6", "b1c3", "g8f6", "c1g5", "d5c4", "e2e3", "f8e7", "f1c4", "c7c5", "d4c5", "e8g8", "d1e2", "f6d7", "g5f4", "d8a5", "g1f3", "b8c6", "a1c1", "a7a6", "f3d4", "a5c5", "d4c6", "c5c6", "e1g1", "b7b5", "c4d3", "c8b7", "c3e4", "c6b6", "f4c7", "b6a7", "c1c2", "d7f6", "e4d6", "b7d5", "b2b3... | {"missing move": "a2a1"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "e7e5", "g1f3", "b8c6", "b1c3", "f8c5", "c3a4", "c5e7", "d2d4", "e5d4", "f3d4", "g8f6", "d4c6", "b7c6", "e4e5", "f6d5", "c2c4", "d5b6", "f1d3", "e8g8", "e1g1", "d7d6", "e5d6", "e7d6", "c4c5", "b6a4", "c5d6", "a4c5", "d3h7", "g8h7", "d1c2", "h7g8", "c2c5", "d8d6", "c5c3", "c8e6", "c1e3", "f8d8", "h2h3... | {"missing move": "a1b2"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "g8f6", "c2c4", "e7e6", "b1c3", "f8b4", "g1f3", "c7c5", "d4c5", "b8c6", "d1c2", "b4c5", "c1f4", "e6e5", "f4g5", "h7h6", "g5f6", "d8f6", "a2a3", "c6d4", "f3d4", "c5d4", "c3e4", "f6c6", "e2e3", "d7d5", "e3d4", "d5e4", "d4d5", "c6g6", "f2f3", "e4f3", "c2g6", "f7g6", "g2f3", "h8f8", "f1e2", "f8f4", "c4c5... | {"missing move": "g2g6"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "g8f6", "g1f3", "d7d5", "c1f4", "c7c6", "e2e3", "g7g6", "c2c4", "f8g7", "b1c3", "e8g8", "d1b3", "d5c4", "f1c4", "b7b5", "c4e2", "a7a5", "b3c2", "d8b6", "h2h3", "c8b7", "e1g1", "c6c5", "a1c1", "b8a6", "e2b5", "b7f3", "d4c5", "a6c5", "g2f3", "f6h5", "f4c7", "b6b7", "c3d5", "b7d5", "c2c5", "d5c5", "c1c5... | {"missing move": "a3b2"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "c7c5", "g1f3", "e7e6", "d2d4", "c5d4", "f3d4", "b8c6", "b1c3", "d7d6", "c1e3", "g8f6", "f1e2", "c8d7", "d4b5", "d8b8", "a2a4", "f8e7", "d1d2", "e8g8", "g2g4", "a7a6", "b5d4", "d6d5", "e4d5", "f6d5", "d4e6", "f7e6", "c3d5", "e6d5", "d2d5", "f8f7", "e1c1", "d7e8", "d5e4", "f7f8", "f2f4", "e8g6", "e2c4... | {"missing move": "f5c5"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["g2g3", "e7e5", "f1g2", "g8f6", "e2e4", "b8c6", "b1c3", "f8c5", "g1e2", "d7d6", "c3a4", "h7h5", "h2h3", "h5h4", "g3g4", "f6g4", "d2d4", "c5d4", "e2d4", "e5d4", "h3g4", "b7b5", "e4e5", "c8d7", "e5d6", "b5a4", "e1g1", "e8g8", "g4g5", "h4h3", "g2d5", "c6b4", "d5e4", "d7c6", "d1d4", "d8d7", "d4b4", "d7g4", "g1h2... | {"missing move": "h2h1q"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "e7e6", "d2d4", "d7d5", "b1d2", "b8c6", "g1f3", "g8f6", "e4e5", "f6d7", "d2b3", "f8e7", "f1b5", "a7a5", "a2a4", "c6a7", "b5e2", "c7c5", "b3c5", "d7c5", "d4c5", "e7c5", "e2d3", "h7h6", "c2c3", "a7c6", "e1g1", "e8g8", "d3c2", "f7f6", "e5f6", "d8f6", "c1e3", "b7b6", "e3d4", "c6d4", "c3d4", "c5d6", "c2d3... | {"missing move": "f2f3"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "g8f6", "g1f3", "e7e6", "c2c4", "b7b6", "g2g3", "c8a6", "d1a4", "a6b7", "b1c3", "f8e7", "f1g2", "f6e4", "c3e4", "b7e4", "d4d5", "a7a5", "e1g1", "e8g8", "f1d1", "d8e8", "f3d4", "e4g2", "g1g2", "e7c5", "a4c2", "c5d4", "d1d4", "d7d6", "c1d2", "e6e5", "d4d3", "f7f5", "d3c3", "b8d7", "a1g1", "e8h5", "f2f3... | {"missing move": "d8h8"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "g8f6", "c2c4", "e7e6", "e2e3", "d7d5", "g1f3", "f8e7", "f1e2", "d5c4", "d1a4", "b8d7", "a4c4", "a7a6", "b2b4", "b7b5", "c4b3", "e8g8", "e1g1", "c8b7", "a2a3", "f6e4", "b1d2", "b7d5", "b3c2", "f7f5", "e2d3", "e4d2", "f3d2", "e7d6", "e3e4", "f5e4", "d2e4", "d8h4", "h2h3", "d7b6", "c2e2", "h7h6", "f1d1... | {"missing move": "f8f7"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["c2c4", "g7g6", "g2g3", "f8g7", "d2d3", "g8f6", "f1g2", "e8g8", "b1c3", "c7c5", "c1d2", "f8e8", "d1c1", "d7d6", "d2h6", "g7h8", "a1b1", "a7a5", "h2h3", "b8c6", "g3g4", "a5a4", "g1f3", "b7b6", "f3e5", "c6e5", "g2a8", "c8g4", "a8g2", "g4d7", "b2b4", "a4b3", "b1b3", "d7c6", "c1g5", "f6h5", "g2d5", "d8d7", "e1f1... | {"missing move": "e1c2"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "d7d5", "c2c4", "e7e6", "g1f3", "c7c6", "d1c2", "f7f5", "c1f4", "g8f6", "e2e3", "f8d6", "f1e2", "e8g8", "e1g1", "a7a5", "b1c3", "d6f4", "e3f4", "d8d6", "g2g3", "d5c4", "e2c4", "b7b5", "c4e2", "f8d8", "f3e5", "b8a6", "e2f3", "c8b7", "c3b5", "c6b5", "f3b7", "a8a7", "b7f3", "a7c7", "c2e2", "d6b6", "a1c1... | {"missing move": "c5e7"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "d7d6", "d2d4", "g8f6", "b1c3", "g7g6", "f1e2", "f8g7", "h2h4", "h7h5", "g1h3", "b8c6", "c1g5", "e8g8", "d1d3", "f6h7", "g5e3", "h7f6", "e1c1", "e7e5", "d4e5", "c6e5", "d3d2", "a7a6", "e3g5", "d8e8", "h3f4", "b7b5", "f4d5", "f6d5", "c3d5", "f7f6", "d5c7", "e8f7", "c7a8", "f6g5", "d2d6", "f7a2", "h4g5... | {"missing move": "c1a1"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "c7c5", "g1f3", "d7d6", "f1c4", "e7e6", "e1g1", "f8e7", "f1e1", "g8f6", "c4f1", "e8g8", "d2d4", "c5d4", "f3d4", "b7b6", "c2c4", "c8b7", "b1c3", "a7a6", "b2b3", "d8c7", "c1b2", "b8d7", "d1e2", "d7c5", "f2f3", "f8e8", "a1d1", "a8d8", "e2f2", "c5d7", "d1d2", "d6d5", "e4d5", "e6d5", "e1e7", "e8e7", "c3d5... | {"missing move": "b4b2"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "g7g6", "e2e4", "f8g7", "b1c3", "d7d6", "c1e3", "a7a6", "a2a4", "b8c6", "d4d5", "c6b4", "c3e2", "a6a5", "c2c3", "b4a6", "e2g3", "c7c6", "g1f3", "g8f6", "f1c4", "d8c7", "e1g1", "e8g8", "d5c6", "b7c6", "f1e1", "c8g4", "a1b1", "f6d7", "c4a6", "a8a6", "h2h3", "g4f3", "d1f3", "c6c5", "g3f1", "a6b6", "e3g5... | {"missing move": "a7a8q"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "e7e5", "g1f3", "g8f6", "f3e5", "d7d6", "e5c4", "f6e4", "b1c3", "e4c3", "d2c3", "d6d5", "c4e3", "c8e6", "f2f4", "f8c5", "d1f3", "b8c6", "f4f5", "d8h4", "g2g3", "h4f6", "f1g2", "c6e5", "f3e2", "c5e3", "c1e3", "f6f5", "e3f4", "f7f6", "e2b5", "c7c6", "b5b7", "e8g8", "e1c1", "f8b8", "b7c7", "e6f7", "f4e5... | {"missing move": "b1a2"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "g8f6", "g1f3", "e7e6", "b1d2", "d7d5", "e2e3", "c7c5", "d4c5", "f8c5", "a2a3", "a7a5", "b2b3", "e8g8", "c1b2", "b8c6", "f1b5", "d8e7", "d1e2", "c5d6", "e1g1", "e6e5", "e3e4", "c8g4", "f1e1", "f8d8", "e4d5", "f6d5", "e2e4", "d5f6", "e4a4", "g4d7", "d2c4", "e5e4", "c4b6", "d7e6", "b2f6", "e7f6", "a4e4... | {"missing move": "e3d2"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "e7e5", "g1f3", "d8e7", "b1c3", "d7d6", "d2d4", "g8f6", "f1c4", "e5d4", "f3d4", "g7g6", "e1g1", "f8g7", "c1g5", "c7c6", "d1d2", "e8g8", "f1e1", "b7b5", "c4f1", "f8e8", "a1d1", "e7c7", "d4f3", "b8d7", "d2d6", "c7d6", "d1d6", "b5b4", "g5f6", "d7f6", "c3a4", "f6e4", "d6c6", "c8g4", "c6c7", "g4f3", "g2f3... | {"missing move": "b1a2"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "e7e5", "f2f4", "f8c5", "f4e5", "d8h4", "g2g3", "h4e4", "d1e2", "e4h1", "d2d4", "c5d4", "g1f3", "b8c6", "b1c3", "d7d6", "e1d2", "c8g4", "e5d6", "c6e5", "f1g2", "g4f3", "g2h1", "f3e2", "d2e2", "c7c6", "c3e4", "e8c8", "a2a4", "a7a5", "h1g2", "g8f6", "e4f6", "g7f6", "c1f4", "e5g4", "g2h3", "f6f5", "e2f3... | {"missing move": "h2h1q"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "f7f5", "c2c4", "g8f6", "g2g3", "e7e6", "b1c3", "f8b4", "d1b3", "c7c5", "f1g2", "b8c6", "d4c5", "b4c5", "c1g5", "c6a5", "b3b5", "d8b6", "g1h3", "b6b5", "c3b5", "e8e7", "b2b3", "c5b4", "e1f1", "a7a6", "b5d4", "b4c5", "d4c2", "a5c6", "h3f4", "h8d8", "g2c6", "b7c6", "f4d3", "c5a7", "f2f3", "a6a5", "g5f4... | {"missing move": "e2e3"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "d7d5", "c2c4", "e7e6", "b1c3", "g8f6", "c4d5", "f6d5", "e2e4", "d5c3", "b2c3", "c7c5", "g1f3", "c5d4", "c3d4", "f8b4", "c1d2", "b4d2", "d1d2", "e8g8", "f1c4", "b8d7", "e1g1", "d7f6", "c4d3", "c8d7", "a2a4", "d7c6", "f1e1", "a7a5", "d2b2", "f6d7", "h2h4", "h7h6", "d3b5", "a8c8", "a1b1", "b7b6", "b5a6... | {"missing move": "d6e6"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "e7e5", "g1f3", "b8c6", "f1b5", "a7a6", "b5a4", "g8f6", "e1g1", "f8e7", "d2d3", "b7b5", "a4b3", "d7d6", "c2c3", "e8g8", "f1e1", "c6a5", "b3c2", "c7c5", "d3d4", "e5d4", "c3d4", "a5c6", "h2h3", "c6b4", "b1c3", "b4c2", "d1c2", "c8b7", "c1f4", "f8e8", "d4d5", "g7g6", "a2a4", "d8b6", "f4g5", "f6d7", "g5e7... | {"missing move": "f6g5"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["g1f3", "b8c6", "d2d4", "d7d5", "g2g3", "c8g4", "f1g2", "d8d7", "e1g1", "e7e6", "c2c3", "f8d6", "b1d2", "g8f6", "f1e1", "g4h5", "e2e4", "f6e4", "d2e4", "d5e4", "e1e4", "e8g8", "e4e1", "f8e8", "a2a4", "a8d8", "c1e3", "e6e5", "d4e5", "c6e5", "f3e5", "e8e5", "d1d3", "b7b6", "a4a5", "h5g4", "d3a6", "g4h3", "a5b6... | {"missing move": "f7f8"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "c7c5", "g1f3", "b8c6", "d2d4", "c5d4", "f3d4", "g8f6", "b1c3", "g7g6", "f1c4", "f8g7", "d4c6", "b7c6", "e4e5", "f6g4", "d1g4", "d7d5", "g4f3", "d5c4", "f3c6", "c8d7", "c6c5", "d8c8", "c1e3", "c8c5", "e3c5", "g7e5", "c3d5", "a8c8", "c5a3", "e7e6", "e1c1", "d7c6", "d5e7", "c8c7", "e7c6", "c7c6", "h1e1... | {"missing move": "b8a8"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "g8f6", "c2c4", "c7c5", "d4d5", "d7d6", "b1c3", "g7g6", "e2e4", "f8g7", "h2h3", "e7e6", "g1f3", "e8g8", "f1d3", "f6h5", "c1g5", "f7f6", "g5d2", "f6f5", "d2g5", "g7f6", "g5h6", "f6g7", "d1d2", "e6e5", "e4f5", "c8f5", "h6g5", "d8c8", "g2g4", "e5e4", "c3e4", "f5e4", "d3e4", "h5f6", "g5f6", "g7f6", "e1g1... | {"missing move": "g4d1"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["b2b3", "d7d5", "c1b2", "g8f6", "e2e3", "c8g4", "g1f3", "e7e6", "c2c4", "f8d6", "f1e2", "c7c6", "h2h3", "g4h5", "d2d3", "e8g8", "g2g4", "h5g6", "b1d2", "b8d7", "g4g5", "f6e8", "h3h4", "g6h5", "f3d4", "h5e2", "d1e2", "d8e7", "c4d5", "c6d5", "a1c1", "d6a3", "d2f3", "a3b2", "e2b2", "f7f6", "e3e4", "d5e4", "d3e4... | {"missing move": "h6h8"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "e7e5", "g1f3", "b8c6", "d2d4", "e5d4", "f3d4", "g8f6", "d4c6", "b7c6", "e4e5", "d8e7", "d1e2", "f6d5", "g2g3", "g7g6", "c2c4", "d5b6", "b2b3", "d7d6", "f1g2", "c8b7", "e1g1", "f8g7", "f2f4", "f7f6", "e5e6", "f6f5", "c1b2", "g7b2", "e2b2", "e8g8", "a2a4", "a7a5", "f1e1", "f8f6", "b1a3", "f6e6", "b2c3... | {"missing move": "b5b1"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "g8f6", "c2c4", "d7d6", "b1c3", "e7e5", "d4d5", "e5e4", "d1c2", "c8f5", "g1f3", "f5g6", "c2a4", "b8d7", "f3h4", "f6g4", "g2g3", "f8e7", "h4g6", "h7g6", "c3e4", "f7f5", "e4c3", "h8h2", "h1h2", "g4h2", "f1g2", "e8f7", "f2f3", "e7f6", "c1d2", "d8e7", "e1c1", "f6c3", "d2c3", "d7c5", "a4c2", "a8e8", "b2b4... | {"missing move": "e1e2"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "d7d5", "c2c4", "b8c6", "b1c3", "d5c4", "d4d5", "c6e5", "f2f4", "e5g4", "e2e4", "e7e5", "g1f3", "f8c5", "f1c4", "e5f4", "c1f4", "g8e7", "h2h3", "e7g6", "f4g5", "g4f2", "d1a4", "c8d7", "g5d8", "d7a4", "c3a4", "a8d8", "e1g1", "f2d3", "a4c5", "d3c5", "c4b5", "c7c6", "d5c6", "e8g8", "c6b7", "c5b7", "a1c1... | {"missing move": "e6d7"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "g8f6", "c2c4", "g7g6", "b1c3", "d7d5", "c1f4", "f8g7", "e2e3", "c7c5", "d4c5", "d8a5", "g1f3", "f6e4", "f4e5", "e4c3", "d1d2", "g7e5", "f3e5", "f7f6", "e5f3", "d5c4", "f1c4", "b8c6", "d2c3", "a5c3", "b2c3", "c8d7", "a1b1", "c6d8", "f3d4", "a8c8", "d4b3", "a7a5", "c4d5", "d7e6", "d5f3", "a5a4", "b3d4... | {"missing move": "c7d7"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "g8f6", "c2c4", "e7e6", "e2e3", "d7d5", "b1c3", "f8e7", "g1f3", "e8g8", "a2a3", "b7b6", "c4d5", "e6d5", "b2b4", "c7c5", "d4c5", "b6c5", "b4c5", "b8a6", "c5c6", "a6c5", "f1e2", "c8a6", "e1g1", "a6c4", "a1b1", "a8b8", "c1d2", "b8b1", "d1b1", "c5b3", "b1c2", "d8d6", "f1b1", "b3d2", "f3d2", "d6c6", "d2c4... | {"missing move": "f2f3"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["g1f3", "g8f6", "c2c4", "d7d5", "c4d5", "f6d5", "e2e4", "d5b6", "d2d4", "g7g6", "c1f4", "f8g7", "a2a4", "e8g8", "a4a5", "b6d7", "b1c3", "b8c6", "e4e5", "b7b6", "h2h4", "c6b4", "f3g5", "h7h6", "g5f7", "g8f7", "d1b3", "f7e8", "f4e3", "b6a5", "a1a5", "a8b8", "c3b5", "a7a6", "b3b4", "c7c5", "b4c3", "a6b5", "f1d3... | {"missing move": "a7d7"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "d7d5", "e4d5", "g8f6", "g1f3", "f6d5", "d2d4", "c8f5", "f1d3", "f5d3", "d1d3", "e7e6", "e1g1", "c7c5", "d4c5", "b8c6", "d3b5", "d8c7", "c1d2", "f8e7", "b1c3", "a8d8", "f1e1", "e8g8", "b5c4", "h7h6", "a1d1", "d8d7", "c3d5", "d7d5", "d2e3", "f8d8", "d1d5", "d8d5", "b2b4", "e7f6", "g2g3", "c6e7", "e3d4... | {"missing move": "g6g8"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "c7c5", "g1f3", "e7e6", "d2d4", "c5d4", "f3d4", "a7a6", "f1d3", "g8f6", "d1e2", "d7d6", "b1c3", "b7b5", "a2a4", "b5b4", "c3a2", "e6e5", "d4f3", "a6a5", "d3b5", "b8d7", "c1g5", "f8e7", "c2c3", "b4c3", "a2c3", "e8g8", "f3d2", "d7c5", "g5e3", "c5e6", "c3d5", "f6d5", "e4d5", "e6d4", "e3d4", "e5d4", "e1g1... | {"missing move": "g5g4"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "c7c5", "g1f3", "d7d6", "f1b5", "c8d7", "b5d7", "d8d7", "c2c4", "g7g6", "d2d4", "c5d4", "f3d4", "g8f6", "f2f3", "f8g7", "b1c3", "e8g8", "c1e3", "f8c8", "d1d3", "b8c6", "d4c6", "d7c6", "b2b3", "a7a6", "a2a4", "e7e6", "e1g1", "f6d7", "a1c1", "d7c5", "d3c2", "c6c7", "f1d1", "c8d8", "c3e2", "a8c8", "c2a2... | {"missing move": "f4h4"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "g8f6", "c2c4", "e7e6", "e2e3", "d7d5", "g1f3", "c7c5", "b1c3", "b8c6", "d4c5", "f8c5", "a2a3", "a7a5", "f1e2", "e8g8", "c4d5", "e6d5", "e1g1", "c8f5", "c3b5", "f6e4", "c1d2", "d5d4", "b5d4", "c6d4", "e3d4", "c5d4", "f3d4", "d8d4", "d2c1", "d4d1", "f1d1", "e4c5", "e2c4", "b7b5", "c4a2", "c5d3", "a2b1... | {"missing move": "f4e3"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "c7c5", "g1f3", "b8c6", "d2d4", "c5d4", "f3d4", "g7g6", "c2c4", "g8f6", "b1c3", "f8g7", "c1e3", "d7d6", "h2h3", "c8d7", "f1e2", "e8g8", "d4f3", "a8c8", "e1g1", "c6a5", "b2b3", "f6g4", "e3d4", "g4e5", "f3e5", "d6e5", "d4a7", "a5c6", "a7e3", "c6d4", "a2a4", "f7f5", "f2f3", "d7e6", "a1b1", "d8d6", "e2d3... | {"missing move": "h6a6"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "g8f6", "c2c4", "e7e6", "g1f3", "b7b6", "g2g3", "c8b7", "f1g2", "f8e7", "e1g1", "e8g8", "b2b3", "d7d5", "c4d5", "f6d5", "f1e1", "d5f6", "b1c3", "c7c5", "e2e4", "c5d4", "f3d4", "d8c8", "c1b2", "f8d8", "a1c1", "b8c6", "c3b5", "e7c5", "d1e2", "c8d7", "e1d1", "a7a6", "d4f5", "e6f5", "d1d7", "d8d7", "e4e5... | {"missing move": "f5f6"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["g1f3", "d7d5", "g2g3", "g8f6", "f1g2", "g7g6", "d2d4", "f8g7", "e1g1", "e8g8", "a2a4", "a7a5", "c2c3", "c7c6", "b1d2", "b8d7", "f1e1", "c6c5", "h2h4", "b7b6", "e2e4", "f6e4", "d2e4", "d5e4", "e1e4", "c8b7", "e4e1", "c5d4", "f3d4", "b7g2", "g1g2", "a8c8", "c1g5", "g7f6", "g5h6", "f8e8", "d4b5", "d7e5", "e1e2... | {"missing move": "e8c8"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "e7e6", "d2d4", "d7d5", "e4d5", "e6d5", "g1f3", "f8d6", "f1d3", "g8e7", "e1g1", "e8g8", "f1e1", "h7h6", "c2c4", "d5c4", "d3c4", "b8d7", "b1c3", "d7b6", "c4b3", "c7c6", "f3e5", "b6d5", "c3d5", "e7d5", "d1d3", "d8h4", "h2h3", "f8d8", "c1d2", "c8e6", "e1e2", "d6c7", "a1e1", "c7e5", "e2e5", "a8c8", "e1e4... | {"missing move": "h2g1"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "c7c5", "g1f3", "d7d6", "d2d4", "c5d4", "f3d4", "g8f6", "b1c3", "a7a6", "c1g5", "e7e6", "f1e2", "f8e7", "f2f4", "h7h6", "g5h4", "e6e5", "d4f5", "c8f5", "e4f5", "b8c6", "d1d2", "a8c8", "e1c1", "e8g8", "c1b1", "b7b5", "h4f6", "e7f6", "c3d5", "f8e8", "h1e1", "e5f4", "d2f4", "f6g5", "f4g4", "c6e7", "e2f3... | {"missing move": "b2a1"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["b2b4", "e7e5", "c1b2", "f8b4", "b2e5", "g8f6", "c2c4", "e8g8", "e2e3", "b8c6", "e5b2", "d7d5", "c4d5", "f6d5", "g1f3", "c8f5", "f1e2", "b4a5", "e1g1", "d8e7", "d1b3", "f8d8", "d2d4", "d5f4", "e2d1", "f4g2", "g1g2", "f5e4", "b2c3", "d8d6", "f1g1", "e7d7", "b1d2", "c6d4", "e3d4", "e4d5", "c3a5", "d5b3", "a2b3... | {"missing move": "c8g8"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["g1f3", "g8f6", "e2e3", "d7d6", "f1e2", "g7g6", "d2d4", "f8g7", "c2c4", "b7b6", "b1c3", "c8b7", "d1c2", "e8g8", "e3e4", "b8d7", "e1g1", "e7e5", "d4e5", "d6e5", "f1d1", "f8e8", "c1g5", "c7c6", "c4c5", "d8e7", "c5b6", "a7b6", "a2a4", "d7c5", "e2c4", "b7a6", "c4a2", "h7h6", "g5e3", "a8d8", "d1d8", "e8d8", "a1d1... | {"missing move": "e5f5"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "c7c5", "g1f3", "b8c6", "d2d4", "c5d4", "f3d4", "e7e5", "d4b5", "d7d6", "f1c4", "f8e7", "c1g5", "e7g5", "b5d6", "e8f8", "d6f7", "d8d4", "d1d4", "c6d4", "f7g5", "d4c2", "e1d2", "c2a1", "b1c3", "g8f6", "h1a1", "b7b5", "c3b5", "f8e7", "g5f7", "h8f8", "f7e5", "f6e4", "d2e3", "c8b7", "f2f4", "f8d8", "b5d4... | {"missing move": "e1c1"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "g7g6", "d2d4", "f8g7", "b1c3", "d7d6", "c1e3", "a7a6", "d1d2", "b7b5", "a2a4", "b5b4", "c3d5", "a6a5", "h2h4", "e7e6", "d5f4", "h7h6", "e1c1", "b8d7", "f1b5", "c8b7", "d4d5", "e6d5", "e4d5", "g8f6", "f4e6", "f7e6", "d5e6", "c7c6", "e6d7", "d8d7", "b5c4", "e8c8", "g1e2", "c6c5", "e2f4", "d7a4", "c1b1... | {"missing move": "b3a3"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "g8f6", "c2c4", "e7e6", "b1c3", "f8b4", "c1d2", "b7b6", "e2e3", "c8b7", "g1f3", "b4c3", "d2c3", "d8e7", "f3d2", "d7d5", "d1a4", "b8d7", "c4c5", "b6c5", "d4c5", "c7c6", "a4a5", "e7c5", "a5c5", "d7c5", "a1c1", "c5a4", "c3d4", "e8e7", "b2b3", "a4b6", "b3b4", "f6d7", "d2b3", "e6e5", "d4a1", "h8c8", "f2f4... | {"missing move": "f3f4"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "e7e6", "c2c4", "g8f6", "g1f3", "c7c5", "d4d5", "e6d5", "c4d5", "d7d6", "e2e4", "g7g6", "b1c3", "a7a6", "c1f4", "f8g7", "d1a4", "c8d7", "a4b3", "d7c8", "a2a4", "e8g8", "f1e2", "f6e8", "h2h4", "c8g4", "f3d2", "g4e2", "c3e2", "b8d7", "h4h5", "d8e7", "a4a5", "e8f6", "h5h6", "g7h8", "f4g5", "f8b8", "e1g1... | {"missing move": "d4b2"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "e7e5", "g1f3", "d7d6", "f1c4", "f8e7", "e1g1", "g8f6", "f1e1", "e8g8", "d2d4", "b8d7", "c2c3", "h7h6", "b1d2", "e5d4", "c3d4", "d6d5", "c4b3", "f6e4", "b3d5", "e4f6", "d5b3", "c7c6", "f3e5", "d7b6", "d2f3", "b6d5", "b3c2", "e7d6", "h2h3", "c8e6", "a2a3", "d5e7", "c1f4", "f8e8", "g2g4", "f6h7", "d1d3... | {"missing move": "c2a2"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["c2c4", "g8f6", "b1c3", "e7e6", "g2g3", "d7d5", "c4d5", "e6d5", "f1g2", "c7c5", "d2d3", "d5d4", "c3e4", "f6e4", "g2e4", "f8e7", "h2h4", "e8g8", "g1h3", "h7h6", "h3f4", "e7d6", "e1g1", "b8d7", "a2a4", "d7e5", "f4g2", "c8g4", "c1f4", "d8d7", "f4e5", "d6e5", "e4f3", "g4e6", "a4a5", "a8b8", "f1e1", "g7g5", "a1c1... | {"missing move": "b5a5"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "d7d6", "d2d4", "e7e5", "g1f3", "c8g4", "f1e2", "g4f3", "e2f3", "f8e7", "c2c3", "b8d7", "e1g1", "g8f6", "c1e3", "c7c6", "a2a4", "e8g8", "b1d2", "d6d5", "e4d5", "f6d5", "f3d5", "c6d5", "d1b3", "e5d4", "e3d4", "d7c5", "d4c5", "e7c5", "d2f3", "f8e8", "a1d1", "d8b6", "b3b6", "a7b6", "b2b3", "e8d8", "d1d3... | {"missing move": "g2h1"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "g8f6", "c1g5", "e7e6", "e2e4", "h7h6", "g5f6", "d8f6", "g1f3", "b8c6", "c2c3", "g7g5", "d1d3", "g5g4", "f3d2", "h6h5", "e4e5", "f6g7", "d2e4", "f8e7", "b1a3", "b7b6", "d3g3", "c8b7", "e4f6", "e8d8", "h2h3", "e7f6", "e5f6", "g7f6", "h3g4", "h5g4", "h1h8", "f6h8", "g3g4", "c6e7", "a3c2", "h8h6", "g2g3... | {"missing move": "f2f3"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "c7c5", "c2c3", "d7d5", "e4d5", "d8d5", "d2d4", "g8f6", "g1f3", "b8c6", "b1a3", "c5d4", "a3b5", "d5d8", "c1f4", "e7e5", "f3e5", "f6d5", "f4g3", "f8c5", "f1c4", "e8g8", "e1g1", "c6e5", "g3e5", "d5b6", "c4b3", "d4c3", "d1h5", "c8d7", "b5c3", "d7e6", "e5g7", "g8g7", "b3e6", "f7e6", "h5c5", "f8f5", "c5b4... | {"missing move": "e5e3"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "g8f6", "g1f3", "e7e6", "c1g5", "d7d5", "b1d2", "b8d7", "e2e4", "h7h6", "g5f6", "d7f6", "e4e5", "f6e4", "c2c3", "e4d2", "d1d2", "c7c5", "f1d3", "c8d7", "a2a4", "c5d4", "f3d4", "a7a5", "f2f4", "f8c5", "f4f5", "d8g5", "d2g5", "h6g5", "f5e6", "f7e6", "e1g1", "e8e7", "g2g3", "c5b6", "g1g2", "h8h6", "a1a3... | {"missing move": "d4e5"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "g8f6", "c2c4", "e7e6", "g2g3", "d7d5", "g1f3", "d5c4", "f1g2", "c7c5", "e1g1", "b8c6", "d4c5", "f8c5", "d1d8", "e8d8", "b1d2", "d8e7", "d2c4", "h8d8", "b2b3", "c8d7", "c1b2", "a8c8", "f3e5", "e7f8", "f1d1", "f6d5", "e5d7", "d8d7", "a1c1", "f7f6", "e2e3", "d7d8", "a2a4", "c5e7", "g2e4", "f8f7", "g1f1... | {"missing move": "e8f7"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["g1f3", "g8f6", "c2c4", "g7g6", "b1c3", "f8g7", "e2e4", "d7d6", "d2d4", "e8g8", "f1e2", "c8g4", "h2h3", "g4f3", "e2f3", "f6d7", "h3h4", "b8c6", "c1e3", "e7e5", "d4d5", "c6d4", "h4h5", "d8e7", "d1d2", "c7c5", "e1c1", "d7f6", "h1h3", "e7d7", "d1h1", "a7a6", "f3d1", "b7b5", "g2g4", "b5b4", "c3a4", "a8b8", "e3d4... | {"missing move": "g7f7"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["g1f3", "d7d5", "c2c4", "c7c6", "d2d4", "g8f6", "b1c3", "g7g6", "c1f4", "a7a6", "e2e3", "f8g7", "a1c1", "e8g8", "h2h3", "b7b5", "c4c5", "f6e4", "c3e4", "d5e4", "f3d2", "f7f5", "g2g4", "g8h8", "g4f5", "c8f5", "f1g2", "b8d7", "d2e4", "e7e5", "d4e5", "d7e5", "e1g1", "e5d3", "f4d6", "d3b2", "d1f3", "f8e8", "e4g3... | {"missing move": "b8d6"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "c7c5", "g1f3", "b8c6", "d2d4", "c5d4", "f3d4", "g8f6", "b1c3", "g7g6", "d4c6", "d7c6", "d1d8", "e8d8", "f1c4", "d8e8", "a2a4", "a7a5", "e4e5", "f6d7", "f2f4", "d7b6", "c4e2", "c8f5", "c1e3", "b6d7", "e1c1", "h7h5", "e2f3", "e7e6", "h2h3", "h5h4", "c1b1", "a8d8", "d1d2", "d7c5", "d2d1", "f8e7", "e3f2... | {"missing move": "f4e4"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["g1f3", "g7g6", "d2d4", "f8g7", "c2c4", "d7d6", "g2g3", "c7c5", "d4c5", "d8a5", "b1c3", "a5c5", "c3d5", "b8a6", "d1b3", "g8f6", "c1e3", "c5a5", "e3d2", "a5d8", "d2c3", "a6c5", "b3a3", "e7e5", "f3e5", "f6e4", "e5f3", "e4c3", "d5c3", "c8e6", "e2e3", "e8g8", "f3d4", "d8b6", "f1e2", "e6h3", "c3d5", "b6d8", "e2f1... | {"missing move": "h2f2"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "d7d5", "c2c4", "e7e6", "b1c3", "c7c6", "e2e3", "g8f6", "g1f3", "c6c5", "c4d5", "e6d5", "f1e2", "b8c6", "e1g1", "c5d4", "e3d4", "f8e7", "h2h3", "h7h6", "e2d3", "c8e6", "c1f4", "e8g8", "f1e1", "a7a6", "a1c1", "f8e8", "d3b1", "a8c8", "d1d3", "e7d6", "f4e5", "g7g6", "d3d2", "d6f8", "e5f4", "g8h7", "e1e2... | {"missing move": "c7d8"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "d7d5", "c2c4", "d5c4", "g1f3", "g8f6", "e2e3", "e7e6", "b1c3", "c7c5", "f1c4", "a7a6", "e1g1", "b7b5", "c4e2", "c5d4", "d1d4", "d8d4", "f3d4", "c8b7", "d4b3", "b8c6", "c1d2", "f8e7", "f1d1", "e8g8", "d2e1", "f8d8", "a1c1", "d8d1", "c1d1", "g7g5", "a2a3", "g5g4", "c3a2", "h7h5", "d1c1", "f6d7", "b3a5... | {"missing move": "f1a6"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "e7e5", "g1f3", "b8c6", "f1b5", "a7a6", "b5a4", "g8f6", "e1g1", "f8e7", "f1e1", "b7b5", "a4b3", "e8g8", "d2d4", "c6d4", "f3d4", "e5d4", "e4e5", "f6e8", "d1d4", "c7c5", "d4e4", "a8b8", "c2c4", "c8b7", "e4e2", "b5c4", "b3c4", "d7d5", "e5d6", "e7d6", "b1c3", "d8c7", "h2h3", "d6h2", "g1h1", "e8f6", "c4a6... | {"missing move": "g7g8q"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "g8f6", "c2c4", "e7e6", "e2e3", "d7d5", "g1f3", "f8e7", "d1c2", "e8g8", "f1e2", "c7c5", "c4d5", "f6d5", "d4c5", "b8d7", "a2a3", "d7c5", "e3e4", "d5f6", "b1c3", "d8c7", "e4e5", "f6d5", "c1g5", "b7b6", "c3b5", "c7d8", "h2h4", "a7a5", "a1d1", "c8a6", "g5e7", "d8e7", "e1g1", "h7h6", "d1d4", "c5d7", "e2c4... | {"missing move": "d2b2"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "d7d5", "c2c4", "c7c6", "g1f3", "g8f6", "e2e3", "c8f5", "b1c3", "e7e6", "f3h4", "f5g6", "h4g6", "h7g6", "c1d2", "f8b4", "d1b3", "a7a5", "a2a3", "b4c3", "b2c3", "b7b6", "f2f3", "e8g8", "c4d5", "e6d5", "c3c4", "f8e8", "c4d5", "f6d5", "e1f2", "b8d7", "a1c1", "d8f6", "a3a4", "g6g5", "h2h3", "d5b4", "f1e2... | {"missing move": "g3g7"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "d7d5", "c2c4", "c7c6", "e2e3", "g8f6", "b1c3", "e7e6", "g1f3", "b8d7", "d1c2", "b7b6", "f1d3", "c8b7", "e1g1", "f8e7", "h2h3", "e8g8", "f1d1", "a8c8", "e3e4", "d5c4", "d3c4", "b6b5", "c4d3", "b5b4", "c3e2", "h7h6", "e4e5", "f6d5", "e2g3", "c6c5", "c2e2", "d5b6", "d3c2", "b7f3", "e2f3", "c5d4", "f3e4... | {"missing move": "a5e5"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "g7g6", "d2d4", "f8g7", "b1c3", "c7c6", "f2f4", "d7d5", "e4e5", "h7h5", "c1e3", "c8f5", "g1f3", "e7e6", "h2h3", "b8d7", "e3f2", "g7f8", "f1e2", "f8e7", "d1d2", "g8h6", "f3g5", "f7f6", "g5f3", "d8c7", "e1c1", "e8c8", "c1b1", "d8g8", "h1f1", "c8b8", "f3h4", "f6e5", "d4e5", "g6g5", "h4f5", "h6f5", "g2g4... | {"missing move": "c6c7"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "c7c5", "g1f3", "d7d6", "d2d4", "c5d4", "f3d4", "g8f6", "b1c3", "g7g6", "c1g5", "f8g7", "d4b3", "h7h6", "g5e3", "f6g4", "e3d2", "a7a6", "h2h3", "g4f6", "d2e3", "b8c6", "d1d2", "b7b5", "f2f3", "a8b8", "e1c1", "b5b4", "c3d5", "a6a5", "b3d4", "c8d7", "d4c6", "d7c6", "d5f6", "g7f6", "e3d4", "f6d4", "d2d4... | {"missing move": "d7b5"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "e7e6", "d2d4", "d7d5", "b1d2", "d5e4", "d2e4", "b8d7", "f1d3", "g8f6", "d1e2", "c7c5", "e4f6", "d7f6", "d4c5", "f8c5", "g1f3", "d8c7", "c1d2", "c8d7", "e1c1", "e8c8", "e2e5", "f6g4", "e5c7", "c8c7", "f3g5", "f7f6", "f2f3", "g4f2", "g5f7", "h7h5", "h2h4", "d8f8", "f7h8", "f8h8", "h1f1", "f2d1", "c1d1... | {"missing move": "b8b5"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "g8f6", "g1f3", "d7d5", "c1f4", "e7e6", "e2e3", "f8d6", "f4g3", "f6e4", "f1d3", "e4g3", "h2g3", "c7c5", "c2c4", "d5c4", "d3c4", "c5d4", "c4b5", "c8d7", "b5d7", "b8d7", "d1d4", "d6e7", "b1d2", "e8g8", "e1e2", "a8c8", "a1c1", "d7c5", "d4d8", "f8d8", "c1c2", "c5a4", "h1c1", "c8c2", "c1c2", "e7f6", "f3d4... | {"missing move": "c2b1"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["c2c4", "g7g6", "b1c3", "d7d6", "g2g3", "f8g7", "f1g2", "g8h6", "g1f3", "e7e5", "d2d4", "h6g4", "e2e4", "e8g8", "c1g5", "d8d7", "d4d5", "f7f5", "h2h3", "g4f6", "e1g1", "a7a5", "e4f5", "g6f5", "g5e3", "b8a6", "f3g5", "d7e7", "d1c2", "a6c5", "g1h2", "e5e4", "a1d1", "h7h6", "g5e6", "c5e6", "d5e6", "c8e6", "c3e2... | {"missing move": "e5f6"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "c7c5", "b1c3", "b8c6", "g2g3", "d7d6", "d2d3", "g7g6", "f1g2", "g8f6", "a2a4", "f8g7", "g1e2", "a8b8", "e1g1", "a7a6", "c3d5", "e8g8", "c1g5", "e7e6", "g5f6", "g7f6", "d5f6", "d8f6", "c2c3", "f6e7", "d1d2", "b7b5", "a4b5", "a6b5", "f2f4", "b8b6", "f4f5", "e6f5", "e2f4", "e7g5", "e4f5", "c8f5", "h2h4... | {"missing move": "g6h6"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "e7e5", "g1f3", "b8c6", "f1b5", "a7a6", "b5a4", "g8f6", "e1g1", "b7b5", "a4b3", "c8b7", "d2d3", "f8c5", "b1c3", "e8g8", "c3d5", "h7h6", "c2c3", "f8e8", "a2a4", "c6a5", "d5f6", "d8f6", "b3a2", "b5b4", "c1e3", "d7d6", "h2h3", "a8d8", "a1c1", "b4b3", "a2b3", "a5b3", "d1b3", "b7c8", "f1e1", "c8h3", "b3d1... | {"missing move": "g6h6"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "e7e5", "g1f3", "d7d6", "d2d4", "e5d4", "d1d4", "b8c6", "d4c4", "c8e6", "c4b5", "d8c8", "b1c3", "a7a6", "b5d3", "g8f6", "c1g5", "f8e7", "e1c1", "h7h6", "g5h4", "c6e5", "f3e5", "d6e5", "f1e2", "c7c6", "f2f4", "e5f4", "e4e5", "f6d5", "c3d5", "c6d5", "h4e7", "e8e7", "h1f1", "c8c7", "f1f4", "c7e5", "d3d2... | {"missing move": "a7a8"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "d7d5", "c2c4", "c7c6", "g1f3", "d5c4", "e2e4", "g8f6", "e4e5", "f6d5", "f1c4", "c8f5", "f3h4", "f5b1", "a1b1", "e7e6", "h4f3", "f8b4", "e1f1", "b4e7", "h2h4", "c6c5", "h1h3", "b8c6", "h3g3", "g7g6", "d4c5", "e7c5", "d1e2", "h7h6", "c1d2", "a7a6", "b2b4", "c5b6", "a2a4", "c6e7", "a4a5", "b6a7", "b4b5... | {"missing move": "b3b8"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "e7e5", "g1f3", "g8f6", "f3e5", "d7d6", "e5f3", "f6e4", "d2d4", "f8e7", "f1d3", "e4f6", "c2c4", "b8c6", "h2h3", "d6d5", "e1g1", "c6b4", "d3e2", "d5c4", "e2c4", "e8g8", "a2a3", "b4d5", "f1e1", "c7c6", "b1c3", "c8e6", "f3g5", "d5c3", "g5e6", "c3d1", "e6d8", "e7d8", "e1d1", "d8e7", "a3a4", "f8d8", "a1b1... | {"missing move": "f4f3"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["f2f4", "d7d5", "g1f3", "g8f6", "e2e3", "g7g6", "b2b3", "f8g7", "c1b2", "c7c5", "f1b5", "c8d7", "a2a4", "e8g8", "e1g1", "d7f5", "h2h3", "a7a6", "b5e2", "d5d4", "e3d4", "c5d4", "f3d4", "f6e4", "c2c3", "g7d4", "c3d4", "b8c6", "g1h2", "c6d4", "e2c4", "e4c5", "d2d3", "d8d6", "b1c3", "f5e6", "b2a3", "d6c6", "c3e2... | {"missing move": "h1g2"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "c7c5", "g1f3", "d7d6", "d2d4", "c5d4", "f3d4", "g8f6", "b1c3", "a7a6", "h2h3", "e7e5", "d4e2", "c8e6", "g2g4", "h7h6", "f1g2", "b8d7", "e1g1", "f8e7", "e2g3", "g7g6", "c3d5", "e6d5", "e4d5", "d8c7", "a2a4", "e8f8", "c1e3", "f8g7", "d1d2", "a8c8", "c2c3", "a6a5", "f2f4", "d7c5", "a1a3", "b7b6", "b2b4... | {"missing move": "a7a8q"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "g8f6", "c2c4", "e7e6", "e2e3", "d7d5", "g1f3", "c7c5", "b1c3", "b8c6", "d4c5", "f8c5", "a2a3", "a7a5", "f1e2", "e8g8", "c4d5", "e6d5", "e1g1", "c8f5", "c3b5", "d8e7", "b2b3", "f8d8", "c1b2", "a8c8", "f3d4", "f5g6", "a1c1", "c5b6", "a3a4", "h7h6", "h2h3", "h6h5", "e2f3", "c6b4", "c1c8", "d8c8", "f3e2... | {"missing move": "d5c6"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["d2d4", "g8f6", "f2f3", "d7d5", "e2e4", "d5e4", "b1c3", "c7c6", "c1e3", "c8f5", "f3e4", "f6e4", "f1d3", "e4c3", "b2c3", "f5d3", "c2d3", "e7e6", "g1h3", "b8d7", "e1g1", "d7f6", "c3c4", "f8e7", "h3f2", "a8c8", "a2a4", "e8g8", "d1f3", "b7b6", "a4a5", "b6b5", "a5a6", "c6c5", "c4b5", "c5d4", "e3f4", "f6d5", "f4e5... | {"missing move": "a3a4"} | FIND_LAST_MOVE |
Given an incomplit set of chess moves and the game's final score, write the last missing chess move.
Input Format: A comma-separated list of chess moves followed by the game score.
Output Format: The missing chess move | {"moves": ["e2e4", "e7e5", "g1f3", "g8f6", "d2d4", "f6e4", "f1d3", "d7d5", "f3e5", "b8d7", "e5f3", "f8d6", "e1g1", "e8g8", "c2c4", "c7c6", "c4d5", "c6d5", "b1c3", "d7f6", "f1e1", "e4c3", "b2c3", "c8g4", "c1g5", "a8c8", "d1d2", "g4f3", "g2f3", "c8c6", "g5h4", "d8c7", "h4g3", "f6h5", "g3d6", "c7d6", "e1e5", "g7g6", "d3b5... | {"missing move": "f2g3"} | FIND_LAST_MOVE |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.