diff --git a/test/test_env.py b/test/test_env.py index 1feadf5e895..d8bf36cdf98 100644 --- a/test/test_env.py +++ b/test/test_env.py @@ -131,6 +131,7 @@ from torchrl.envs.transforms.transforms import ( AutoResetEnv, AutoResetTransform, + Tokenizer, Transform, ) from torchrl.envs.utils import ( @@ -3441,35 +3442,148 @@ def test_partial_rest(self, batched): # fen strings for board positions generated with: # https://lichess.org/editor -@pytest.mark.parametrize("stateful", [False, True]) @pytest.mark.skipif(not _has_chess, reason="chess not found") class TestChessEnv: - def test_env(self, stateful): - env = ChessEnv(stateful=stateful) - check_env_specs(env) + @pytest.mark.parametrize("include_pgn", [False, True]) + @pytest.mark.parametrize("include_fen", [False, True]) + @pytest.mark.parametrize("stateful", [False, True]) + @pytest.mark.parametrize("include_hash", [False, True]) + @pytest.mark.parametrize("include_san", [False, True]) + def test_env(self, stateful, include_pgn, include_fen, include_hash, include_san): + with pytest.raises( + RuntimeError, match="At least one state representation" + ) if not stateful and not include_pgn and not include_fen else contextlib.nullcontext(): + env = ChessEnv( + stateful=stateful, + include_pgn=include_pgn, + include_fen=include_fen, + include_hash=include_hash, + include_san=include_san, + ) + # Because we always use mask_actions=True + assert isinstance(env, TransformedEnv) + check_env_specs(env) + if include_hash: + if include_fen: + assert "fen_hash" in env.observation_spec.keys() + if include_pgn: + assert "pgn_hash" in env.observation_spec.keys() + if include_san: + assert "san_hash" in env.observation_spec.keys() + + def test_pgn_bijectivity(self): + np.random.seed(0) + pgn = ChessEnv._PGN_RESTART + board = ChessEnv._pgn_to_board(pgn) + pgn_prev = pgn + for _ in range(10): + moves = list(board.legal_moves) + move = np.random.choice(moves) + board.push(move) + pgn_move = ChessEnv._board_to_pgn(board) + assert pgn_move != pgn_prev + assert pgn_move == ChessEnv._board_to_pgn(ChessEnv._pgn_to_board(pgn_move)) + assert pgn_move == ChessEnv._add_move_to_pgn(pgn_prev, move) + pgn_prev = pgn_move + + def test_consistency(self): + env0_stateful = ChessEnv(stateful=True, include_pgn=True, include_fen=True) + env1_stateful = ChessEnv(stateful=True, include_pgn=False, include_fen=True) + env2_stateful = ChessEnv(stateful=True, include_pgn=True, include_fen=False) + env0_stateless = ChessEnv(stateful=False, include_pgn=True, include_fen=True) + env1_stateless = ChessEnv(stateful=False, include_pgn=False, include_fen=True) + env2_stateless = ChessEnv(stateful=False, include_pgn=True, include_fen=False) + torch.manual_seed(0) + r1_stateless = env1_stateless.rollout(50, break_when_any_done=False) + torch.manual_seed(0) + r1_stateful = env1_stateful.rollout(50, break_when_any_done=False) + torch.manual_seed(0) + r2_stateless = env2_stateless.rollout(50, break_when_any_done=False) + torch.manual_seed(0) + r2_stateful = env2_stateful.rollout(50, break_when_any_done=False) + torch.manual_seed(0) + r0_stateless = env0_stateless.rollout(50, break_when_any_done=False) + torch.manual_seed(0) + r0_stateful = env0_stateful.rollout(50, break_when_any_done=False) + assert (r0_stateless["action"] == r1_stateless["action"]).all() + assert (r0_stateless["action"] == r2_stateless["action"]).all() + assert (r0_stateless["action"] == r0_stateful["action"]).all() + assert (r1_stateless["action"] == r1_stateful["action"]).all() + assert (r2_stateless["action"] == r2_stateful["action"]).all() + + @pytest.mark.parametrize( + "include_fen,include_pgn", [[True, False], [False, True], [True, True]] + ) + @pytest.mark.parametrize("stateful", [False, True]) + def test_san(self, stateful, include_fen, include_pgn): + torch.manual_seed(0) + env = ChessEnv( + stateful=stateful, + include_pgn=include_pgn, + include_fen=include_fen, + include_san=True, + ) + r = env.rollout(100, break_when_any_done=False) + sans = r["next", "san"] + actions = [env.san_moves.index(san) for san in sans] + i = 0 + + def policy(td): + nonlocal i + td["action"] = actions[i] + i += 1 + return td - def test_rollout(self, stateful): - env = ChessEnv(stateful=stateful) - env.rollout(5000) + r2 = env.rollout(100, policy=policy, break_when_any_done=False) + assert_allclose_td(r, r2) - def test_reset_white_to_move(self, stateful): - env = ChessEnv(stateful=stateful) + @pytest.mark.parametrize( + "include_fen,include_pgn", [[True, False], [False, True], [True, True]] + ) + @pytest.mark.parametrize("stateful", [False, True]) + def test_rollout(self, stateful, include_pgn, include_fen): + torch.manual_seed(0) + env = ChessEnv( + stateful=stateful, include_pgn=include_pgn, include_fen=include_fen + ) + r = env.rollout(500, break_when_any_done=False) + assert r.shape == (500,) + + @pytest.mark.parametrize( + "include_fen,include_pgn", [[True, False], [False, True], [True, True]] + ) + @pytest.mark.parametrize("stateful", [False, True]) + def test_reset_white_to_move(self, stateful, include_pgn, include_fen): + env = ChessEnv( + stateful=stateful, include_pgn=include_pgn, include_fen=include_fen + ) fen = "5k2/4r3/8/8/8/1Q6/2K5/8 w - - 0 1" td = env.reset(TensorDict({"fen": fen})) - assert td["fen"] == fen + if include_fen: + assert td["fen"] == fen + assert env.board.fen() == fen assert td["turn"] == env.lib.WHITE assert not td["done"] - def test_reset_black_to_move(self, stateful): - env = ChessEnv(stateful=stateful) + @pytest.mark.parametrize("include_fen,include_pgn", [[True, False], [True, True]]) + @pytest.mark.parametrize("stateful", [False, True]) + def test_reset_black_to_move(self, stateful, include_pgn, include_fen): + env = ChessEnv( + stateful=stateful, include_pgn=include_pgn, include_fen=include_fen + ) fen = "5k2/4r3/8/8/8/1Q6/2K5/8 b - - 0 1" td = env.reset(TensorDict({"fen": fen})) assert td["fen"] == fen + assert env.board.fen() == fen assert td["turn"] == env.lib.BLACK assert not td["done"] - def test_reset_done_error(self, stateful): - env = ChessEnv(stateful=stateful) + @pytest.mark.parametrize("include_fen,include_pgn", [[True, False], [True, True]]) + @pytest.mark.parametrize("stateful", [False, True]) + def test_reset_done_error(self, stateful, include_pgn, include_fen): + env = ChessEnv( + stateful=stateful, include_pgn=include_pgn, include_fen=include_fen + ) fen = "1R3k2/2R5/8/8/8/8/2K5/8 b - - 0 1" with pytest.raises(ValueError) as e_info: env.reset(TensorDict({"fen": fen})) @@ -3480,12 +3594,19 @@ def test_reset_done_error(self, stateful): @pytest.mark.parametrize( "endstate", ["white win", "black win", "stalemate", "50 move", "insufficient"] ) - def test_reward(self, stateful, reset_without_fen, endstate): + @pytest.mark.parametrize("include_pgn", [False, True]) + @pytest.mark.parametrize("include_fen", [True]) + @pytest.mark.parametrize("stateful", [False, True]) + def test_reward( + self, stateful, reset_without_fen, endstate, include_pgn, include_fen + ): if stateful and reset_without_fen: # reset_without_fen is only used for stateless env return - env = ChessEnv(stateful=stateful) + env = ChessEnv( + stateful=stateful, include_pgn=include_pgn, include_fen=include_fen + ) if endstate == "white win": fen = "5k2/2R5/8/8/8/1R6/2K5/8 w - - 0 1" @@ -3498,28 +3619,28 @@ def test_reward(self, stateful, reset_without_fen, endstate): fen = "5k2/6r1/8/8/8/8/7r/1K6 b - - 0 1" expected_turn = env.lib.BLACK move = "Rg1#" - expected_reward = -1 + expected_reward = 1 expected_done = True elif endstate == "stalemate": fen = "5k2/6r1/8/8/8/8/7r/K7 b - - 0 1" expected_turn = env.lib.BLACK move = "Rb7" - expected_reward = 0 + expected_reward = 0.5 expected_done = True elif endstate == "insufficient": fen = "5k2/8/8/8/3r4/2K5/8/8 w - - 0 1" expected_turn = env.lib.WHITE move = "Kxd4" - expected_reward = 0 + expected_reward = 0.5 expected_done = True elif endstate == "50 move": fen = "5k2/8/1R6/8/6r1/2K5/8/8 b - - 99 123" expected_turn = env.lib.BLACK move = "Kf7" - expected_reward = 0 + expected_reward = 0.5 expected_done = True elif endstate == "not_done": @@ -3538,13 +3659,33 @@ def test_reward(self, stateful, reset_without_fen, endstate): td = env.reset(TensorDict({"fen": fen})) assert td["turn"] == expected_turn - moves = env.get_legal_moves(None if stateful else td) - td["action"] = moves.index(move) + td["action"] = env._san_moves.index(move) td = env.step(td)["next"] assert td["done"] == expected_done assert td["reward"] == expected_reward assert td["turn"] == (not expected_turn) + def test_chess_tokenized(self): + env = ChessEnv(include_fen=True, stateful=True, include_san=True) + assert isinstance(env.observation_spec["fen"], NonTensor) + env = env.append_transform( + Tokenizer(in_keys=["fen"], out_keys=["fen_tokenized"]) + ) + assert isinstance(env.observation_spec["fen"], NonTensor) + env.transform.transform_output_spec(env.base_env.output_spec) + env.transform.transform_input_spec(env.base_env.input_spec) + r = env.rollout(10, return_contiguous=False) + assert "fen_tokenized" in r + assert "fen" in r + assert "fen_tokenized" in r["next"] + assert "fen" in r["next"] + ftd = env.fake_tensordict() + assert "fen_tokenized" in ftd + assert "fen" in ftd + assert "fen_tokenized" in ftd["next"] + assert "fen" in ftd["next"] + env.check_env_specs() + class TestCustomEnvs: def test_tictactoe_env(self): diff --git a/torchrl/data/tensor_specs.py b/torchrl/data/tensor_specs.py index 3d4198ae234..95aaaebd936 100644 --- a/torchrl/data/tensor_specs.py +++ b/torchrl/data/tensor_specs.py @@ -5042,7 +5042,7 @@ def zero(self, shape: torch.Size = None) -> TensorDictBase: def __eq__(self, other): return ( - type(self) is type(other) + type(self) == type(other) and self.shape == other.shape and self._device == other._device and set(self._specs.keys()) == set(other._specs.keys()) diff --git a/torchrl/envs/batched_envs.py b/torchrl/envs/batched_envs.py index 2a70f70a3e2..51331a86346 100644 --- a/torchrl/envs/batched_envs.py +++ b/torchrl/envs/batched_envs.py @@ -718,17 +718,13 @@ def _create_td(self) -> None: env_output_keys = set() env_obs_keys = set() for meta_data in self.meta_data: - env_obs_keys = env_obs_keys.union( - key - for key in meta_data.specs["output_spec"][ - "full_observation_spec" - ].keys(True, True) - ) - env_output_keys = env_output_keys.union( - meta_data.specs["output_spec"]["full_observation_spec"].keys( - True, True - ) + keys = meta_data.specs["output_spec"]["full_observation_spec"].keys( + True, True ) + keys = list(keys) + env_obs_keys = env_obs_keys.union(keys) + + env_output_keys = env_output_keys.union(keys) env_output_keys = env_output_keys.union(self.reward_keys + self.done_keys) self._env_obs_keys = sorted(env_obs_keys, key=_sort_keys) self._env_input_keys = sorted(env_input_keys, key=_sort_keys) @@ -1003,7 +999,12 @@ def _reset(self, tensordict: TensorDictBase, **kwargs) -> TensorDictBase: for i, _env in enumerate(self._envs): if not needs_resetting[i]: if out_tds is not None and tensordict is not None: - out_tds[i] = tensordict[i].exclude(*self._envs[i].reset_keys) + ftd = _env.observation_spec.zero() + if self.device is None: + ftd.clear_device_() + else: + ftd = ftd.to(self.device) + out_tds[i] = ftd continue if tensordict is not None: tensordict_ = tensordict[i] diff --git a/torchrl/envs/common.py b/torchrl/envs/common.py index a47ed98a23b..c3a714fcf91 100644 --- a/torchrl/envs/common.py +++ b/torchrl/envs/common.py @@ -2505,11 +2505,26 @@ def reset( Returns: a tensordict (or the input tensordict, if any), modified in place with the resulting observations. + .. note:: `reset` should not be overwritten by :class:`~torchrl.envs.EnvBase` subclasses. The method to + modify is :meth:`~torchrl.envs.EnvBase._reset`. + """ if tensordict is not None: self._assert_tensordict_shape(tensordict) - tensordict_reset = self._reset(tensordict, **kwargs) + select_reset_only = kwargs.pop("select_reset_only", False) + if select_reset_only and tensordict is not None: + # When making rollouts with step_and_maybe_reset, it can happen that a tensordict has + # keys that are used by reset to optionally set the reset state (eg, the fen in chess). If that's the + # case and we don't throw them away here, reset will just be a no-op (put the env in the state reached + # during the previous step). + # Therefore, maybe_reset tells reset to temporarily hide the non-reset keys. + # To make step_and_maybe_reset handle custom reset states, some version of TensorDictPrimer should be used. + tensordict_reset = self._reset( + tensordict.select(*self.reset_keys, strict=False), **kwargs + ) + else: + tensordict_reset = self._reset(tensordict, **kwargs) # We assume that this is done properly # if reset.device != self.device: # reset = reset.to(self.device, non_blocking=True) @@ -3293,7 +3308,7 @@ def maybe_reset(self, tensordict: TensorDictBase) -> TensorDictBase: else: any_done = False if any_done: - tensordict._set_str( + tensordict = tensordict._set_str( "_reset", done.clone(), validated=True, @@ -3307,7 +3322,7 @@ def maybe_reset(self, tensordict: TensorDictBase) -> TensorDictBase: key="_reset", ) if any_done: - tensordict = self.reset(tensordict) + return self.reset(tensordict, select_reset_only=True) return tensordict def empty_cache(self): diff --git a/torchrl/envs/custom/chess.py b/torchrl/envs/custom/chess.py index 4dc5dbe5321..ebd23e18452 100644 --- a/torchrl/envs/custom/chess.py +++ b/torchrl/envs/custom/chess.py @@ -4,85 +4,177 @@ # LICENSE file in the root directory of this source tree. from __future__ import annotations -from typing import Dict, Optional +import importlib.util +import io +import pathlib +from typing import Dict import torch +from PIL import Image from tensordict import TensorDict, TensorDictBase -from torchrl.data import Categorical, Composite, NonTensor, Unbounded +from torchrl.data import Binary, Bounded, Categorical, Composite, NonTensor, Unbounded from torchrl.envs import EnvBase +from torchrl.envs.common import _EnvPostInit from torchrl.envs.utils import _classproperty -class ChessEnv(EnvBase): - """A chess environment that follows the TorchRL API. +class _ChessMeta(_EnvPostInit): + def __call__(cls, *args, **kwargs): + instance = super().__call__(*args, **kwargs) + if kwargs.get("include_hash"): + from torchrl.envs import Hash + + in_keys = [] + out_keys = [] + if instance.include_san: + in_keys.append("san") + out_keys.append("san_hash") + if instance.include_fen: + in_keys.append("fen") + out_keys.append("fen_hash") + if instance.include_pgn: + in_keys.append("pgn") + out_keys.append("pgn_hash") + instance = instance.append_transform(Hash(in_keys, out_keys)) + if kwargs.get("mask_actions", True): + from torchrl.envs import ActionMask + + instance = instance.append_transform(ActionMask()) + return instance + + +class ChessEnv(EnvBase, metaclass=_ChessMeta): + r"""A chess environment that follows the TorchRL API. + + This environment simulates a chess game using the `chess` library. It supports various state representations + and can be configured to include different types of observations such as SAN, FEN, PGN, and legal moves. Requires: the `chess` library. More info `here `__. Args: stateful (bool): Whether to keep track of the internal state of the board. If False, the state will be stored in the observation and passed back - to the environment on each call. Default: ``False``. + to the environment on each call. Default: ``True``. + include_san (bool): Whether to include SAN (Standard Algebraic Notation) in the observations. Default: ``False``. - .. note:: the action spec is a :class:`~torchrl.data.Categorical` spec with a ``-1`` shape. - Unless :meth:`~torchrl.data.Categorical.set_provisional_n` is called with the cardinality of the legal moves, - valid random actions cannot be taken. :meth:`~torchrl.envs.EnvBase.rand_action` has been adapted to account for - this behavior. + .. note:: The `"san"` entry corresponding to `rollout["action"]` will be found in `rollout["next", "san"]`, + whereas the value at the root `rollout["san"]` will correspond to the value of the san preceding the + same index action. + + include_fen (bool): Whether to include FEN (Forsyth-Edwards Notation) in the observations. Default: ``False``. + include_pgn (bool): Whether to include PGN (Portable Game Notation) in the observations. Default: ``False``. + include_legal_moves (bool): Whether to include legal moves in the observations. Default: ``False``. + include_hash (bool): Whether to include hash transformations in the environment. Default: ``False``. + mask_actions (bool): if ``True``, a :class:`~torchrl.envs.ActionMask` transform will be appended + to the env to make sure that the actions are properly masked. Default: ``True``. + pixels (bool): Whether to include pixel-based observations of the board. Default: ``False``. + + .. note:: The action spec is a :class:`~torchrl.data.Categorical` with a number of actions equal to the number of possible SAN moves. + The action space is structured as a categorical distribution over all possible SAN moves, with the legal moves + being a subset of this space. The environment uses a mask to ensure only legal moves are selected. Examples: - >>> env = ChessEnv() + >>> import torch + >>> from torchrl.envs import ChessEnv + >>> _ = torch.manual_seed(0) + >>> env = ChessEnv(include_fen=True, include_san=True, include_pgn=True, include_legal_moves=True) + >>> print(env) + TransformedEnv( + env=ChessEnv(), + transform=ActionMask(keys=['action', 'action_mask'])) >>> r = env.reset() - >>> env.rand_step(r) + >>> print(env.rand_step(r)) TensorDict( fields={ action: Tensor(shape=torch.Size([]), device=cpu, dtype=torch.int64, is_shared=False), + action_mask: Tensor(shape=torch.Size([29275]), device=cpu, dtype=torch.bool, is_shared=False), done: Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.bool, is_shared=False), fen: NonTensorData(data=rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1, batch_size=torch.Size([]), device=None), - hashing: Tensor(shape=torch.Size([]), device=cpu, dtype=torch.int64, is_shared=False), + legal_moves: Tensor(shape=torch.Size([219]), device=cpu, dtype=torch.int64, is_shared=False), next: TensorDict( fields={ + action_mask: Tensor(shape=torch.Size([29275]), device=cpu, dtype=torch.bool, is_shared=False), done: Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.bool, is_shared=False), - fen: NonTensorData(data=rnbqkbnr/pppppppp/8/8/8/2N5/PPPPPPPP/R1BQKBNR b KQkq - 1 1, batch_size=torch.Size([]), device=None), - hashing: Tensor(shape=torch.Size([]), device=cpu, dtype=torch.int64, is_shared=False), - reward: Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.int32, is_shared=False), + fen: NonTensorData(data=rnbqkbnr/pppppppp/8/8/5P2/8/PPPPP1PP/RNBQKBNR b KQkq - 0 1, batch_size=torch.Size([]), device=None), + legal_moves: Tensor(shape=torch.Size([219]), device=cpu, dtype=torch.int64, is_shared=False), + pgn: NonTensorData(data=[Event "?"] + [Site "?"] + [Date "????.??.??"] + [Round "?"] + [White "?"] + [Black "?"] + [Result "*"] + + 1. f4 *, batch_size=torch.Size([]), device=None), + reward: Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.float32, is_shared=False), + san: NonTensorData(data=f4, batch_size=torch.Size([]), device=None), terminated: Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.bool, is_shared=False), turn: Tensor(shape=torch.Size([]), device=cpu, dtype=torch.bool, is_shared=False)}, batch_size=torch.Size([]), device=None, is_shared=False), + pgn: NonTensorData(data=[Event "?"] + [Site "?"] + [Date "????.??.??"] + [Round "?"] + [White "?"] + [Black "?"] + [Result "*"] + + *, batch_size=torch.Size([]), device=None), + san: NonTensorData(data=, batch_size=torch.Size([]), device=None), terminated: Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.bool, is_shared=False), turn: Tensor(shape=torch.Size([]), device=cpu, dtype=torch.bool, is_shared=False)}, batch_size=torch.Size([]), device=None, is_shared=False) - >>> env.rollout(1000) + >>> print(env.rollout(1000)) TensorDict( fields={ - action: Tensor(shape=torch.Size([322]), device=cpu, dtype=torch.int64, is_shared=False), - done: Tensor(shape=torch.Size([322, 1]), device=cpu, dtype=torch.bool, is_shared=False), + action: Tensor(shape=torch.Size([96]), device=cpu, dtype=torch.int64, is_shared=False), + action_mask: Tensor(shape=torch.Size([96, 29275]), device=cpu, dtype=torch.bool, is_shared=False), + done: Tensor(shape=torch.Size([96, 1]), device=cpu, dtype=torch.bool, is_shared=False), fen: NonTensorStack( ['rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQ..., - batch_size=torch.Size([322]), + batch_size=torch.Size([96]), device=None), - hashing: Tensor(shape=torch.Size([322]), device=cpu, dtype=torch.int64, is_shared=False), + legal_moves: Tensor(shape=torch.Size([96, 219]), device=cpu, dtype=torch.int64, is_shared=False), next: TensorDict( fields={ - done: Tensor(shape=torch.Size([322, 1]), device=cpu, dtype=torch.bool, is_shared=False), + action_mask: Tensor(shape=torch.Size([96, 29275]), device=cpu, dtype=torch.bool, is_shared=False), + done: Tensor(shape=torch.Size([96, 1]), device=cpu, dtype=torch.bool, is_shared=False), fen: NonTensorStack( - ['rnbqkbnr/pppppppp/8/8/2P5/8/PP1PPPPP/RNBQKBNR b ..., - batch_size=torch.Size([322]), + ['rnbqkbnr/pppppppp/8/8/8/5N2/PPPPPPPP/RNBQKB1R b ..., + batch_size=torch.Size([96]), + device=None), + legal_moves: Tensor(shape=torch.Size([96, 219]), device=cpu, dtype=torch.int64, is_shared=False), + pgn: NonTensorStack( + ['[Event "?"]\n[Site "?"]\n[Date "????.??.??"]\n[R..., + batch_size=torch.Size([96]), device=None), - hashing: Tensor(shape=torch.Size([322]), device=cpu, dtype=torch.int64, is_shared=False), - reward: Tensor(shape=torch.Size([322, 1]), device=cpu, dtype=torch.int32, is_shared=False), - terminated: Tensor(shape=torch.Size([322, 1]), device=cpu, dtype=torch.bool, is_shared=False), - turn: Tensor(shape=torch.Size([322]), device=cpu, dtype=torch.bool, is_shared=False)}, - batch_size=torch.Size([322]), + reward: Tensor(shape=torch.Size([96, 1]), device=cpu, dtype=torch.float32, is_shared=False), + san: NonTensorStack( + ['Nf3', 'Na6', 'c4', 'f6', 'h4', 'Rb8', 'Na3', 'Ra..., + batch_size=torch.Size([96]), + device=None), + terminated: Tensor(shape=torch.Size([96, 1]), device=cpu, dtype=torch.bool, is_shared=False), + turn: Tensor(shape=torch.Size([96]), device=cpu, dtype=torch.bool, is_shared=False)}, + batch_size=torch.Size([96]), device=None, is_shared=False), - terminated: Tensor(shape=torch.Size([322, 1]), device=cpu, dtype=torch.bool, is_shared=False), - turn: Tensor(shape=torch.Size([322]), device=cpu, dtype=torch.bool, is_shared=False)}, - batch_size=torch.Size([322]), + pgn: NonTensorStack( + ['[Event "?"]\n[Site "?"]\n[Date "????.??.??"]\n[R..., + batch_size=torch.Size([96]), + device=None), + san: NonTensorStack( + ['', 'Nf3', 'Na6', 'c4', 'f6', 'h4', 'Rb8',..., + batch_size=torch.Size([96]), + device=None), + terminated: Tensor(shape=torch.Size([96, 1]), device=cpu, dtype=torch.bool, is_shared=False), + turn: Tensor(shape=torch.Size([96]), device=cpu, dtype=torch.bool, is_shared=False)}, + batch_size=torch.Size([96]), device=None, is_shared=False) @@ -90,84 +182,296 @@ class ChessEnv(EnvBase): """ _hash_table: Dict[int, str] = {} + _PGN_RESTART = """[Event "?"] +[Site "?"] +[Date "????.??.??"] +[Round "?"] +[White "?"] +[Black "?"] +[Result "*"] + +*""" @_classproperty def lib(cls): try: import chess + import chess.pgn except ImportError: raise ImportError( "The `chess` library could not be found. Make sure you installed it through `pip install chess`." ) return chess - def __init__(self, stateful: bool = False): + _san_moves = [] + + @_classproperty + def san_moves(cls): + if not cls._san_moves: + with open(pathlib.Path(__file__).parent / "san_moves.txt", "r+") as f: + cls._san_moves.extend(f.read().split("\n")) + return cls._san_moves + + def _legal_moves_to_index( + self, + tensordict: TensorDictBase | None = None, + board: "chess.Board" | None = None, # noqa: F821 + return_mask: bool = False, + pad: bool = False, + ) -> torch.Tensor: + if not self.stateful: + if tensordict is None: + # trust the board + pass + elif self.include_fen: + fen = tensordict.get("fen", None) + fen = fen.data + self.board.set_fen(fen) + board = self.board + elif self.include_pgn: + pgn = tensordict.get("pgn") + pgn = pgn.data + board = self._pgn_to_board(pgn, self.board) + + if board is None: + board = self.board + + indices = torch.tensor( + [self._san_moves.index(board.san(m)) for m in board.legal_moves], + dtype=torch.int64, + ) + mask = None + if return_mask: + mask = self._move_index_to_mask(indices) + if pad: + indices = torch.nn.functional.pad( + indices, [0, 218 - indices.numel() + 1], value=len(self.san_moves) + ) + if return_mask: + return indices, mask + return indices + + @classmethod + def _move_index_to_mask(cls, indices: torch.Tensor) -> torch.Tensor: + return torch.zeros(len(cls.san_moves), dtype=torch.bool).index_fill_( + 0, indices, True + ) + + def __init__( + self, + *, + stateful: bool = True, + include_san: bool = False, + include_fen: bool = False, + include_pgn: bool = False, + include_legal_moves: bool = False, + include_hash: bool = False, + mask_actions: bool = True, + pixels: bool = False, + ): chess = self.lib super().__init__() self.full_observation_spec = Composite( - hashing=Unbounded(shape=(), dtype=torch.int64), - fen=NonTensor(shape=()), turn=Categorical(n=2, dtype=torch.bool, shape=()), ) + self.include_san = include_san + self.include_fen = include_fen + self.include_pgn = include_pgn + self.mask_actions = mask_actions + self.include_legal_moves = include_legal_moves + if include_legal_moves: + # 218 max possible legal moves per chess board position + # https://www.stmintz.com/ccc/index.php?id=424966 + # len(self.san_moves)+1 is the padding value + self.full_observation_spec["legal_moves"] = Bounded( + 0, 1 + len(self.san_moves), shape=(218,), dtype=torch.int64 + ) + if include_san: + self.full_observation_spec["san"] = NonTensor(shape=(), example_data="Nc6") + if include_pgn: + self.full_observation_spec["pgn"] = NonTensor( + shape=(), example_data=self._PGN_RESTART + ) + if include_fen: + self.full_observation_spec["fen"] = NonTensor(shape=(), example_data="any") + if not stateful and not (include_pgn or include_fen): + raise RuntimeError( + "At least one state representation (pgn or fen) must be enabled when stateful " + f"is {stateful}." + ) + self.stateful = stateful - if not self.stateful: - self.full_state_spec = self.full_observation_spec.clone() + + # state_spec is loosely defined as such - it's not really an issue that extra keys + # can go missing but it allows us to reset the env using fen passed to the reset + # method. + self.full_state_spec = self.full_observation_spec.clone() + + self.pixels = pixels + if pixels: + if importlib.util.find_spec("cairosvg") is None: + raise ImportError( + "Please install cairosvg to use this environment with pixel rendering." + ) + if importlib.util.find_spec("torchvision") is None: + raise ImportError( + "Please install torchvision to use this environment with pixel rendering." + ) + self.full_observation_spec["pixels"] = Unbounded(shape=()) + self.full_action_spec = Composite( - action=Categorical(n=-1, shape=(), dtype=torch.int64) + action=Categorical(n=len(self.san_moves), shape=(), dtype=torch.int64) ) self.full_reward_spec = Composite( - reward=Unbounded(shape=(1,), dtype=torch.int32) + reward=Unbounded(shape=(1,), dtype=torch.float32) ) + if self.mask_actions: + self.full_observation_spec["action_mask"] = Binary( + n=len(self.san_moves), dtype=torch.bool + ) + # done spec generated automatically self.board = chess.Board() if self.stateful: self.action_spec.set_provisional_n(len(list(self.board.legal_moves))) - def rand_action(self, tensordict: Optional[TensorDictBase] = None): - self._set_action_space(tensordict) - return super().rand_action(tensordict) - def _is_done(self, board): return board.is_game_over() | board.is_fifty_moves() def _reset(self, tensordict=None): fen = None + pgn = None if tensordict is not None: - fen = self._get_fen(tensordict).data dest = tensordict.empty() + if self.include_fen: + fen = tensordict.get("fen", None) + if fen is not None: + fen = fen.data + elif self.include_pgn: + pgn = tensordict.get("pgn", None) + if pgn is not None: + pgn = pgn.data else: dest = TensorDict() - if fen is None: + if fen is None and pgn is None: self.board.reset() - fen = self.board.fen() - else: + elif fen is not None: self.board.set_fen(fen) if self._is_done(self.board): raise ValueError( "Cannot reset to a fen that is a gameover state." f" fen: {fen}" ) + elif pgn is not None: + self.board = self._pgn_to_board(pgn) - hashing = hash(fen) + if self.include_fen and fen is None: + fen = self.board.fen() + if self.include_pgn and pgn is None: + pgn = self._board_to_pgn(self.board) - self._set_action_space() turn = self.board.turn - return dest.set("fen", fen).set("hashing", hashing).set("turn", turn) + if self.include_san: + if self.board.move_stack: + move = self.board.peek() + else: + move = None + if move is None: + dest.set("san", "") + else: + dest.set("san", self.board.san(move)) + if self.include_fen: + dest.set("fen", fen) + if self.include_pgn: + dest.set("pgn", pgn) + dest.set("turn", turn) + if self.include_legal_moves: + moves_idx = self._legal_moves_to_index( + board=self.board, pad=True, return_mask=self.mask_actions + ) + if self.mask_actions: + moves_idx, mask = moves_idx + dest.set("action_mask", mask) + dest.set("legal_moves", moves_idx) + elif self.mask_actions: + dest.set( + "action_mask", + self._legal_moves_to_index( + board=self.board, pad=True, return_mask=True + )[1], + ) - def _set_action_space(self, tensordict: TensorDict | None = None): - if not self.stateful and tensordict is not None: - fen = self._get_fen(tensordict).data - self.board.set_fen(fen) - self.action_spec.set_provisional_n(self.board.legal_moves.count()) + if self.pixels: + dest.set("pixels", self._get_tensor_image(board=self.board)) + return dest + + _cairosvg_lib = None + + @_classproperty + def _cairosvg(cls): + csvg = cls._cairosvg_lib + if csvg is None: + import cairosvg + + csvg = cls._cairosvg_lib = cairosvg + return csvg + + _torchvision_lib = None + + @_classproperty + def _torchvision(cls): + tv = cls._torchvision_lib + if tv is None: + import torchvision + + tv = cls._torchvision_lib = torchvision + return tv + + @classmethod + def _get_tensor_image(cls, board): + try: + svg = board._repr_svg_() + # Convert SVG to PNG using cairosvg + png_data = io.BytesIO() + cls._cairosvg.svg2png(bytestring=svg.encode("utf-8"), write_to=png_data) + png_data.seek(0) + # Open the PNG image using Pillow + img = Image.open(png_data) + img = cls._torchvision.transforms.functional.pil_to_tensor(img) + except ImportError: + raise ImportError( + "Chess rendering requires cairosvg and torchvision to be installed." + ) + return img + + @classmethod + def _pgn_to_board( + cls, pgn_string: str, board: "chess.Board" | None = None # noqa: F821 + ) -> "chess.Board": # noqa: F821 + pgn_io = io.StringIO(pgn_string) + game = cls.lib.pgn.read_game(pgn_io) + if board is None: + board = cls.lib.Board() + else: + board.reset() + for move in game.mainline_moves(): + board.push(move) + return board + + @classmethod + def _add_move_to_pgn(cls, pgn_string: str, move: "chess.Move") -> str: # noqa: F821 + pgn_io = io.StringIO(pgn_string) + game = cls.lib.pgn.read_game(pgn_io) + if game is None: + raise ValueError("Invalid PGN string") + game.end().add_variation(move) + return str(game) @classmethod - def _get_fen(cls, tensordict): - fen = tensordict.get("fen", None) - if fen is None: - hashing = tensordict.get("hashing", None) - if hashing is not None: - fen = cls._hash_table.get(hashing.item()) - return fen + def _board_to_pgn(cls, board: "chess.Board") -> str: # noqa: F821 + game = cls.lib.pgn.Game.from_board(board) + pgn_string = str(game) + return pgn_string def get_legal_moves(self, tensordict=None, uci=False): """List the legal moves in a position. @@ -192,7 +496,7 @@ def get_legal_moves(self, tensordict=None, uci=False): raise ValueError( "tensordict must be given since this env is not stateful" ) - fen = self._get_fen(tensordict).data + fen = tensordict.get("fen").data board.set_fen(fen) moves = board.legal_moves @@ -205,33 +509,75 @@ def _step(self, tensordict): # action action = tensordict.get("action") board = self.board + + pgn = None + fen = None if not self.stateful: - fen = self._get_fen(tensordict).data - board.set_fen(fen) - action = list(board.legal_moves)[action] - board.push(action) - self._set_action_space() + if self.include_fen: + fen = tensordict.get("fen").data + board.set_fen(fen) + elif self.include_pgn: + pgn = tensordict.get("pgn").data + board = self._pgn_to_board(pgn, board) + else: + raise RuntimeError( + "Not enough information to deduce the board. If stateful=False, include_pgn or include_fen must be True." + ) + + san = self.san_moves[action] + board.push_san(san) - # Collect data - fen = self.board.fen() dest = tensordict.empty() - hashing = hash(fen) - dest.set("fen", fen) - dest.set("hashing", hashing) + + # Collect data + if self.include_fen: + fen = board.fen() + dest.set("fen", fen) + + if self.include_pgn: + if pgn is not None: + pgn = self._add_move_to_pgn(pgn, board.move_stack[-1]) + else: + pgn = self._board_to_pgn(board) + dest.set("pgn", pgn) + + if self.include_san: + dest.set("san", san) + + if self.include_legal_moves: + moves_idx = self._legal_moves_to_index( + board=board, pad=True, return_mask=self.mask_actions + ) + if self.mask_actions: + moves_idx, mask = moves_idx + dest.set("action_mask", mask) + dest.set("legal_moves", moves_idx) + elif self.mask_actions: + dest.set( + "action_mask", + self._legal_moves_to_index( + board=self.board, pad=True, return_mask=True + )[1], + ) turn = torch.tensor(board.turn) + done = self._is_done(board) if board.is_checkmate(): # turn flips after every move, even if the game is over - winner = not turn - reward_val = 1 if winner == self.lib.WHITE else -1 + # winner = not turn + reward_val = 1 # if winner == self.lib.WHITE else 0 + elif done: + reward_val = 0.5 else: - reward_val = 0 - reward = torch.tensor([reward_val], dtype=torch.int32) - done = self._is_done(board) + reward_val = 0.0 + + reward = torch.tensor([reward_val], dtype=torch.float32) dest.set("reward", reward) dest.set("turn", turn) dest.set("done", [done]) dest.set("terminated", [done]) + if self.pixels: + dest.set("pixels", self._get_tensor_image(board=self.board)) return dest def _set_seed(self, *args, **kwargs): diff --git a/torchrl/envs/custom/san_moves.txt b/torchrl/envs/custom/san_moves.txt new file mode 100644 index 00000000000..3a4ef3e1af1 --- /dev/null +++ b/torchrl/envs/custom/san_moves.txt @@ -0,0 +1,29274 @@ +a2 +a3 +a4 +a5 +a6 +a7 +b2 +b3 +b4 +b5 +b6 +b7 +c2 +c3 +c4 +c5 +c6 +c7 +d2 +d3 +d4 +d5 +d6 +d7 +e2 +e3 +e4 +e5 +e6 +e7 +f2 +f3 +f4 +f5 +f6 +f7 +g2 +g3 +g4 +g5 +g6 +g7 +h2 +h3 +h4 +h5 +h6 +h7 +Ba1 +Ba2 +Ba3 +Ba4 +Ba5 +Ba6 +Ba7 +Ba8 +Bb1 +Bb2 +Bb3 +Bb4 +Bb5 +Bb6 +Bb7 +Bb8 +Bc1 +Bc2 +Bc3 +Bc4 +Bc5 +Bc6 +Bc7 +Bc8 +Bd1 +Bd2 +Bd3 +Bd4 +Bd5 +Bd6 +Bd7 +Bd8 +Be1 +Be2 +Be3 +Be4 +Be5 +Be6 +Be7 +Be8 +Bf1 +Bf2 +Bf3 +Bf4 +Bf5 +Bf6 +Bf7 +Bf8 +Bg1 +Bg2 +Bg3 +Bg4 +Bg5 +Bg6 +Bg7 +Bg8 +Bh1 +Bh2 +Bh3 +Bh4 +Bh5 +Bh6 +Bh7 +Bh8 +Ka1 +Ka2 +Ka3 +Ka4 +Ka5 +Ka6 +Ka7 +Ka8 +Kb1 +Kb2 +Kb3 +Kb4 +Kb5 +Kb6 +Kb7 +Kb8 +Kc1 +Kc2 +Kc3 +Kc4 +Kc5 +Kc6 +Kc7 +Kc8 +Kd1 +Kd2 +Kd3 +Kd4 +Kd5 +Kd6 +Kd7 +Kd8 +Ke1 +Ke2 +Ke3 +Ke4 +Ke5 +Ke6 +Ke7 +Ke8 +Kf1 +Kf2 +Kf3 +Kf4 +Kf5 +Kf6 +Kf7 +Kf8 +Kg1 +Kg2 +Kg3 +Kg4 +Kg5 +Kg6 +Kg7 +Kg8 +Kh1 +Kh2 +Kh3 +Kh4 +Kh5 +Kh6 +Kh7 +Kh8 +Na1 +Na2 +Na3 +Na4 +Na5 +Na6 +Na7 +Na8 +Nb1 +Nb2 +Nb3 +Nb4 +Nb5 +Nb6 +Nb7 +Nb8 +Nc1 +Nc2 +Nc3 +Nc4 +Nc5 +Nc6 +Nc7 +Nc8 +Nd1 +Nd2 +Nd3 +Nd4 +Nd5 +Nd6 +Nd7 +Nd8 +Ne1 +Ne2 +Ne3 +Ne4 +Ne5 +Ne6 +Ne7 +Ne8 +Nf1 +Nf2 +Nf3 +Nf4 +Nf5 +Nf6 +Nf7 +Nf8 +Ng1 +Ng2 +Ng3 +Ng4 +Ng5 +Ng6 +Ng7 +Ng8 +Nh1 +Nh2 +Nh3 +Nh4 +Nh5 +Nh6 +Nh7 +Nh8 +O-O +Qa1 +Qa2 +Qa3 +Qa4 +Qa5 +Qa6 +Qa7 +Qa8 +Qb1 +Qb2 +Qb3 +Qb4 +Qb5 +Qb6 +Qb7 +Qb8 +Qc1 +Qc2 +Qc3 +Qc4 +Qc5 +Qc6 +Qc7 +Qc8 +Qd1 +Qd2 +Qd3 +Qd4 +Qd5 +Qd6 +Qd7 +Qd8 +Qe1 +Qe2 +Qe3 +Qe4 +Qe5 +Qe6 +Qe7 +Qe8 +Qf1 +Qf2 +Qf3 +Qf4 +Qf5 +Qf6 +Qf7 +Qf8 +Qg1 +Qg2 +Qg3 +Qg4 +Qg5 +Qg6 +Qg7 +Qg8 +Qh1 +Qh2 +Qh3 +Qh4 +Qh5 +Qh6 +Qh7 +Qh8 +Ra1 +Ra2 +Ra3 +Ra4 +Ra5 +Ra6 +Ra7 +Ra8 +Rb1 +Rb2 +Rb3 +Rb4 +Rb5 +Rb6 +Rb7 +Rb8 +Rc1 +Rc2 +Rc3 +Rc4 +Rc5 +Rc6 +Rc7 +Rc8 +Rd1 +Rd2 +Rd3 +Rd4 +Rd5 +Rd6 +Rd7 +Rd8 +Re1 +Re2 +Re3 +Re4 +Re5 +Re6 +Re7 +Re8 +Rf1 +Rf2 +Rf3 +Rf4 +Rf5 +Rf6 +Rf7 +Rf8 +Rg1 +Rg2 +Rg3 +Rg4 +Rg5 +Rg6 +Rg7 +Rg8 +Rh1 +Rh2 +Rh3 +Rh4 +Rh5 +Rh6 +Rh7 +Rh8 +a2# +a2+ +a3# +a3+ +a4# +a4+ +a5# +a5+ +a6# +a6+ +a7# +a7+ +b2# +b2+ +b3# +b3+ +b4# +b4+ +b5# +b5+ +b6# +b6+ +b7# +b7+ +c2# +c2+ +c3# +c3+ +c4# +c4+ +c5# +c5+ +c6# +c6+ +c7# +c7+ +d2# +d2+ +d3# +d3+ +d4# +d4+ +d5# +d5+ +d6# +d6+ +d7# +d7+ +e2# +e2+ +e3# +e3+ +e4# +e4+ +e5# +e5+ +e6# +e6+ +e7# +e7+ +f2# +f2+ +f3# +f3+ +f4# +f4+ +f5# +f5+ +f6# +f6+ +f7# +f7+ +g2# +g2+ +g3# +g3+ +g4# +g4+ +g5# +g5+ +g6# +g6+ +g7# +g7+ +h2# +h2+ +h3# +h3+ +h4# +h4+ +h5# +h5+ +h6# +h6+ +h7# +h7+ +B1a2 +B1a3 +B1a4 +B1b2 +B1b3 +B1b4 +B1c2 +B1c3 +B1c4 +B1d2 +B1d3 +B1d4 +B1e2 +B1e3 +B1e4 +B1f2 +B1f3 +B1f4 +B1g2 +B1g3 +B1g4 +B1h2 +B1h3 +B1h4 +B2a3 +B2a4 +B2a5 +B2b3 +B2b4 +B2b5 +B2c3 +B2c4 +B2c5 +B2d3 +B2d4 +B2d5 +B2e3 +B2e4 +B2e5 +B2f3 +B2f4 +B2f5 +B2g3 +B2g4 +B2g5 +B2h3 +B2h4 +B2h5 +B3a2 +B3a4 +B3a5 +B3b2 +B3b4 +B3b5 +B3c2 +B3c4 +B3c5 +B3d2 +B3d4 +B3d5 +B3e2 +B3e4 +B3e5 +B3f2 +B3f4 +B3f5 +B3g2 +B3g4 +B3g5 +B3h2 +B3h4 +B3h5 +B4a3 +B4a5 +B4a6 +B4b3 +B4b5 +B4b6 +B4c3 +B4c5 +B4c6 +B4d3 +B4d5 +B4d6 +B4e3 +B4e5 +B4e6 +B4f3 +B4f5 +B4f6 +B4g3 +B4g5 +B4g6 +B4h3 +B4h5 +B4h6 +B5a3 +B5a4 +B5a6 +B5b3 +B5b4 +B5b6 +B5c3 +B5c4 +B5c6 +B5d3 +B5d4 +B5d6 +B5e3 +B5e4 +B5e6 +B5f3 +B5f4 +B5f6 +B5g3 +B5g4 +B5g6 +B5h3 +B5h4 +B5h6 +B6a4 +B6a5 +B6a7 +B6b4 +B6b5 +B6b7 +B6c4 +B6c5 +B6c7 +B6d4 +B6d5 +B6d7 +B6e4 +B6e5 +B6e7 +B6f4 +B6f5 +B6f7 +B6g4 +B6g5 +B6g7 +B6h4 +B6h5 +B6h7 +B7a4 +B7a5 +B7a6 +B7b4 +B7b5 +B7b6 +B7c4 +B7c5 +B7c6 +B7d4 +B7d5 +B7d6 +B7e4 +B7e5 +B7e6 +B7f4 +B7f5 +B7f6 +B7g4 +B7g5 +B7g6 +B7h4 +B7h5 +B7h6 +B8a5 +B8a6 +B8a7 +B8b5 +B8b6 +B8b7 +B8c5 +B8c6 +B8c7 +B8d5 +B8d6 +B8d7 +B8e5 +B8e6 +B8e7 +B8f5 +B8f6 +B8f7 +B8g5 +B8g6 +B8g7 +B8h5 +B8h6 +B8h7 +Ba1# +Ba1+ +Ba2# +Ba2+ +Ba3# +Ba3+ +Ba4# +Ba4+ +Ba5# +Ba5+ +Ba6# +Ba6+ +Ba7# +Ba7+ +Ba8# +Ba8+ +Bab1 +Bab2 +Bab3 +Bab4 +Bab5 +Bab6 +Bab7 +Bab8 +Bac1 +Bac2 +Bac3 +Bac4 +Bac5 +Bac6 +Bac7 +Bac8 +Bad1 +Bad2 +Bad3 +Bad4 +Bad5 +Bad6 +Bad7 +Bad8 +Bae1 +Bae2 +Bae3 +Bae4 +Bae5 +Bae6 +Bae7 +Bae8 +Baf1 +Baf2 +Baf3 +Baf6 +Baf7 +Baf8 +Bag1 +Bag2 +Bag7 +Bag8 +Bb1# +Bb1+ +Bb2# +Bb2+ +Bb3# +Bb3+ +Bb4# +Bb4+ +Bb5# +Bb5+ +Bb6# +Bb6+ +Bb7# +Bb7+ +Bb8# +Bb8+ +Bba2 +Bba3 +Bba4 +Bba5 +Bba6 +Bba7 +Bbc1 +Bbc2 +Bbc3 +Bbc4 +Bbc5 +Bbc6 +Bbc7 +Bbc8 +Bbd1 +Bbd2 +Bbd3 +Bbd4 +Bbd5 +Bbd6 +Bbd7 +Bbd8 +Bbe1 +Bbe2 +Bbe3 +Bbe4 +Bbe5 +Bbe6 +Bbe7 +Bbe8 +Bbf1 +Bbf2 +Bbf3 +Bbf4 +Bbf5 +Bbf6 +Bbf7 +Bbf8 +Bbg1 +Bbg2 +Bbg3 +Bbg6 +Bbg7 +Bbg8 +Bbh2 +Bbh7 +Bc1# +Bc1+ +Bc2# +Bc2+ +Bc3# +Bc3+ +Bc4# +Bc4+ +Bc5# +Bc5+ +Bc6# +Bc6+ +Bc7# +Bc7+ +Bc8# +Bc8+ +Bca2 +Bca3 +Bca4 +Bca5 +Bca6 +Bca7 +Bcb1 +Bcb2 +Bcb3 +Bcb4 +Bcb5 +Bcb6 +Bcb7 +Bcb8 +Bcd1 +Bcd2 +Bcd3 +Bcd4 +Bcd5 +Bcd6 +Bcd7 +Bcd8 +Bce1 +Bce2 +Bce3 +Bce4 +Bce5 +Bce6 +Bce7 +Bce8 +Bcf1 +Bcf2 +Bcf3 +Bcf4 +Bcf5 +Bcf6 +Bcf7 +Bcf8 +Bcg1 +Bcg2 +Bcg3 +Bcg4 +Bcg5 +Bcg6 +Bcg7 +Bcg8 +Bch2 +Bch3 +Bch6 +Bch7 +Bd1# +Bd1+ +Bd2# +Bd2+ +Bd3# +Bd3+ +Bd4# +Bd4+ +Bd5# +Bd5+ +Bd6# +Bd6+ +Bd7# +Bd7+ +Bd8# +Bd8+ +Bda2 +Bda3 +Bda4 +Bda5 +Bda6 +Bda7 +Bdb1 +Bdb2 +Bdb3 +Bdb4 +Bdb5 +Bdb6 +Bdb7 +Bdb8 +Bdc1 +Bdc2 +Bdc3 +Bdc4 +Bdc5 +Bdc6 +Bdc7 +Bdc8 +Bde1 +Bde2 +Bde3 +Bde4 +Bde5 +Bde6 +Bde7 +Bde8 +Bdf1 +Bdf2 +Bdf3 +Bdf4 +Bdf5 +Bdf6 +Bdf7 +Bdf8 +Bdg1 +Bdg2 +Bdg3 +Bdg4 +Bdg5 +Bdg6 +Bdg7 +Bdg8 +Bdh2 +Bdh3 +Bdh4 +Bdh5 +Bdh6 +Bdh7 +Be1# +Be1+ +Be2# +Be2+ +Be3# +Be3+ +Be4# +Be4+ +Be5# +Be5+ +Be6# +Be6+ +Be7# +Be7+ +Be8# +Be8+ +Bea2 +Bea3 +Bea4 +Bea5 +Bea6 +Bea7 +Beb1 +Beb2 +Beb3 +Beb4 +Beb5 +Beb6 +Beb7 +Beb8 +Bec1 +Bec2 +Bec3 +Bec4 +Bec5 +Bec6 +Bec7 +Bec8 +Bed1 +Bed2 +Bed3 +Bed4 +Bed5 +Bed6 +Bed7 +Bed8 +Bef1 +Bef2 +Bef3 +Bef4 +Bef5 +Bef6 +Bef7 +Bef8 +Beg1 +Beg2 +Beg3 +Beg4 +Beg5 +Beg6 +Beg7 +Beg8 +Beh2 +Beh3 +Beh4 +Beh5 +Beh6 +Beh7 +Bf1# +Bf1+ +Bf2# +Bf2+ +Bf3# +Bf3+ +Bf4# +Bf4+ +Bf5# +Bf5+ +Bf6# +Bf6+ +Bf7# +Bf7+ +Bf8# +Bf8+ +Bfa2 +Bfa3 +Bfa6 +Bfa7 +Bfb1 +Bfb2 +Bfb3 +Bfb4 +Bfb5 +Bfb6 +Bfb7 +Bfb8 +Bfc1 +Bfc2 +Bfc3 +Bfc4 +Bfc5 +Bfc6 +Bfc7 +Bfc8 +Bfd1 +Bfd2 +Bfd3 +Bfd4 +Bfd5 +Bfd6 +Bfd7 +Bfd8 +Bfe1 +Bfe2 +Bfe3 +Bfe4 +Bfe5 +Bfe6 +Bfe7 +Bfe8 +Bfg1 +Bfg2 +Bfg3 +Bfg4 +Bfg5 +Bfg6 +Bfg7 +Bfg8 +Bfh2 +Bfh3 +Bfh4 +Bfh5 +Bfh6 +Bfh7 +Bg1# +Bg1+ +Bg2# +Bg2+ +Bg3# +Bg3+ +Bg4# +Bg4+ +Bg5# +Bg5+ +Bg6# +Bg6+ +Bg7# +Bg7+ +Bg8# +Bg8+ +Bga2 +Bga7 +Bgb1 +Bgb2 +Bgb3 +Bgb6 +Bgb7 +Bgb8 +Bgc1 +Bgc2 +Bgc3 +Bgc4 +Bgc5 +Bgc6 +Bgc7 +Bgc8 +Bgd1 +Bgd2 +Bgd3 +Bgd4 +Bgd5 +Bgd6 +Bgd7 +Bgd8 +Bge1 +Bge2 +Bge3 +Bge4 +Bge5 +Bge6 +Bge7 +Bge8 +Bgf1 +Bgf2 +Bgf3 +Bgf4 +Bgf5 +Bgf6 +Bgf7 +Bgf8 +Bgh2 +Bgh3 +Bgh4 +Bgh5 +Bgh6 +Bgh7 +Bh1# +Bh1+ +Bh2# +Bh2+ +Bh3# +Bh3+ +Bh4# +Bh4+ +Bh5# +Bh5+ +Bh6# +Bh6+ +Bh7# +Bh7+ +Bh8# +Bh8+ +Bhb1 +Bhb2 +Bhb7 +Bhb8 +Bhc1 +Bhc2 +Bhc3 +Bhc6 +Bhc7 +Bhc8 +Bhd1 +Bhd2 +Bhd3 +Bhd4 +Bhd5 +Bhd6 +Bhd7 +Bhd8 +Bhe1 +Bhe2 +Bhe3 +Bhe4 +Bhe5 +Bhe6 +Bhe7 +Bhe8 +Bhf1 +Bhf2 +Bhf3 +Bhf4 +Bhf5 +Bhf6 +Bhf7 +Bhf8 +Bhg1 +Bhg2 +Bhg3 +Bhg4 +Bhg5 +Bhg6 +Bhg7 +Bhg8 +Bxa1 +Bxa2 +Bxa3 +Bxa4 +Bxa5 +Bxa6 +Bxa7 +Bxa8 +Bxb1 +Bxb2 +Bxb3 +Bxb4 +Bxb5 +Bxb6 +Bxb7 +Bxb8 +Bxc1 +Bxc2 +Bxc3 +Bxc4 +Bxc5 +Bxc6 +Bxc7 +Bxc8 +Bxd1 +Bxd2 +Bxd3 +Bxd4 +Bxd5 +Bxd6 +Bxd7 +Bxd8 +Bxe1 +Bxe2 +Bxe3 +Bxe4 +Bxe5 +Bxe6 +Bxe7 +Bxe8 +Bxf1 +Bxf2 +Bxf3 +Bxf4 +Bxf5 +Bxf6 +Bxf7 +Bxf8 +Bxg1 +Bxg2 +Bxg3 +Bxg4 +Bxg5 +Bxg6 +Bxg7 +Bxg8 +Bxh1 +Bxh2 +Bxh3 +Bxh4 +Bxh5 +Bxh6 +Bxh7 +Bxh8 +Ka1# +Ka1+ +Ka2# +Ka2+ +Ka3# +Ka3+ +Ka4# +Ka4+ +Ka5# +Ka5+ +Ka6# +Ka6+ +Ka7# +Ka7+ +Ka8# +Ka8+ +Kb1# +Kb1+ +Kb2# +Kb2+ +Kb3# +Kb3+ +Kb4# +Kb4+ +Kb5# +Kb5+ +Kb6# +Kb6+ +Kb7# +Kb7+ +Kb8# +Kb8+ +Kc1# +Kc1+ +Kc2# +Kc2+ +Kc3# +Kc3+ +Kc4# +Kc4+ +Kc5# +Kc5+ +Kc6# +Kc6+ +Kc7# +Kc7+ +Kc8# +Kc8+ +Kd1# +Kd1+ +Kd2# +Kd2+ +Kd3# +Kd3+ +Kd4# +Kd4+ +Kd5# +Kd5+ +Kd6# +Kd6+ +Kd7# +Kd7+ +Kd8# +Kd8+ +Ke1# +Ke1+ +Ke2# +Ke2+ +Ke3# +Ke3+ +Ke4# +Ke4+ +Ke5# +Ke5+ +Ke6# +Ke6+ +Ke7# +Ke7+ +Ke8# +Ke8+ +Kf1# +Kf1+ +Kf2# +Kf2+ +Kf3# +Kf3+ +Kf4# +Kf4+ +Kf5# +Kf5+ +Kf6# +Kf6+ +Kf7# +Kf7+ +Kf8# +Kf8+ +Kg1# +Kg1+ +Kg2# +Kg2+ +Kg3# +Kg3+ +Kg4# +Kg4+ +Kg5# +Kg5+ +Kg6# +Kg6+ +Kg7# +Kg7+ +Kg8# +Kg8+ +Kh1# +Kh1+ +Kh2# +Kh2+ +Kh3# +Kh3+ +Kh4# +Kh4+ +Kh5# +Kh5+ +Kh6# +Kh6+ +Kh7# +Kh7+ +Kh8# +Kh8+ +Kxa1 +Kxa2 +Kxa3 +Kxa4 +Kxa5 +Kxa6 +Kxa7 +Kxa8 +Kxb1 +Kxb2 +Kxb3 +Kxb4 +Kxb5 +Kxb6 +Kxb7 +Kxb8 +Kxc1 +Kxc2 +Kxc3 +Kxc4 +Kxc5 +Kxc6 +Kxc7 +Kxc8 +Kxd1 +Kxd2 +Kxd3 +Kxd4 +Kxd5 +Kxd6 +Kxd7 +Kxd8 +Kxe1 +Kxe2 +Kxe3 +Kxe4 +Kxe5 +Kxe6 +Kxe7 +Kxe8 +Kxf1 +Kxf2 +Kxf3 +Kxf4 +Kxf5 +Kxf6 +Kxf7 +Kxf8 +Kxg1 +Kxg2 +Kxg3 +Kxg4 +Kxg5 +Kxg6 +Kxg7 +Kxg8 +Kxh1 +Kxh2 +Kxh3 +Kxh4 +Kxh5 +Kxh6 +Kxh7 +Kxh8 +N1a2 +N1a3 +N1b2 +N1b3 +N1c2 +N1c3 +N1d2 +N1d3 +N1e2 +N1e3 +N1f2 +N1f3 +N1g2 +N1g3 +N1h2 +N1h3 +N2a3 +N2a4 +N2b3 +N2b4 +N2c3 +N2c4 +N2d3 +N2d4 +N2e3 +N2e4 +N2f3 +N2f4 +N2g3 +N2g4 +N2h3 +N2h4 +N3a2 +N3a4 +N3a5 +N3b2 +N3b4 +N3b5 +N3c2 +N3c4 +N3c5 +N3d2 +N3d4 +N3d5 +N3e2 +N3e4 +N3e5 +N3f2 +N3f4 +N3f5 +N3g2 +N3g4 +N3g5 +N3h2 +N3h4 +N3h5 +N4a3 +N4a5 +N4a6 +N4b3 +N4b5 +N4b6 +N4c3 +N4c5 +N4c6 +N4d3 +N4d5 +N4d6 +N4e3 +N4e5 +N4e6 +N4f3 +N4f5 +N4f6 +N4g3 +N4g5 +N4g6 +N4h3 +N4h5 +N4h6 +N5a3 +N5a4 +N5a6 +N5b3 +N5b4 +N5b6 +N5c3 +N5c4 +N5c6 +N5d3 +N5d4 +N5d6 +N5e3 +N5e4 +N5e6 +N5f3 +N5f4 +N5f6 +N5g3 +N5g4 +N5g6 +N5h3 +N5h4 +N5h6 +N6a4 +N6a5 +N6a7 +N6b4 +N6b5 +N6b7 +N6c4 +N6c5 +N6c7 +N6d4 +N6d5 +N6d7 +N6e4 +N6e5 +N6e7 +N6f4 +N6f5 +N6f7 +N6g4 +N6g5 +N6g7 +N6h4 +N6h5 +N6h7 +N7a5 +N7a6 +N7b5 +N7b6 +N7c5 +N7c6 +N7d5 +N7d6 +N7e5 +N7e6 +N7f5 +N7f6 +N7g5 +N7g6 +N7h5 +N7h6 +N8a6 +N8a7 +N8b6 +N8b7 +N8c6 +N8c7 +N8d6 +N8d7 +N8e6 +N8e7 +N8f6 +N8f7 +N8g6 +N8g7 +N8h6 +N8h7 +Na1# +Na1+ +Na2# +Na2+ +Na3# +Na3+ +Na4# +Na4+ +Na5# +Na5+ +Na6# +Na6+ +Na7# +Na7+ +Na8# +Na8+ +Nab1 +Nab2 +Nab3 +Nab4 +Nab5 +Nab6 +Nab7 +Nab8 +Nac1 +Nac2 +Nac3 +Nac4 +Nac5 +Nac6 +Nac7 +Nac8 +Nb1# +Nb1+ +Nb2# +Nb2+ +Nb3# +Nb3+ +Nb4# +Nb4+ +Nb5# +Nb5+ +Nb6# +Nb6+ +Nb7# +Nb7+ +Nb8# +Nb8+ +Nba1 +Nba2 +Nba3 +Nba4 +Nba5 +Nba6 +Nba7 +Nba8 +Nbc1 +Nbc2 +Nbc3 +Nbc4 +Nbc5 +Nbc6 +Nbc7 +Nbc8 +Nbd1 +Nbd2 +Nbd3 +Nbd4 +Nbd5 +Nbd6 +Nbd7 +Nbd8 +Nc1# +Nc1+ +Nc2# +Nc2+ +Nc3# +Nc3+ +Nc4# +Nc4+ +Nc5# +Nc5+ +Nc6# +Nc6+ +Nc7# +Nc7+ +Nc8# +Nc8+ +Nca1 +Nca2 +Nca3 +Nca4 +Nca5 +Nca6 +Nca7 +Nca8 +Ncb1 +Ncb2 +Ncb3 +Ncb4 +Ncb5 +Ncb6 +Ncb7 +Ncb8 +Ncd1 +Ncd2 +Ncd3 +Ncd4 +Ncd5 +Ncd6 +Ncd7 +Ncd8 +Nce1 +Nce2 +Nce3 +Nce4 +Nce5 +Nce6 +Nce7 +Nce8 +Nd1# +Nd1+ +Nd2# +Nd2+ +Nd3# +Nd3+ +Nd4# +Nd4+ +Nd5# +Nd5+ +Nd6# +Nd6+ +Nd7# +Nd7+ +Nd8# +Nd8+ +Ndb1 +Ndb2 +Ndb3 +Ndb4 +Ndb5 +Ndb6 +Ndb7 +Ndb8 +Ndc1 +Ndc2 +Ndc3 +Ndc4 +Ndc5 +Ndc6 +Ndc7 +Ndc8 +Nde1 +Nde2 +Nde3 +Nde4 +Nde5 +Nde6 +Nde7 +Nde8 +Ndf1 +Ndf2 +Ndf3 +Ndf4 +Ndf5 +Ndf6 +Ndf7 +Ndf8 +Ne1# +Ne1+ +Ne2# +Ne2+ +Ne3# +Ne3+ +Ne4# +Ne4+ +Ne5# +Ne5+ +Ne6# +Ne6+ +Ne7# +Ne7+ +Ne8# +Ne8+ +Nec1 +Nec2 +Nec3 +Nec4 +Nec5 +Nec6 +Nec7 +Nec8 +Ned1 +Ned2 +Ned3 +Ned4 +Ned5 +Ned6 +Ned7 +Ned8 +Nef1 +Nef2 +Nef3 +Nef4 +Nef5 +Nef6 +Nef7 +Nef8 +Neg1 +Neg2 +Neg3 +Neg4 +Neg5 +Neg6 +Neg7 +Neg8 +Nf1# +Nf1+ +Nf2# +Nf2+ +Nf3# +Nf3+ +Nf4# +Nf4+ +Nf5# +Nf5+ +Nf6# +Nf6+ +Nf7# +Nf7+ +Nf8# +Nf8+ +Nfd1 +Nfd2 +Nfd3 +Nfd4 +Nfd5 +Nfd6 +Nfd7 +Nfd8 +Nfe1 +Nfe2 +Nfe3 +Nfe4 +Nfe5 +Nfe6 +Nfe7 +Nfe8 +Nfg1 +Nfg2 +Nfg3 +Nfg4 +Nfg5 +Nfg6 +Nfg7 +Nfg8 +Nfh1 +Nfh2 +Nfh3 +Nfh4 +Nfh5 +Nfh6 +Nfh7 +Nfh8 +Ng1# +Ng1+ +Ng2# +Ng2+ +Ng3# +Ng3+ +Ng4# +Ng4+ +Ng5# +Ng5+ +Ng6# +Ng6+ +Ng7# +Ng7+ +Ng8# +Ng8+ +Nge1 +Nge2 +Nge3 +Nge4 +Nge5 +Nge6 +Nge7 +Nge8 +Ngf1 +Ngf2 +Ngf3 +Ngf4 +Ngf5 +Ngf6 +Ngf7 +Ngf8 +Ngh1 +Ngh2 +Ngh3 +Ngh4 +Ngh5 +Ngh6 +Ngh7 +Ngh8 +Nh1# +Nh1+ +Nh2# +Nh2+ +Nh3# +Nh3+ +Nh4# +Nh4+ +Nh5# +Nh5+ +Nh6# +Nh6+ +Nh7# +Nh7+ +Nh8# +Nh8+ +Nhf1 +Nhf2 +Nhf3 +Nhf4 +Nhf5 +Nhf6 +Nhf7 +Nhf8 +Nhg1 +Nhg2 +Nhg3 +Nhg4 +Nhg5 +Nhg6 +Nhg7 +Nhg8 +Nxa1 +Nxa2 +Nxa3 +Nxa4 +Nxa5 +Nxa6 +Nxa7 +Nxa8 +Nxb1 +Nxb2 +Nxb3 +Nxb4 +Nxb5 +Nxb6 +Nxb7 +Nxb8 +Nxc1 +Nxc2 +Nxc3 +Nxc4 +Nxc5 +Nxc6 +Nxc7 +Nxc8 +Nxd1 +Nxd2 +Nxd3 +Nxd4 +Nxd5 +Nxd6 +Nxd7 +Nxd8 +Nxe1 +Nxe2 +Nxe3 +Nxe4 +Nxe5 +Nxe6 +Nxe7 +Nxe8 +Nxf1 +Nxf2 +Nxf3 +Nxf4 +Nxf5 +Nxf6 +Nxf7 +Nxf8 +Nxg1 +Nxg2 +Nxg3 +Nxg4 +Nxg5 +Nxg6 +Nxg7 +Nxg8 +Nxh1 +Nxh2 +Nxh3 +Nxh4 +Nxh5 +Nxh6 +Nxh7 +Nxh8 +O-O# +O-O+ +Q1a1 +Q1a2 +Q1a3 +Q1a4 +Q1a5 +Q1a6 +Q1a7 +Q1a8 +Q1b1 +Q1b2 +Q1b3 +Q1b4 +Q1b5 +Q1b6 +Q1b7 +Q1c1 +Q1c2 +Q1c3 +Q1c4 +Q1c5 +Q1c6 +Q1c7 +Q1d1 +Q1d2 +Q1d3 +Q1d4 +Q1d5 +Q1d6 +Q1d7 +Q1e1 +Q1e2 +Q1e3 +Q1e4 +Q1e5 +Q1e6 +Q1e7 +Q1f1 +Q1f2 +Q1f3 +Q1f4 +Q1f5 +Q1f6 +Q1f7 +Q1g1 +Q1g2 +Q1g3 +Q1g4 +Q1g5 +Q1g6 +Q1g7 +Q1h1 +Q1h2 +Q1h3 +Q1h4 +Q1h5 +Q1h6 +Q1h7 +Q1h8 +Q2a1 +Q2a2 +Q2a3 +Q2a4 +Q2a5 +Q2a6 +Q2a7 +Q2a8 +Q2b1 +Q2b2 +Q2b3 +Q2b4 +Q2b5 +Q2b6 +Q2b7 +Q2b8 +Q2c1 +Q2c2 +Q2c3 +Q2c4 +Q2c5 +Q2c6 +Q2c7 +Q2d1 +Q2d2 +Q2d3 +Q2d4 +Q2d5 +Q2d6 +Q2d7 +Q2e1 +Q2e2 +Q2e3 +Q2e4 +Q2e5 +Q2e6 +Q2e7 +Q2f1 +Q2f2 +Q2f3 +Q2f4 +Q2f5 +Q2f6 +Q2f7 +Q2g1 +Q2g2 +Q2g3 +Q2g4 +Q2g5 +Q2g6 +Q2g7 +Q2g8 +Q2h1 +Q2h2 +Q2h3 +Q2h4 +Q2h5 +Q2h6 +Q2h7 +Q2h8 +Q3a1 +Q3a2 +Q3a3 +Q3a4 +Q3a5 +Q3a6 +Q3a7 +Q3a8 +Q3b1 +Q3b2 +Q3b3 +Q3b4 +Q3b5 +Q3b6 +Q3b7 +Q3b8 +Q3c1 +Q3c2 +Q3c3 +Q3c4 +Q3c5 +Q3c6 +Q3c7 +Q3c8 +Q3d1 +Q3d2 +Q3d3 +Q3d4 +Q3d5 +Q3d6 +Q3d7 +Q3e1 +Q3e2 +Q3e3 +Q3e4 +Q3e5 +Q3e6 +Q3e7 +Q3f1 +Q3f2 +Q3f3 +Q3f4 +Q3f5 +Q3f6 +Q3f7 +Q3f8 +Q3g1 +Q3g2 +Q3g3 +Q3g4 +Q3g5 +Q3g6 +Q3g7 +Q3g8 +Q3h1 +Q3h2 +Q3h3 +Q3h4 +Q3h5 +Q3h6 +Q3h7 +Q3h8 +Q4a1 +Q4a2 +Q4a3 +Q4a4 +Q4a5 +Q4a6 +Q4a7 +Q4a8 +Q4b1 +Q4b2 +Q4b3 +Q4b4 +Q4b5 +Q4b6 +Q4b7 +Q4b8 +Q4c1 +Q4c2 +Q4c3 +Q4c4 +Q4c5 +Q4c6 +Q4c7 +Q4c8 +Q4d1 +Q4d2 +Q4d3 +Q4d4 +Q4d5 +Q4d6 +Q4d7 +Q4d8 +Q4e1 +Q4e2 +Q4e3 +Q4e4 +Q4e5 +Q4e6 +Q4e7 +Q4e8 +Q4f1 +Q4f2 +Q4f3 +Q4f4 +Q4f5 +Q4f6 +Q4f7 +Q4f8 +Q4g1 +Q4g2 +Q4g3 +Q4g4 +Q4g5 +Q4g6 +Q4g7 +Q4g8 +Q4h1 +Q4h2 +Q4h3 +Q4h4 +Q4h5 +Q4h6 +Q4h7 +Q4h8 +Q5a1 +Q5a2 +Q5a3 +Q5a4 +Q5a5 +Q5a6 +Q5a7 +Q5a8 +Q5b1 +Q5b2 +Q5b3 +Q5b4 +Q5b5 +Q5b6 +Q5b7 +Q5b8 +Q5c1 +Q5c2 +Q5c3 +Q5c4 +Q5c5 +Q5c6 +Q5c7 +Q5c8 +Q5d1 +Q5d2 +Q5d3 +Q5d4 +Q5d5 +Q5d6 +Q5d7 +Q5d8 +Q5e1 +Q5e2 +Q5e3 +Q5e4 +Q5e5 +Q5e6 +Q5e7 +Q5e8 +Q5f1 +Q5f2 +Q5f3 +Q5f4 +Q5f5 +Q5f6 +Q5f7 +Q5f8 +Q5g1 +Q5g2 +Q5g3 +Q5g4 +Q5g5 +Q5g6 +Q5g7 +Q5g8 +Q5h1 +Q5h2 +Q5h3 +Q5h4 +Q5h5 +Q5h6 +Q5h7 +Q5h8 +Q6a1 +Q6a2 +Q6a3 +Q6a4 +Q6a5 +Q6a6 +Q6a7 +Q6a8 +Q6b1 +Q6b2 +Q6b3 +Q6b4 +Q6b5 +Q6b6 +Q6b7 +Q6b8 +Q6c1 +Q6c2 +Q6c3 +Q6c4 +Q6c5 +Q6c6 +Q6c7 +Q6c8 +Q6d2 +Q6d3 +Q6d4 +Q6d5 +Q6d6 +Q6d7 +Q6d8 +Q6e2 +Q6e3 +Q6e4 +Q6e5 +Q6e6 +Q6e7 +Q6e8 +Q6f1 +Q6f2 +Q6f3 +Q6f4 +Q6f5 +Q6f6 +Q6f7 +Q6f8 +Q6g1 +Q6g2 +Q6g3 +Q6g4 +Q6g5 +Q6g6 +Q6g7 +Q6g8 +Q6h1 +Q6h2 +Q6h3 +Q6h4 +Q6h5 +Q6h6 +Q6h7 +Q6h8 +Q7a1 +Q7a2 +Q7a3 +Q7a4 +Q7a5 +Q7a6 +Q7a7 +Q7a8 +Q7b1 +Q7b2 +Q7b3 +Q7b4 +Q7b5 +Q7b6 +Q7b7 +Q7b8 +Q7c2 +Q7c3 +Q7c4 +Q7c5 +Q7c6 +Q7c7 +Q7c8 +Q7d2 +Q7d3 +Q7d4 +Q7d5 +Q7d6 +Q7d7 +Q7d8 +Q7e2 +Q7e3 +Q7e4 +Q7e5 +Q7e6 +Q7e7 +Q7e8 +Q7f2 +Q7f3 +Q7f4 +Q7f5 +Q7f6 +Q7f7 +Q7f8 +Q7g1 +Q7g2 +Q7g3 +Q7g4 +Q7g5 +Q7g6 +Q7g7 +Q7g8 +Q7h1 +Q7h2 +Q7h3 +Q7h4 +Q7h5 +Q7h6 +Q7h7 +Q7h8 +Q8a1 +Q8a2 +Q8a3 +Q8a4 +Q8a5 +Q8a6 +Q8a7 +Q8a8 +Q8b2 +Q8b3 +Q8b4 +Q8b5 +Q8b6 +Q8b7 +Q8b8 +Q8c2 +Q8c3 +Q8c4 +Q8c5 +Q8c6 +Q8c7 +Q8c8 +Q8d2 +Q8d3 +Q8d4 +Q8d5 +Q8d6 +Q8d7 +Q8d8 +Q8e2 +Q8e3 +Q8e4 +Q8e5 +Q8e6 +Q8e7 +Q8e8 +Q8f2 +Q8f3 +Q8f4 +Q8f5 +Q8f6 +Q8f7 +Q8f8 +Q8g2 +Q8g3 +Q8g4 +Q8g5 +Q8g6 +Q8g7 +Q8g8 +Q8h1 +Q8h2 +Q8h3 +Q8h4 +Q8h5 +Q8h6 +Q8h7 +Q8h8 +Qa1# +Qa1+ +Qa2# +Qa2+ +Qa3# +Qa3+ +Qa4# +Qa4+ +Qa5# +Qa5+ +Qa6# +Qa6+ +Qa7# +Qa7+ +Qa8# +Qa8+ +Qaa1 +Qaa2 +Qaa3 +Qaa4 +Qaa5 +Qaa6 +Qaa7 +Qaa8 +Qab1 +Qab2 +Qab3 +Qab4 +Qab5 +Qab6 +Qab7 +Qab8 +Qac1 +Qac2 +Qac3 +Qac4 +Qac5 +Qac6 +Qac7 +Qac8 +Qad1 +Qad2 +Qad3 +Qad4 +Qad5 +Qad6 +Qad7 +Qad8 +Qae1 +Qae2 +Qae3 +Qae4 +Qae5 +Qae6 +Qae7 +Qae8 +Qaf1 +Qaf2 +Qaf3 +Qaf4 +Qaf5 +Qaf6 +Qaf7 +Qaf8 +Qag1 +Qag2 +Qag3 +Qag4 +Qag5 +Qag6 +Qag7 +Qag8 +Qah1 +Qah2 +Qah3 +Qah4 +Qah5 +Qah6 +Qah7 +Qah8 +Qb1# +Qb1+ +Qb2# +Qb2+ +Qb3# +Qb3+ +Qb4# +Qb4+ +Qb5# +Qb5+ +Qb6# +Qb6+ +Qb7# +Qb7+ +Qb8# +Qb8+ +Qba1 +Qba2 +Qba3 +Qba4 +Qba5 +Qba6 +Qba7 +Qba8 +Qbb1 +Qbb2 +Qbb3 +Qbb4 +Qbb5 +Qbb6 +Qbb7 +Qbb8 +Qbc1 +Qbc2 +Qbc3 +Qbc4 +Qbc5 +Qbc6 +Qbc7 +Qbc8 +Qbd1 +Qbd2 +Qbd3 +Qbd4 +Qbd5 +Qbd6 +Qbd7 +Qbd8 +Qbe1 +Qbe2 +Qbe3 +Qbe4 +Qbe5 +Qbe6 +Qbe7 +Qbe8 +Qbf1 +Qbf2 +Qbf3 +Qbf4 +Qbf5 +Qbf6 +Qbf7 +Qbf8 +Qbg1 +Qbg2 +Qbg3 +Qbg4 +Qbg5 +Qbg6 +Qbg7 +Qbg8 +Qbh1 +Qbh2 +Qbh3 +Qbh4 +Qbh5 +Qbh6 +Qbh7 +Qbh8 +Qc1# +Qc1+ +Qc2# +Qc2+ +Qc3# +Qc3+ +Qc4# +Qc4+ +Qc5# +Qc5+ +Qc6# +Qc6+ +Qc7# +Qc7+ +Qc8# +Qc8+ +Qca1 +Qca2 +Qca3 +Qca4 +Qca5 +Qca6 +Qca7 +Qca8 +Qcb1 +Qcb2 +Qcb3 +Qcb4 +Qcb5 +Qcb6 +Qcb7 +Qcb8 +Qcc1 +Qcc2 +Qcc3 +Qcc4 +Qcc5 +Qcc6 +Qcc7 +Qcc8 +Qcd1 +Qcd2 +Qcd3 +Qcd4 +Qcd5 +Qcd6 +Qcd7 +Qcd8 +Qce1 +Qce2 +Qce3 +Qce4 +Qce5 +Qce6 +Qce7 +Qce8 +Qcf1 +Qcf2 +Qcf3 +Qcf4 +Qcf5 +Qcf6 +Qcf7 +Qcf8 +Qcg1 +Qcg2 +Qcg3 +Qcg4 +Qcg5 +Qcg6 +Qcg7 +Qcg8 +Qch1 +Qch2 +Qch3 +Qch4 +Qch5 +Qch6 +Qch7 +Qch8 +Qd1# +Qd1+ +Qd2# +Qd2+ +Qd3# +Qd3+ +Qd4# +Qd4+ +Qd5# +Qd5+ +Qd6# +Qd6+ +Qd7# +Qd7+ +Qd8# +Qd8+ +Qda1 +Qda2 +Qda3 +Qda4 +Qda5 +Qda6 +Qda7 +Qda8 +Qdb1 +Qdb2 +Qdb3 +Qdb4 +Qdb5 +Qdb6 +Qdb7 +Qdb8 +Qdc1 +Qdc2 +Qdc3 +Qdc4 +Qdc5 +Qdc6 +Qdc7 +Qdc8 +Qdd1 +Qdd2 +Qdd3 +Qdd4 +Qdd5 +Qdd6 +Qdd7 +Qdd8 +Qde1 +Qde2 +Qde3 +Qde4 +Qde5 +Qde6 +Qde7 +Qde8 +Qdf1 +Qdf2 +Qdf3 +Qdf4 +Qdf5 +Qdf6 +Qdf7 +Qdf8 +Qdg1 +Qdg2 +Qdg3 +Qdg4 +Qdg5 +Qdg6 +Qdg7 +Qdg8 +Qdh1 +Qdh2 +Qdh3 +Qdh4 +Qdh5 +Qdh6 +Qdh7 +Qdh8 +Qe1# +Qe1+ +Qe2# +Qe2+ +Qe3# +Qe3+ +Qe4# +Qe4+ +Qe5# +Qe5+ +Qe6# +Qe6+ +Qe7# +Qe7+ +Qe8# +Qe8+ +Qea1 +Qea2 +Qea3 +Qea4 +Qea5 +Qea6 +Qea7 +Qea8 +Qeb1 +Qeb2 +Qeb3 +Qeb4 +Qeb5 +Qeb6 +Qeb7 +Qeb8 +Qec1 +Qec2 +Qec3 +Qec4 +Qec5 +Qec6 +Qec7 +Qec8 +Qed1 +Qed2 +Qed3 +Qed4 +Qed5 +Qed6 +Qed7 +Qed8 +Qee1 +Qee2 +Qee3 +Qee4 +Qee5 +Qee6 +Qee7 +Qee8 +Qef1 +Qef2 +Qef3 +Qef4 +Qef5 +Qef6 +Qef7 +Qef8 +Qeg1 +Qeg2 +Qeg3 +Qeg4 +Qeg5 +Qeg6 +Qeg7 +Qeg8 +Qeh1 +Qeh2 +Qeh3 +Qeh4 +Qeh5 +Qeh6 +Qeh7 +Qeh8 +Qf1# +Qf1+ +Qf2# +Qf2+ +Qf3# +Qf3+ +Qf4# +Qf4+ +Qf5# +Qf5+ +Qf6# +Qf6+ +Qf7# +Qf7+ +Qf8# +Qf8+ +Qfa1 +Qfa2 +Qfa3 +Qfa4 +Qfa5 +Qfa6 +Qfa7 +Qfa8 +Qfb1 +Qfb2 +Qfb3 +Qfb4 +Qfb5 +Qfb6 +Qfb7 +Qfb8 +Qfc1 +Qfc2 +Qfc3 +Qfc4 +Qfc5 +Qfc6 +Qfc7 +Qfc8 +Qfd1 +Qfd2 +Qfd3 +Qfd4 +Qfd5 +Qfd6 +Qfd7 +Qfd8 +Qfe1 +Qfe2 +Qfe3 +Qfe4 +Qfe5 +Qfe6 +Qfe7 +Qfe8 +Qff1 +Qff2 +Qff3 +Qff4 +Qff5 +Qff6 +Qff7 +Qff8 +Qfg1 +Qfg2 +Qfg3 +Qfg4 +Qfg5 +Qfg6 +Qfg7 +Qfg8 +Qfh1 +Qfh2 +Qfh3 +Qfh4 +Qfh5 +Qfh6 +Qfh7 +Qfh8 +Qg1# +Qg1+ +Qg2# +Qg2+ +Qg3# +Qg3+ +Qg4# +Qg4+ +Qg5# +Qg5+ +Qg6# +Qg6+ +Qg7# +Qg7+ +Qg8# +Qg8+ +Qga1 +Qga2 +Qga3 +Qga4 +Qga5 +Qga6 +Qga7 +Qga8 +Qgb1 +Qgb2 +Qgb3 +Qgb4 +Qgb5 +Qgb6 +Qgb7 +Qgb8 +Qgc1 +Qgc2 +Qgc3 +Qgc4 +Qgc5 +Qgc6 +Qgc7 +Qgc8 +Qgd1 +Qgd2 +Qgd3 +Qgd4 +Qgd5 +Qgd6 +Qgd7 +Qgd8 +Qge1 +Qge2 +Qge3 +Qge4 +Qge5 +Qge6 +Qge7 +Qge8 +Qgf1 +Qgf2 +Qgf3 +Qgf4 +Qgf5 +Qgf6 +Qgf7 +Qgf8 +Qgg1 +Qgg2 +Qgg3 +Qgg4 +Qgg5 +Qgg6 +Qgg7 +Qgg8 +Qgh1 +Qgh2 +Qgh3 +Qgh4 +Qgh5 +Qgh6 +Qgh7 +Qgh8 +Qh1# +Qh1+ +Qh2# +Qh2+ +Qh3# +Qh3+ +Qh4# +Qh4+ +Qh5# +Qh5+ +Qh6# +Qh6+ +Qh7# +Qh7+ +Qh8# +Qh8+ +Qha1 +Qha2 +Qha3 +Qha4 +Qha5 +Qha6 +Qha7 +Qha8 +Qhb1 +Qhb2 +Qhb3 +Qhb4 +Qhb5 +Qhb6 +Qhb7 +Qhb8 +Qhc1 +Qhc2 +Qhc3 +Qhc4 +Qhc5 +Qhc6 +Qhc7 +Qhc8 +Qhd1 +Qhd2 +Qhd3 +Qhd4 +Qhd5 +Qhd6 +Qhd7 +Qhd8 +Qhe1 +Qhe2 +Qhe3 +Qhe4 +Qhe5 +Qhe6 +Qhe7 +Qhe8 +Qhf1 +Qhf2 +Qhf3 +Qhf4 +Qhf5 +Qhf6 +Qhf7 +Qhf8 +Qhg1 +Qhg2 +Qhg3 +Qhg4 +Qhg5 +Qhg6 +Qhg7 +Qhg8 +Qhh1 +Qhh2 +Qhh3 +Qhh4 +Qhh5 +Qhh6 +Qhh7 +Qhh8 +Qxa1 +Qxa2 +Qxa3 +Qxa4 +Qxa5 +Qxa6 +Qxa7 +Qxa8 +Qxb1 +Qxb2 +Qxb3 +Qxb4 +Qxb5 +Qxb6 +Qxb7 +Qxb8 +Qxc1 +Qxc2 +Qxc3 +Qxc4 +Qxc5 +Qxc6 +Qxc7 +Qxc8 +Qxd1 +Qxd2 +Qxd3 +Qxd4 +Qxd5 +Qxd6 +Qxd7 +Qxd8 +Qxe1 +Qxe2 +Qxe3 +Qxe4 +Qxe5 +Qxe6 +Qxe7 +Qxe8 +Qxf1 +Qxf2 +Qxf3 +Qxf4 +Qxf5 +Qxf6 +Qxf7 +Qxf8 +Qxg1 +Qxg2 +Qxg3 +Qxg4 +Qxg5 +Qxg6 +Qxg7 +Qxg8 +Qxh1 +Qxh2 +Qxh3 +Qxh4 +Qxh5 +Qxh6 +Qxh7 +Qxh8 +R1a2 +R1a3 +R1a4 +R1a5 +R1a6 +R1a7 +R1b2 +R1b3 +R1b4 +R1b5 +R1b6 +R1b7 +R1c2 +R1c3 +R1c4 +R1c5 +R1c6 +R1c7 +R1d2 +R1d3 +R1d4 +R1d5 +R1d6 +R1d7 +R1e2 +R1e3 +R1e4 +R1e5 +R1e6 +R1e7 +R1f2 +R1f3 +R1f4 +R1f5 +R1f6 +R1f7 +R1g2 +R1g3 +R1g4 +R1g5 +R1g6 +R1g7 +R1h2 +R1h3 +R1h4 +R1h5 +R1h6 +R1h7 +R2a3 +R2a4 +R2a5 +R2a6 +R2a7 +R2b3 +R2b4 +R2b5 +R2b6 +R2b7 +R2c3 +R2c4 +R2c5 +R2c6 +R2c7 +R2d3 +R2d4 +R2d5 +R2d6 +R2d7 +R2e3 +R2e4 +R2e5 +R2e6 +R2e7 +R2f3 +R2f4 +R2f5 +R2f6 +R2f7 +R2g3 +R2g4 +R2g5 +R2g6 +R2g7 +R2h3 +R2h4 +R2h5 +R2h6 +R2h7 +R3a2 +R3a4 +R3a5 +R3a6 +R3a7 +R3b2 +R3b4 +R3b5 +R3b6 +R3b7 +R3c2 +R3c4 +R3c5 +R3c6 +R3c7 +R3d2 +R3d4 +R3d5 +R3d6 +R3d7 +R3e2 +R3e4 +R3e5 +R3e6 +R3e7 +R3f2 +R3f4 +R3f5 +R3f6 +R3f7 +R3g2 +R3g4 +R3g5 +R3g6 +R3g7 +R3h2 +R3h4 +R3h5 +R3h6 +R3h7 +R4a2 +R4a3 +R4a5 +R4a6 +R4a7 +R4b2 +R4b3 +R4b5 +R4b6 +R4b7 +R4c2 +R4c3 +R4c5 +R4c6 +R4c7 +R4d2 +R4d3 +R4d5 +R4d6 +R4d7 +R4e2 +R4e3 +R4e5 +R4e6 +R4e7 +R4f2 +R4f3 +R4f5 +R4f6 +R4f7 +R4g2 +R4g3 +R4g5 +R4g6 +R4g7 +R4h2 +R4h3 +R4h5 +R4h6 +R4h7 +R5a2 +R5a3 +R5a4 +R5a6 +R5a7 +R5b2 +R5b3 +R5b4 +R5b6 +R5b7 +R5c2 +R5c3 +R5c4 +R5c6 +R5c7 +R5d2 +R5d3 +R5d4 +R5d6 +R5d7 +R5e2 +R5e3 +R5e4 +R5e6 +R5e7 +R5f2 +R5f3 +R5f4 +R5f6 +R5f7 +R5g2 +R5g3 +R5g4 +R5g6 +R5g7 +R5h2 +R5h3 +R5h4 +R5h6 +R5h7 +R6a2 +R6a3 +R6a4 +R6a5 +R6a7 +R6b2 +R6b3 +R6b4 +R6b5 +R6b7 +R6c2 +R6c3 +R6c4 +R6c5 +R6c7 +R6d2 +R6d3 +R6d4 +R6d5 +R6d7 +R6e2 +R6e3 +R6e4 +R6e5 +R6e7 +R6f2 +R6f3 +R6f4 +R6f5 +R6f7 +R6g2 +R6g3 +R6g4 +R6g5 +R6g7 +R6h2 +R6h3 +R6h4 +R6h5 +R6h7 +R7a2 +R7a3 +R7a4 +R7a5 +R7a6 +R7b2 +R7b3 +R7b4 +R7b5 +R7b6 +R7c2 +R7c3 +R7c4 +R7c5 +R7c6 +R7d2 +R7d3 +R7d4 +R7d5 +R7d6 +R7e2 +R7e3 +R7e4 +R7e5 +R7e6 +R7f2 +R7f3 +R7f4 +R7f5 +R7f6 +R7g2 +R7g3 +R7g4 +R7g5 +R7g6 +R7h2 +R7h3 +R7h4 +R7h5 +R7h6 +R8a2 +R8a3 +R8a4 +R8a5 +R8a6 +R8a7 +R8b2 +R8b3 +R8b4 +R8b5 +R8b6 +R8b7 +R8c2 +R8c3 +R8c4 +R8c5 +R8c6 +R8c7 +R8d2 +R8d3 +R8d4 +R8d5 +R8d6 +R8d7 +R8e2 +R8e3 +R8e4 +R8e5 +R8e6 +R8e7 +R8f2 +R8f3 +R8f4 +R8f5 +R8f6 +R8f7 +R8g2 +R8g3 +R8g4 +R8g5 +R8g6 +R8g7 +R8h2 +R8h3 +R8h4 +R8h5 +R8h6 +R8h7 +Ra1# +Ra1+ +Ra2# +Ra2+ +Ra3# +Ra3+ +Ra4# +Ra4+ +Ra5# +Ra5+ +Ra6# +Ra6+ +Ra7# +Ra7+ +Ra8# +Ra8+ +Raa1 +Raa2 +Raa3 +Raa4 +Raa5 +Raa6 +Raa7 +Raa8 +Rab1 +Rab2 +Rab3 +Rab4 +Rab5 +Rab6 +Rab7 +Rab8 +Rac1 +Rac2 +Rac3 +Rac4 +Rac5 +Rac6 +Rac7 +Rac8 +Rad1 +Rad2 +Rad3 +Rad4 +Rad5 +Rad6 +Rad7 +Rad8 +Rae1 +Rae2 +Rae3 +Rae4 +Rae5 +Rae6 +Rae7 +Rae8 +Raf1 +Raf2 +Raf3 +Raf4 +Raf5 +Raf6 +Raf7 +Raf8 +Rag1 +Rag2 +Rag3 +Rag4 +Rag5 +Rag6 +Rag7 +Rag8 +Rah1 +Rah2 +Rah3 +Rah4 +Rah5 +Rah6 +Rah7 +Rah8 +Rb1# +Rb1+ +Rb2# +Rb2+ +Rb3# +Rb3+ +Rb4# +Rb4+ +Rb5# +Rb5+ +Rb6# +Rb6+ +Rb7# +Rb7+ +Rb8# +Rb8+ +Rba1 +Rba2 +Rba3 +Rba4 +Rba5 +Rba6 +Rba7 +Rba8 +Rbb1 +Rbb2 +Rbb3 +Rbb4 +Rbb5 +Rbb6 +Rbb7 +Rbb8 +Rbc1 +Rbc2 +Rbc3 +Rbc4 +Rbc5 +Rbc6 +Rbc7 +Rbc8 +Rbd1 +Rbd2 +Rbd3 +Rbd4 +Rbd5 +Rbd6 +Rbd7 +Rbd8 +Rbe1 +Rbe2 +Rbe3 +Rbe4 +Rbe5 +Rbe6 +Rbe7 +Rbe8 +Rbf1 +Rbf2 +Rbf3 +Rbf4 +Rbf5 +Rbf6 +Rbf7 +Rbf8 +Rbg1 +Rbg2 +Rbg3 +Rbg4 +Rbg5 +Rbg6 +Rbg7 +Rbg8 +Rbh1 +Rbh2 +Rbh3 +Rbh4 +Rbh5 +Rbh6 +Rbh7 +Rbh8 +Rc1# +Rc1+ +Rc2# +Rc2+ +Rc3# +Rc3+ +Rc4# +Rc4+ +Rc5# +Rc5+ +Rc6# +Rc6+ +Rc7# +Rc7+ +Rc8# +Rc8+ +Rca1 +Rca2 +Rca3 +Rca4 +Rca5 +Rca6 +Rca7 +Rca8 +Rcb1 +Rcb2 +Rcb3 +Rcb4 +Rcb5 +Rcb6 +Rcb7 +Rcb8 +Rcc1 +Rcc2 +Rcc3 +Rcc4 +Rcc5 +Rcc6 +Rcc7 +Rcc8 +Rcd1 +Rcd2 +Rcd3 +Rcd4 +Rcd5 +Rcd6 +Rcd7 +Rcd8 +Rce1 +Rce2 +Rce3 +Rce4 +Rce5 +Rce6 +Rce7 +Rce8 +Rcf1 +Rcf2 +Rcf3 +Rcf4 +Rcf5 +Rcf6 +Rcf7 +Rcf8 +Rcg1 +Rcg2 +Rcg3 +Rcg4 +Rcg5 +Rcg6 +Rcg7 +Rcg8 +Rch1 +Rch2 +Rch3 +Rch4 +Rch5 +Rch6 +Rch7 +Rch8 +Rd1# +Rd1+ +Rd2# +Rd2+ +Rd3# +Rd3+ +Rd4# +Rd4+ +Rd5# +Rd5+ +Rd6# +Rd6+ +Rd7# +Rd7+ +Rd8# +Rd8+ +Rda1 +Rda2 +Rda3 +Rda4 +Rda5 +Rda6 +Rda7 +Rda8 +Rdb1 +Rdb2 +Rdb3 +Rdb4 +Rdb5 +Rdb6 +Rdb7 +Rdb8 +Rdc1 +Rdc2 +Rdc3 +Rdc4 +Rdc5 +Rdc6 +Rdc7 +Rdc8 +Rdd1 +Rdd2 +Rdd3 +Rdd4 +Rdd5 +Rdd6 +Rdd7 +Rdd8 +Rde1 +Rde2 +Rde3 +Rde4 +Rde5 +Rde6 +Rde7 +Rde8 +Rdf1 +Rdf2 +Rdf3 +Rdf4 +Rdf5 +Rdf6 +Rdf7 +Rdf8 +Rdg1 +Rdg2 +Rdg3 +Rdg4 +Rdg5 +Rdg6 +Rdg7 +Rdg8 +Rdh1 +Rdh2 +Rdh3 +Rdh4 +Rdh5 +Rdh6 +Rdh7 +Rdh8 +Re1# +Re1+ +Re2# +Re2+ +Re3# +Re3+ +Re4# +Re4+ +Re5# +Re5+ +Re6# +Re6+ +Re7# +Re7+ +Re8# +Re8+ +Rea1 +Rea2 +Rea3 +Rea4 +Rea5 +Rea6 +Rea7 +Rea8 +Reb1 +Reb2 +Reb3 +Reb4 +Reb5 +Reb6 +Reb7 +Reb8 +Rec1 +Rec2 +Rec3 +Rec4 +Rec5 +Rec6 +Rec7 +Rec8 +Red1 +Red2 +Red3 +Red4 +Red5 +Red6 +Red7 +Red8 +Ree1 +Ree2 +Ree3 +Ree4 +Ree5 +Ree6 +Ree7 +Ree8 +Ref1 +Ref2 +Ref3 +Ref4 +Ref5 +Ref6 +Ref7 +Ref8 +Reg1 +Reg2 +Reg3 +Reg4 +Reg5 +Reg6 +Reg7 +Reg8 +Reh1 +Reh2 +Reh3 +Reh4 +Reh5 +Reh6 +Reh7 +Reh8 +Rf1# +Rf1+ +Rf2# +Rf2+ +Rf3# +Rf3+ +Rf4# +Rf4+ +Rf5# +Rf5+ +Rf6# +Rf6+ +Rf7# +Rf7+ +Rf8# +Rf8+ +Rfa1 +Rfa2 +Rfa3 +Rfa4 +Rfa5 +Rfa6 +Rfa7 +Rfa8 +Rfb1 +Rfb2 +Rfb3 +Rfb4 +Rfb5 +Rfb6 +Rfb7 +Rfb8 +Rfc1 +Rfc2 +Rfc3 +Rfc4 +Rfc5 +Rfc6 +Rfc7 +Rfc8 +Rfd1 +Rfd2 +Rfd3 +Rfd4 +Rfd5 +Rfd6 +Rfd7 +Rfd8 +Rfe1 +Rfe2 +Rfe3 +Rfe4 +Rfe5 +Rfe6 +Rfe7 +Rfe8 +Rff1 +Rff2 +Rff3 +Rff4 +Rff5 +Rff6 +Rff7 +Rff8 +Rfg1 +Rfg2 +Rfg3 +Rfg4 +Rfg5 +Rfg6 +Rfg7 +Rfg8 +Rfh1 +Rfh2 +Rfh3 +Rfh4 +Rfh5 +Rfh6 +Rfh7 +Rfh8 +Rg1# +Rg1+ +Rg2# +Rg2+ +Rg3# +Rg3+ +Rg4# +Rg4+ +Rg5# +Rg5+ +Rg6# +Rg6+ +Rg7# +Rg7+ +Rg8# +Rg8+ +Rga1 +Rga2 +Rga3 +Rga4 +Rga5 +Rga6 +Rga7 +Rga8 +Rgb1 +Rgb2 +Rgb3 +Rgb4 +Rgb5 +Rgb6 +Rgb7 +Rgb8 +Rgc1 +Rgc2 +Rgc3 +Rgc4 +Rgc5 +Rgc6 +Rgc7 +Rgc8 +Rgd1 +Rgd2 +Rgd3 +Rgd4 +Rgd5 +Rgd6 +Rgd7 +Rgd8 +Rge1 +Rge2 +Rge3 +Rge4 +Rge5 +Rge6 +Rge7 +Rge8 +Rgf1 +Rgf2 +Rgf3 +Rgf4 +Rgf5 +Rgf6 +Rgf7 +Rgf8 +Rgg1 +Rgg2 +Rgg3 +Rgg4 +Rgg5 +Rgg6 +Rgg7 +Rgg8 +Rgh1 +Rgh2 +Rgh3 +Rgh4 +Rgh5 +Rgh6 +Rgh7 +Rgh8 +Rh1# +Rh1+ +Rh2# +Rh2+ +Rh3# +Rh3+ +Rh4# +Rh4+ +Rh5# +Rh5+ +Rh6# +Rh6+ +Rh7# +Rh7+ +Rh8# +Rh8+ +Rha1 +Rha2 +Rha3 +Rha4 +Rha5 +Rha6 +Rha7 +Rha8 +Rhb1 +Rhb2 +Rhb3 +Rhb4 +Rhb5 +Rhb6 +Rhb7 +Rhb8 +Rhc1 +Rhc2 +Rhc3 +Rhc4 +Rhc5 +Rhc6 +Rhc7 +Rhc8 +Rhd1 +Rhd2 +Rhd3 +Rhd4 +Rhd5 +Rhd6 +Rhd7 +Rhd8 +Rhe1 +Rhe2 +Rhe3 +Rhe4 +Rhe5 +Rhe6 +Rhe7 +Rhe8 +Rhf1 +Rhf2 +Rhf3 +Rhf4 +Rhf5 +Rhf6 +Rhf7 +Rhf8 +Rhg1 +Rhg2 +Rhg3 +Rhg4 +Rhg5 +Rhg6 +Rhg7 +Rhg8 +Rhh1 +Rhh2 +Rhh3 +Rhh4 +Rhh5 +Rhh6 +Rhh7 +Rhh8 +Rxa1 +Rxa2 +Rxa3 +Rxa4 +Rxa5 +Rxa6 +Rxa7 +Rxa8 +Rxb1 +Rxb2 +Rxb3 +Rxb4 +Rxb5 +Rxb6 +Rxb7 +Rxb8 +Rxc1 +Rxc2 +Rxc3 +Rxc4 +Rxc5 +Rxc6 +Rxc7 +Rxc8 +Rxd1 +Rxd2 +Rxd3 +Rxd4 +Rxd5 +Rxd6 +Rxd7 +Rxd8 +Rxe1 +Rxe2 +Rxe3 +Rxe4 +Rxe5 +Rxe6 +Rxe7 +Rxe8 +Rxf1 +Rxf2 +Rxf3 +Rxf4 +Rxf5 +Rxf6 +Rxf7 +Rxf8 +Rxg1 +Rxg2 +Rxg3 +Rxg4 +Rxg5 +Rxg6 +Rxg7 +Rxg8 +Rxh1 +Rxh2 +Rxh3 +Rxh4 +Rxh5 +Rxh6 +Rxh7 +Rxh8 +a1=B +a1=N +a1=Q +a1=R +a8=B +a8=N +a8=Q +a8=R +axb2 +axb3 +axb4 +axb5 +axb6 +axb7 +b1=B +b1=N +b1=Q +b1=R +b8=B +b8=N +b8=Q +b8=R +bxa2 +bxa3 +bxa4 +bxa5 +bxa6 +bxa7 +bxc2 +bxc3 +bxc4 +bxc5 +bxc6 +bxc7 +c1=B +c1=N +c1=Q +c1=R +c8=B +c8=N +c8=Q +c8=R +cxb2 +cxb3 +cxb4 +cxb5 +cxb6 +cxb7 +cxd2 +cxd3 +cxd4 +cxd5 +cxd6 +cxd7 +d1=B +d1=N +d1=Q +d1=R +d8=B +d8=N +d8=Q +d8=R +dxc2 +dxc3 +dxc4 +dxc5 +dxc6 +dxc7 +dxe2 +dxe3 +dxe4 +dxe5 +dxe6 +dxe7 +e1=B +e1=N +e1=Q +e1=R +e8=B +e8=N +e8=Q +e8=R +exd2 +exd3 +exd4 +exd5 +exd6 +exd7 +exf2 +exf3 +exf4 +exf5 +exf6 +exf7 +f1=B +f1=N +f1=Q +f1=R +f8=B +f8=N +f8=Q +f8=R +fxe2 +fxe3 +fxe4 +fxe5 +fxe6 +fxe7 +fxg2 +fxg3 +fxg4 +fxg5 +fxg6 +fxg7 +g1=B +g1=N +g1=Q +g1=R +g8=B +g8=N +g8=Q +g8=R +gxf2 +gxf3 +gxf4 +gxf5 +gxf6 +gxf7 +gxh2 +gxh3 +gxh4 +gxh5 +gxh6 +gxh7 +h1=B +h1=N +h1=Q +h1=R +h8=B +h8=N +h8=Q +h8=R +hxg2 +hxg3 +hxg4 +hxg5 +hxg6 +hxg7 +B1a2# +B1a2+ +B1a3# +B1a3+ +B1a4# +B1a4+ +B1b2# +B1b2+ +B1b3# +B1b3+ +B1b4# +B1b4+ +B1c2# +B1c2+ +B1c3# +B1c3+ +B1c4# +B1c4+ +B1d2# +B1d2+ +B1d3# +B1d3+ +B1d4# +B1d4+ +B1e2# +B1e2+ +B1e3# +B1e3+ +B1e4# +B1e4+ +B1f2# +B1f2+ +B1f3# +B1f3+ +B1f4# +B1f4+ +B1g2# +B1g2+ +B1g3# +B1g3+ +B1g4# +B1g4+ +B1h2# +B1h2+ +B1h3# +B1h3+ +B1h4# +B1h4+ +B1xa2 +B1xa3 +B1xa4 +B1xb2 +B1xb3 +B1xb4 +B1xc2 +B1xc3 +B1xc4 +B1xd2 +B1xd3 +B1xd4 +B1xe2 +B1xe3 +B1xe4 +B1xf2 +B1xf3 +B1xf4 +B1xg2 +B1xg3 +B1xg4 +B1xh2 +B1xh3 +B1xh4 +B2a3# +B2a3+ +B2a4# +B2a4+ +B2a5# +B2a5+ +B2b3# +B2b3+ +B2b4# +B2b4+ +B2b5# +B2b5+ +B2c3# +B2c3+ +B2c4# +B2c4+ +B2c5# +B2c5+ +B2d3# +B2d3+ +B2d4# +B2d4+ +B2d5# +B2d5+ +B2e3# +B2e3+ +B2e4# +B2e4+ +B2e5# +B2e5+ +B2f3# +B2f3+ +B2f4# +B2f4+ +B2f5# +B2f5+ +B2g3# +B2g3+ +B2g4# +B2g4+ +B2g5# +B2g5+ +B2h3# +B2h3+ +B2h4# +B2h4+ +B2h5# +B2h5+ +B2xa3 +B2xa4 +B2xa5 +B2xb3 +B2xb4 +B2xb5 +B2xc3 +B2xc4 +B2xc5 +B2xd3 +B2xd4 +B2xd5 +B2xe3 +B2xe4 +B2xe5 +B2xf3 +B2xf4 +B2xf5 +B2xg3 +B2xg4 +B2xg5 +B2xh3 +B2xh4 +B2xh5 +B3a2# +B3a2+ +B3a4# +B3a4+ +B3a5# +B3a5+ +B3b2# +B3b2+ +B3b4# +B3b4+ +B3b5# +B3b5+ +B3c2# +B3c2+ +B3c4# +B3c4+ +B3c5# +B3c5+ +B3d2# +B3d2+ +B3d4# +B3d4+ +B3d5# +B3d5+ +B3e2# +B3e2+ +B3e4# +B3e4+ +B3e5# +B3e5+ +B3f2# +B3f2+ +B3f4# +B3f4+ +B3f5# +B3f5+ +B3g2# +B3g2+ +B3g4# +B3g4+ +B3g5# +B3g5+ +B3h2# +B3h2+ +B3h4# +B3h4+ +B3h5# +B3h5+ +B3xa2 +B3xa4 +B3xa5 +B3xb2 +B3xb4 +B3xb5 +B3xc2 +B3xc4 +B3xc5 +B3xd2 +B3xd4 +B3xd5 +B3xe2 +B3xe4 +B3xe5 +B3xf2 +B3xf4 +B3xf5 +B3xg2 +B3xg4 +B3xg5 +B3xh2 +B3xh4 +B3xh5 +B4a3# +B4a3+ +B4a5# +B4a5+ +B4a6# +B4a6+ +B4b3# +B4b3+ +B4b5# +B4b5+ +B4b6# +B4b6+ +B4c3# +B4c3+ +B4c5# +B4c5+ +B4c6# +B4c6+ +B4d3# +B4d3+ +B4d5# +B4d5+ +B4d6# +B4d6+ +B4e3# +B4e3+ +B4e5# +B4e5+ +B4e6# +B4e6+ +B4f3# +B4f3+ +B4f5# +B4f5+ +B4f6# +B4f6+ +B4g3# +B4g3+ +B4g5# +B4g5+ +B4g6# +B4g6+ +B4h3# +B4h3+ +B4h5# +B4h5+ +B4h6# +B4h6+ +B4xa3 +B4xa5 +B4xa6 +B4xb3 +B4xb5 +B4xb6 +B4xc3 +B4xc5 +B4xc6 +B4xd3 +B4xd5 +B4xd6 +B4xe3 +B4xe5 +B4xe6 +B4xf3 +B4xf5 +B4xf6 +B4xg3 +B4xg5 +B4xg6 +B4xh3 +B4xh5 +B4xh6 +B5a3# +B5a3+ +B5a4# +B5a4+ +B5a6# +B5a6+ +B5b3# +B5b3+ +B5b4# +B5b4+ +B5b6# +B5b6+ +B5c3# +B5c3+ +B5c4# +B5c4+ +B5c6# +B5c6+ +B5d3# +B5d3+ +B5d4# +B5d4+ +B5d6# +B5d6+ +B5e3# +B5e3+ +B5e4# +B5e4+ +B5e6# +B5e6+ +B5f3# +B5f3+ +B5f4# +B5f4+ +B5f6# +B5f6+ +B5g3# +B5g3+ +B5g4# +B5g4+ +B5g6# +B5g6+ +B5h3# +B5h3+ +B5h4# +B5h4+ +B5h6# +B5h6+ +B5xa3 +B5xa4 +B5xa6 +B5xb3 +B5xb4 +B5xb6 +B5xc3 +B5xc4 +B5xc6 +B5xd3 +B5xd4 +B5xd6 +B5xe3 +B5xe4 +B5xe6 +B5xf3 +B5xf4 +B5xf6 +B5xg3 +B5xg4 +B5xg6 +B5xh3 +B5xh4 +B5xh6 +B6a4# +B6a4+ +B6a5# +B6a5+ +B6a7# +B6a7+ +B6b4# +B6b4+ +B6b5# +B6b5+ +B6b7# +B6b7+ +B6c4# +B6c4+ +B6c5# +B6c5+ +B6c7# +B6c7+ +B6d4# +B6d4+ +B6d5# +B6d5+ +B6d7# +B6d7+ +B6e4# +B6e4+ +B6e5# +B6e5+ +B6e7# +B6e7+ +B6f4# +B6f4+ +B6f5# +B6f5+ +B6f7# +B6f7+ +B6g4# +B6g4+ +B6g5# +B6g5+ +B6g7# +B6g7+ +B6h4# +B6h4+ +B6h5# +B6h5+ +B6h7# +B6h7+ +B6xa4 +B6xa5 +B6xa7 +B6xb4 +B6xb5 +B6xb7 +B6xc4 +B6xc5 +B6xc7 +B6xd4 +B6xd5 +B6xd7 +B6xe4 +B6xe5 +B6xe7 +B6xf4 +B6xf5 +B6xf7 +B6xg4 +B6xg5 +B6xg7 +B6xh4 +B6xh5 +B6xh7 +B7a4# +B7a4+ +B7a5# +B7a5+ +B7a6# +B7a6+ +B7b4# +B7b4+ +B7b5# +B7b5+ +B7b6# +B7b6+ +B7c4# +B7c4+ +B7c5# +B7c5+ +B7c6# +B7c6+ +B7d4# +B7d4+ +B7d5# +B7d5+ +B7d6# +B7d6+ +B7e4# +B7e4+ +B7e5# +B7e5+ +B7e6# +B7e6+ +B7f4# +B7f4+ +B7f5# +B7f5+ +B7f6# +B7f6+ +B7g4# +B7g4+ +B7g5# +B7g5+ +B7g6# +B7g6+ +B7h4# +B7h4+ +B7h5# +B7h5+ +B7h6# +B7h6+ +B7xa4 +B7xa5 +B7xa6 +B7xb4 +B7xb5 +B7xb6 +B7xc4 +B7xc5 +B7xc6 +B7xd4 +B7xd5 +B7xd6 +B7xe4 +B7xe5 +B7xe6 +B7xf4 +B7xf5 +B7xf6 +B7xg4 +B7xg5 +B7xg6 +B7xh4 +B7xh5 +B7xh6 +B8a5# +B8a5+ +B8a6# +B8a6+ +B8a7# +B8a7+ +B8b5# +B8b5+ +B8b6# +B8b6+ +B8b7# +B8b7+ +B8c5# +B8c5+ +B8c6# +B8c6+ +B8c7# +B8c7+ +B8d5# +B8d5+ +B8d6# +B8d6+ +B8d7# +B8d7+ +B8e5# +B8e5+ +B8e6# +B8e6+ +B8e7# +B8e7+ +B8f5# +B8f5+ +B8f6# +B8f6+ +B8f7# +B8f7+ +B8g5# +B8g5+ +B8g6# +B8g6+ +B8g7# +B8g7+ +B8h5# +B8h5+ +B8h6# +B8h6+ +B8h7# +B8h7+ +B8xa5 +B8xa6 +B8xa7 +B8xb5 +B8xb6 +B8xb7 +B8xc5 +B8xc6 +B8xc7 +B8xd5 +B8xd6 +B8xd7 +B8xe5 +B8xe6 +B8xe7 +B8xf5 +B8xf6 +B8xf7 +B8xg5 +B8xg6 +B8xg7 +B8xh5 +B8xh6 +B8xh7 +Ba1b2 +Ba1c3 +Ba1d4 +Ba2b3 +Ba2c4 +Ba2d5 +Ba3b2 +Ba3b4 +Ba3c5 +Ba4b3 +Ba4b5 +Ba4c6 +Ba5b4 +Ba5b6 +Ba5c3 +Ba6b5 +Ba6b7 +Ba6c4 +Ba7b6 +Ba7c5 +Ba7d4 +Ba8b7 +Ba8c6 +Ba8d5 +Bab1# +Bab1+ +Bab2# +Bab2+ +Bab3# +Bab3+ +Bab4# +Bab4+ +Bab5# +Bab5+ +Bab6# +Bab6+ +Bab7# +Bab7+ +Bab8# +Bab8+ +Bac1# +Bac1+ +Bac2# +Bac2+ +Bac3# +Bac3+ +Bac4# +Bac4+ +Bac5# +Bac5+ +Bac6# +Bac6+ +Bac7# +Bac7+ +Bac8# +Bac8+ +Bad1# +Bad1+ +Bad2# +Bad2+ +Bad3# +Bad3+ +Bad4# +Bad4+ +Bad5# +Bad5+ +Bad6# +Bad6+ +Bad7# +Bad7+ +Bad8# +Bad8+ +Bae1# +Bae1+ +Bae2# +Bae2+ +Bae3# +Bae3+ +Bae4# +Bae4+ +Bae5# +Bae5+ +Bae6# +Bae6+ +Bae7# +Bae7+ +Bae8# +Bae8+ +Baf1# +Baf1+ +Baf2# +Baf2+ +Baf3# +Baf3+ +Baf6# +Baf6+ +Baf7# +Baf7+ +Baf8# +Baf8+ +Bag1# +Bag1+ +Bag2# +Bag2+ +Bag7# +Bag7+ +Bag8# +Bag8+ +Baxb1 +Baxb2 +Baxb3 +Baxb4 +Baxb5 +Baxb6 +Baxb7 +Baxb8 +Baxc1 +Baxc2 +Baxc3 +Baxc4 +Baxc5 +Baxc6 +Baxc7 +Baxc8 +Baxd1 +Baxd2 +Baxd3 +Baxd4 +Baxd5 +Baxd6 +Baxd7 +Baxd8 +Baxe1 +Baxe2 +Baxe3 +Baxe4 +Baxe5 +Baxe6 +Baxe7 +Baxe8 +Baxf1 +Baxf2 +Baxf3 +Baxf6 +Baxf7 +Baxf8 +Baxg1 +Baxg2 +Baxg7 +Baxg8 +Bb1c2 +Bb1d3 +Bb1e4 +Bb2c3 +Bb2d4 +Bb2e5 +Bb3c2 +Bb3c4 +Bb3d5 +Bb4c3 +Bb4c5 +Bb4d6 +Bb5c4 +Bb5c6 +Bb5d3 +Bb6c5 +Bb6c7 +Bb6d4 +Bb7c6 +Bb7d5 +Bb7e4 +Bb8c7 +Bb8d6 +Bb8e5 +Bba2# +Bba2+ +Bba3# +Bba3+ +Bba4# +Bba4+ +Bba5# +Bba5+ +Bba6# +Bba6+ +Bba7# +Bba7+ +Bbc1# +Bbc1+ +Bbc2# +Bbc2+ +Bbc3# +Bbc3+ +Bbc4# +Bbc4+ +Bbc5# +Bbc5+ +Bbc6# +Bbc6+ +Bbc7# +Bbc7+ +Bbc8# +Bbc8+ +Bbd1# +Bbd1+ +Bbd2# +Bbd2+ +Bbd3# +Bbd3+ +Bbd4# +Bbd4+ +Bbd5# +Bbd5+ +Bbd6# +Bbd6+ +Bbd7# +Bbd7+ +Bbd8# +Bbd8+ +Bbe1# +Bbe1+ +Bbe2# +Bbe2+ +Bbe3# +Bbe3+ +Bbe4# +Bbe4+ +Bbe5# +Bbe5+ +Bbe6# +Bbe6+ +Bbe7# +Bbe7+ +Bbe8# +Bbe8+ +Bbf1# +Bbf1+ +Bbf2# +Bbf2+ +Bbf3# +Bbf3+ +Bbf4# +Bbf4+ +Bbf5# +Bbf5+ +Bbf6# +Bbf6+ +Bbf7# +Bbf7+ +Bbf8# +Bbf8+ +Bbg1# +Bbg1+ +Bbg2# +Bbg2+ +Bbg3# +Bbg3+ +Bbg6# +Bbg6+ +Bbg7# +Bbg7+ +Bbg8# +Bbg8+ +Bbh2# +Bbh2+ +Bbh7# +Bbh7+ +Bbxa2 +Bbxa3 +Bbxa4 +Bbxa5 +Bbxa6 +Bbxa7 +Bbxc1 +Bbxc2 +Bbxc3 +Bbxc4 +Bbxc5 +Bbxc6 +Bbxc7 +Bbxc8 +Bbxd1 +Bbxd2 +Bbxd3 +Bbxd4 +Bbxd5 +Bbxd6 +Bbxd7 +Bbxd8 +Bbxe1 +Bbxe2 +Bbxe3 +Bbxe4 +Bbxe5 +Bbxe6 +Bbxe7 +Bbxe8 +Bbxf1 +Bbxf2 +Bbxf3 +Bbxf4 +Bbxf5 +Bbxf6 +Bbxf7 +Bbxf8 +Bbxg1 +Bbxg2 +Bbxg3 +Bbxg6 +Bbxg7 +Bbxg8 +Bbxh2 +Bbxh7 +Bc1b2 +Bc1d2 +Bc1e3 +Bc2b3 +Bc2d3 +Bc2e4 +Bc3b2 +Bc3b4 +Bc3d2 +Bc3d4 +Bc3e5 +Bc4b3 +Bc4b5 +Bc4d3 +Bc4d5 +Bc4e6 +Bc5b4 +Bc5b6 +Bc5d4 +Bc5d6 +Bc5e3 +Bc6b5 +Bc6b7 +Bc6d5 +Bc6d7 +Bc6e4 +Bc7b6 +Bc7d6 +Bc7e5 +Bc8b7 +Bc8d7 +Bc8e6 +Bca2# +Bca2+ +Bca3# +Bca3+ +Bca4# +Bca4+ +Bca5# +Bca5+ +Bca6# +Bca6+ +Bca7# +Bca7+ +Bcb1# +Bcb1+ +Bcb2# +Bcb2+ +Bcb3# +Bcb3+ +Bcb4# +Bcb4+ +Bcb5# +Bcb5+ +Bcb6# +Bcb6+ +Bcb7# +Bcb7+ +Bcb8# +Bcb8+ +Bcd1# +Bcd1+ +Bcd2# +Bcd2+ +Bcd3# +Bcd3+ +Bcd4# +Bcd4+ +Bcd5# +Bcd5+ +Bcd6# +Bcd6+ +Bcd7# +Bcd7+ +Bcd8# +Bcd8+ +Bce1# +Bce1+ +Bce2# +Bce2+ +Bce3# +Bce3+ +Bce4# +Bce4+ +Bce5# +Bce5+ +Bce6# +Bce6+ +Bce7# +Bce7+ +Bce8# +Bce8+ +Bcf1# +Bcf1+ +Bcf2# +Bcf2+ +Bcf3# +Bcf3+ +Bcf4# +Bcf4+ +Bcf5# +Bcf5+ +Bcf6# +Bcf6+ +Bcf7# +Bcf7+ +Bcf8# +Bcf8+ +Bcg1# +Bcg1+ +Bcg2# +Bcg2+ +Bcg3# +Bcg3+ +Bcg4# +Bcg4+ +Bcg5# +Bcg5+ +Bcg6# +Bcg6+ +Bcg7# +Bcg7+ +Bcg8# +Bcg8+ +Bch2# +Bch2+ +Bch3# +Bch3+ +Bch6# +Bch6+ +Bch7# +Bch7+ +Bcxa2 +Bcxa3 +Bcxa4 +Bcxa5 +Bcxa6 +Bcxa7 +Bcxb1 +Bcxb2 +Bcxb3 +Bcxb4 +Bcxb5 +Bcxb6 +Bcxb7 +Bcxb8 +Bcxd1 +Bcxd2 +Bcxd3 +Bcxd4 +Bcxd5 +Bcxd6 +Bcxd7 +Bcxd8 +Bcxe1 +Bcxe2 +Bcxe3 +Bcxe4 +Bcxe5 +Bcxe6 +Bcxe7 +Bcxe8 +Bcxf1 +Bcxf2 +Bcxf3 +Bcxf4 +Bcxf5 +Bcxf6 +Bcxf7 +Bcxf8 +Bcxg1 +Bcxg2 +Bcxg3 +Bcxg4 +Bcxg5 +Bcxg6 +Bcxg7 +Bcxg8 +Bcxh2 +Bcxh3 +Bcxh6 +Bcxh7 +Bd1c2 +Bd1e2 +Bd1f3 +Bd2c3 +Bd2e3 +Bd2f4 +Bd3c2 +Bd3c4 +Bd3e2 +Bd3e4 +Bd3f5 +Bd4c3 +Bd4c5 +Bd4e3 +Bd4e5 +Bd4f6 +Bd5c4 +Bd5c6 +Bd5e4 +Bd5e6 +Bd5f3 +Bd6c5 +Bd6c7 +Bd6e5 +Bd6e7 +Bd6f4 +Bd7c6 +Bd7e6 +Bd7f5 +Bd8c7 +Bd8e7 +Bd8f6 +Bda2# +Bda2+ +Bda3# +Bda3+ +Bda4# +Bda4+ +Bda5# +Bda5+ +Bda6# +Bda6+ +Bda7# +Bda7+ +Bdb1# +Bdb1+ +Bdb2# +Bdb2+ +Bdb3# +Bdb3+ +Bdb4# +Bdb4+ +Bdb5# +Bdb5+ +Bdb6# +Bdb6+ +Bdb7# +Bdb7+ +Bdb8# +Bdb8+ +Bdc1# +Bdc1+ +Bdc2# +Bdc2+ +Bdc3# +Bdc3+ +Bdc4# +Bdc4+ +Bdc5# +Bdc5+ +Bdc6# +Bdc6+ +Bdc7# +Bdc7+ +Bdc8# +Bdc8+ +Bde1# +Bde1+ +Bde2# +Bde2+ +Bde3# +Bde3+ +Bde4# +Bde4+ +Bde5# +Bde5+ +Bde6# +Bde6+ +Bde7# +Bde7+ +Bde8# +Bde8+ +Bdf1# +Bdf1+ +Bdf2# +Bdf2+ +Bdf3# +Bdf3+ +Bdf4# +Bdf4+ +Bdf5# +Bdf5+ +Bdf6# +Bdf6+ +Bdf7# +Bdf7+ +Bdf8# +Bdf8+ +Bdg1# +Bdg1+ +Bdg2# +Bdg2+ +Bdg3# +Bdg3+ +Bdg4# +Bdg4+ +Bdg5# +Bdg5+ +Bdg6# +Bdg6+ +Bdg7# +Bdg7+ +Bdg8# +Bdg8+ +Bdh2# +Bdh2+ +Bdh3# +Bdh3+ +Bdh4# +Bdh4+ +Bdh5# +Bdh5+ +Bdh6# +Bdh6+ +Bdh7# +Bdh7+ +Bdxa2 +Bdxa3 +Bdxa4 +Bdxa5 +Bdxa6 +Bdxa7 +Bdxb1 +Bdxb2 +Bdxb3 +Bdxb4 +Bdxb5 +Bdxb6 +Bdxb7 +Bdxb8 +Bdxc1 +Bdxc2 +Bdxc3 +Bdxc4 +Bdxc5 +Bdxc6 +Bdxc7 +Bdxc8 +Bdxe1 +Bdxe2 +Bdxe3 +Bdxe4 +Bdxe5 +Bdxe6 +Bdxe7 +Bdxe8 +Bdxf1 +Bdxf2 +Bdxf3 +Bdxf4 +Bdxf5 +Bdxf6 +Bdxf7 +Bdxf8 +Bdxg1 +Bdxg2 +Bdxg3 +Bdxg4 +Bdxg5 +Bdxg6 +Bdxg7 +Bdxg8 +Bdxh2 +Bdxh3 +Bdxh4 +Bdxh5 +Bdxh6 +Bdxh7 +Be1c3 +Be1d2 +Be1f2 +Be2c4 +Be2d3 +Be2f3 +Be3c5 +Be3d2 +Be3d4 +Be3f2 +Be3f4 +Be4c6 +Be4d3 +Be4d5 +Be4f3 +Be4f5 +Be5c3 +Be5d4 +Be5d6 +Be5f4 +Be5f6 +Be6c4 +Be6d5 +Be6d7 +Be6f5 +Be6f7 +Be7c5 +Be7d6 +Be7f6 +Be8c6 +Be8d7 +Be8f7 +Bea2# +Bea2+ +Bea3# +Bea3+ +Bea4# +Bea4+ +Bea5# +Bea5+ +Bea6# +Bea6+ +Bea7# +Bea7+ +Beb1# +Beb1+ +Beb2# +Beb2+ +Beb3# +Beb3+ +Beb4# +Beb4+ +Beb5# +Beb5+ +Beb6# +Beb6+ +Beb7# +Beb7+ +Beb8# +Beb8+ +Bec1# +Bec1+ +Bec2# +Bec2+ +Bec3# +Bec3+ +Bec4# +Bec4+ +Bec5# +Bec5+ +Bec6# +Bec6+ +Bec7# +Bec7+ +Bec8# +Bec8+ +Bed1# +Bed1+ +Bed2# +Bed2+ +Bed3# +Bed3+ +Bed4# +Bed4+ +Bed5# +Bed5+ +Bed6# +Bed6+ +Bed7# +Bed7+ +Bed8# +Bed8+ +Bef1# +Bef1+ +Bef2# +Bef2+ +Bef3# +Bef3+ +Bef4# +Bef4+ +Bef5# +Bef5+ +Bef6# +Bef6+ +Bef7# +Bef7+ +Bef8# +Bef8+ +Beg1# +Beg1+ +Beg2# +Beg2+ +Beg3# +Beg3+ +Beg4# +Beg4+ +Beg5# +Beg5+ +Beg6# +Beg6+ +Beg7# +Beg7+ +Beg8# +Beg8+ +Beh2# +Beh2+ +Beh3# +Beh3+ +Beh4# +Beh4+ +Beh5# +Beh5+ +Beh6# +Beh6+ +Beh7# +Beh7+ +Bexa2 +Bexa3 +Bexa4 +Bexa5 +Bexa6 +Bexa7 +Bexb1 +Bexb2 +Bexb3 +Bexb4 +Bexb5 +Bexb6 +Bexb7 +Bexb8 +Bexc1 +Bexc2 +Bexc3 +Bexc4 +Bexc5 +Bexc6 +Bexc7 +Bexc8 +Bexd1 +Bexd2 +Bexd3 +Bexd4 +Bexd5 +Bexd6 +Bexd7 +Bexd8 +Bexf1 +Bexf2 +Bexf3 +Bexf4 +Bexf5 +Bexf6 +Bexf7 +Bexf8 +Bexg1 +Bexg2 +Bexg3 +Bexg4 +Bexg5 +Bexg6 +Bexg7 +Bexg8 +Bexh2 +Bexh3 +Bexh4 +Bexh5 +Bexh6 +Bexh7 +Bf1d3 +Bf1e2 +Bf1g2 +Bf2d4 +Bf2e3 +Bf2g3 +Bf3d5 +Bf3e2 +Bf3e4 +Bf3g2 +Bf3g4 +Bf4d6 +Bf4e3 +Bf4e5 +Bf4g3 +Bf4g5 +Bf5d3 +Bf5e4 +Bf5e6 +Bf5g4 +Bf5g6 +Bf6d4 +Bf6e5 +Bf6e7 +Bf6g5 +Bf6g7 +Bf7d5 +Bf7e6 +Bf7g6 +Bf8d6 +Bf8e7 +Bf8g7 +Bfa2# +Bfa2+ +Bfa3# +Bfa3+ +Bfa6# +Bfa6+ +Bfa7# +Bfa7+ +Bfb1# +Bfb1+ +Bfb2# +Bfb2+ +Bfb3# +Bfb3+ +Bfb4# +Bfb4+ +Bfb5# +Bfb5+ +Bfb6# +Bfb6+ +Bfb7# +Bfb7+ +Bfb8# +Bfb8+ +Bfc1# +Bfc1+ +Bfc2# +Bfc2+ +Bfc3# +Bfc3+ +Bfc4# +Bfc4+ +Bfc5# +Bfc5+ +Bfc6# +Bfc6+ +Bfc7# +Bfc7+ +Bfc8# +Bfc8+ +Bfd1# +Bfd1+ +Bfd2# +Bfd2+ +Bfd3# +Bfd3+ +Bfd4# +Bfd4+ +Bfd5# +Bfd5+ +Bfd6# +Bfd6+ +Bfd7# +Bfd7+ +Bfd8# +Bfd8+ +Bfe1# +Bfe1+ +Bfe2# +Bfe2+ +Bfe3# +Bfe3+ +Bfe4# +Bfe4+ +Bfe5# +Bfe5+ +Bfe6# +Bfe6+ +Bfe7# +Bfe7+ +Bfe8# +Bfe8+ +Bfg1# +Bfg1+ +Bfg2# +Bfg2+ +Bfg3# +Bfg3+ +Bfg4# +Bfg4+ +Bfg5# +Bfg5+ +Bfg6# +Bfg6+ +Bfg7# +Bfg7+ +Bfg8# +Bfg8+ +Bfh2# +Bfh2+ +Bfh3# +Bfh3+ +Bfh4# +Bfh4+ +Bfh5# +Bfh5+ +Bfh6# +Bfh6+ +Bfh7# +Bfh7+ +Bfxa2 +Bfxa3 +Bfxa6 +Bfxa7 +Bfxb1 +Bfxb2 +Bfxb3 +Bfxb4 +Bfxb5 +Bfxb6 +Bfxb7 +Bfxb8 +Bfxc1 +Bfxc2 +Bfxc3 +Bfxc4 +Bfxc5 +Bfxc6 +Bfxc7 +Bfxc8 +Bfxd1 +Bfxd2 +Bfxd3 +Bfxd4 +Bfxd5 +Bfxd6 +Bfxd7 +Bfxd8 +Bfxe1 +Bfxe2 +Bfxe3 +Bfxe4 +Bfxe5 +Bfxe6 +Bfxe7 +Bfxe8 +Bfxg1 +Bfxg2 +Bfxg3 +Bfxg4 +Bfxg5 +Bfxg6 +Bfxg7 +Bfxg8 +Bfxh2 +Bfxh3 +Bfxh4 +Bfxh5 +Bfxh6 +Bfxh7 +Bg1d4 +Bg1e3 +Bg1f2 +Bg2d5 +Bg2e4 +Bg2f3 +Bg3e5 +Bg3f2 +Bg3f4 +Bg4e6 +Bg4f3 +Bg4f5 +Bg5e3 +Bg5f4 +Bg5f6 +Bg6e4 +Bg6f5 +Bg6f7 +Bg7d4 +Bg7e5 +Bg7f6 +Bg8d5 +Bg8e6 +Bg8f7 +Bga2# +Bga2+ +Bga7# +Bga7+ +Bgb1# +Bgb1+ +Bgb2# +Bgb2+ +Bgb3# +Bgb3+ +Bgb6# +Bgb6+ +Bgb7# +Bgb7+ +Bgb8# +Bgb8+ +Bgc1# +Bgc1+ +Bgc2# +Bgc2+ +Bgc3# +Bgc3+ +Bgc4# +Bgc4+ +Bgc5# +Bgc5+ +Bgc6# +Bgc6+ +Bgc7# +Bgc7+ +Bgc8# +Bgc8+ +Bgd1# +Bgd1+ +Bgd2# +Bgd2+ +Bgd3# +Bgd3+ +Bgd4# +Bgd4+ +Bgd5# +Bgd5+ +Bgd6# +Bgd6+ +Bgd7# +Bgd7+ +Bgd8# +Bgd8+ +Bge1# +Bge1+ +Bge2# +Bge2+ +Bge3# +Bge3+ +Bge4# +Bge4+ +Bge5# +Bge5+ +Bge6# +Bge6+ +Bge7# +Bge7+ +Bge8# +Bge8+ +Bgf1# +Bgf1+ +Bgf2# +Bgf2+ +Bgf3# +Bgf3+ +Bgf4# +Bgf4+ +Bgf5# +Bgf5+ +Bgf6# +Bgf6+ +Bgf7# +Bgf7+ +Bgf8# +Bgf8+ +Bgh2# +Bgh2+ +Bgh3# +Bgh3+ +Bgh4# +Bgh4+ +Bgh5# +Bgh5+ +Bgh6# +Bgh6+ +Bgh7# +Bgh7+ +Bgxa2 +Bgxa7 +Bgxb1 +Bgxb2 +Bgxb3 +Bgxb6 +Bgxb7 +Bgxb8 +Bgxc1 +Bgxc2 +Bgxc3 +Bgxc4 +Bgxc5 +Bgxc6 +Bgxc7 +Bgxc8 +Bgxd1 +Bgxd2 +Bgxd3 +Bgxd4 +Bgxd5 +Bgxd6 +Bgxd7 +Bgxd8 +Bgxe1 +Bgxe2 +Bgxe3 +Bgxe4 +Bgxe5 +Bgxe6 +Bgxe7 +Bgxe8 +Bgxf1 +Bgxf2 +Bgxf3 +Bgxf4 +Bgxf5 +Bgxf6 +Bgxf7 +Bgxf8 +Bgxh2 +Bgxh3 +Bgxh4 +Bgxh5 +Bgxh6 +Bgxh7 +Bh1e4 +Bh1f3 +Bh1g2 +Bh2e5 +Bh2f4 +Bh2g3 +Bh3f5 +Bh3g2 +Bh3g4 +Bh4f6 +Bh4g3 +Bh4g5 +Bh5f3 +Bh5g4 +Bh5g6 +Bh6f4 +Bh6g5 +Bh6g7 +Bh7e4 +Bh7f5 +Bh7g6 +Bh8e5 +Bh8f6 +Bh8g7 +Bhb1# +Bhb1+ +Bhb2# +Bhb2+ +Bhb7# +Bhb7+ +Bhb8# +Bhb8+ +Bhc1# +Bhc1+ +Bhc2# +Bhc2+ +Bhc3# +Bhc3+ +Bhc6# +Bhc6+ +Bhc7# +Bhc7+ +Bhc8# +Bhc8+ +Bhd1# +Bhd1+ +Bhd2# +Bhd2+ +Bhd3# +Bhd3+ +Bhd4# +Bhd4+ +Bhd5# +Bhd5+ +Bhd6# +Bhd6+ +Bhd7# +Bhd7+ +Bhd8# +Bhd8+ +Bhe1# +Bhe1+ +Bhe2# +Bhe2+ +Bhe3# +Bhe3+ +Bhe4# +Bhe4+ +Bhe5# +Bhe5+ +Bhe6# +Bhe6+ +Bhe7# +Bhe7+ +Bhe8# +Bhe8+ +Bhf1# +Bhf1+ +Bhf2# +Bhf2+ +Bhf3# +Bhf3+ +Bhf4# +Bhf4+ +Bhf5# +Bhf5+ +Bhf6# +Bhf6+ +Bhf7# +Bhf7+ +Bhf8# +Bhf8+ +Bhg1# +Bhg1+ +Bhg2# +Bhg2+ +Bhg3# +Bhg3+ +Bhg4# +Bhg4+ +Bhg5# +Bhg5+ +Bhg6# +Bhg6+ +Bhg7# +Bhg7+ +Bhg8# +Bhg8+ +Bhxb1 +Bhxb2 +Bhxb7 +Bhxb8 +Bhxc1 +Bhxc2 +Bhxc3 +Bhxc6 +Bhxc7 +Bhxc8 +Bhxd1 +Bhxd2 +Bhxd3 +Bhxd4 +Bhxd5 +Bhxd6 +Bhxd7 +Bhxd8 +Bhxe1 +Bhxe2 +Bhxe3 +Bhxe4 +Bhxe5 +Bhxe6 +Bhxe7 +Bhxe8 +Bhxf1 +Bhxf2 +Bhxf3 +Bhxf4 +Bhxf5 +Bhxf6 +Bhxf7 +Bhxf8 +Bhxg1 +Bhxg2 +Bhxg3 +Bhxg4 +Bhxg5 +Bhxg6 +Bhxg7 +Bhxg8 +Bxa1# +Bxa1+ +Bxa2# +Bxa2+ +Bxa3# +Bxa3+ +Bxa4# +Bxa4+ +Bxa5# +Bxa5+ +Bxa6# +Bxa6+ +Bxa7# +Bxa7+ +Bxa8# +Bxa8+ +Bxb1# +Bxb1+ +Bxb2# +Bxb2+ +Bxb3# +Bxb3+ +Bxb4# +Bxb4+ +Bxb5# +Bxb5+ +Bxb6# +Bxb6+ +Bxb7# +Bxb7+ +Bxb8# +Bxb8+ +Bxc1# +Bxc1+ +Bxc2# +Bxc2+ +Bxc3# +Bxc3+ +Bxc4# +Bxc4+ +Bxc5# +Bxc5+ +Bxc6# +Bxc6+ +Bxc7# +Bxc7+ +Bxc8# +Bxc8+ +Bxd1# +Bxd1+ +Bxd2# +Bxd2+ +Bxd3# +Bxd3+ +Bxd4# +Bxd4+ +Bxd5# +Bxd5+ +Bxd6# +Bxd6+ +Bxd7# +Bxd7+ +Bxd8# +Bxd8+ +Bxe1# +Bxe1+ +Bxe2# +Bxe2+ +Bxe3# +Bxe3+ +Bxe4# +Bxe4+ +Bxe5# +Bxe5+ +Bxe6# +Bxe6+ +Bxe7# +Bxe7+ +Bxe8# +Bxe8+ +Bxf1# +Bxf1+ +Bxf2# +Bxf2+ +Bxf3# +Bxf3+ +Bxf4# +Bxf4+ +Bxf5# +Bxf5+ +Bxf6# +Bxf6+ +Bxf7# +Bxf7+ +Bxf8# +Bxf8+ +Bxg1# +Bxg1+ +Bxg2# +Bxg2+ +Bxg3# +Bxg3+ +Bxg4# +Bxg4+ +Bxg5# +Bxg5+ +Bxg6# +Bxg6+ +Bxg7# +Bxg7+ +Bxg8# +Bxg8+ +Bxh1# +Bxh1+ +Bxh2# +Bxh2+ +Bxh3# +Bxh3+ +Bxh4# +Bxh4+ +Bxh5# +Bxh5+ +Bxh6# +Bxh6+ +Bxh7# +Bxh7+ +Bxh8# +Bxh8+ +Kxa1# +Kxa1+ +Kxa2# +Kxa2+ +Kxa3# +Kxa3+ +Kxa4# +Kxa4+ +Kxa5# +Kxa5+ +Kxa6# +Kxa6+ +Kxa7# +Kxa7+ +Kxa8# +Kxa8+ +Kxb1# +Kxb1+ +Kxb2# +Kxb2+ +Kxb3# +Kxb3+ +Kxb4# +Kxb4+ +Kxb5# +Kxb5+ +Kxb6# +Kxb6+ +Kxb7# +Kxb7+ +Kxb8# +Kxb8+ +Kxc1# +Kxc1+ +Kxc2# +Kxc2+ +Kxc3# +Kxc3+ +Kxc4# +Kxc4+ +Kxc5# +Kxc5+ +Kxc6# +Kxc6+ +Kxc7# +Kxc7+ +Kxc8# +Kxc8+ +Kxd1# +Kxd1+ +Kxd2# +Kxd2+ +Kxd3# +Kxd3+ +Kxd4# +Kxd4+ +Kxd5# +Kxd5+ +Kxd6# +Kxd6+ +Kxd7# +Kxd7+ +Kxd8# +Kxd8+ +Kxe1# +Kxe1+ +Kxe2# +Kxe2+ +Kxe3# +Kxe3+ +Kxe4# +Kxe4+ +Kxe5# +Kxe5+ +Kxe6# +Kxe6+ +Kxe7# +Kxe7+ +Kxe8# +Kxe8+ +Kxf1# +Kxf1+ +Kxf2# +Kxf2+ +Kxf3# +Kxf3+ +Kxf4# +Kxf4+ +Kxf5# +Kxf5+ +Kxf6# +Kxf6+ +Kxf7# +Kxf7+ +Kxf8# +Kxf8+ +Kxg1# +Kxg1+ +Kxg2# +Kxg2+ +Kxg3# +Kxg3+ +Kxg4# +Kxg4+ +Kxg5# +Kxg5+ +Kxg6# +Kxg6+ +Kxg7# +Kxg7+ +Kxg8# +Kxg8+ +Kxh1# +Kxh1+ +Kxh2# +Kxh2+ +Kxh3# +Kxh3+ +Kxh4# +Kxh4+ +Kxh5# +Kxh5+ +Kxh6# +Kxh6+ +Kxh7# +Kxh7+ +Kxh8# +Kxh8+ +N1a2# +N1a2+ +N1a3# +N1a3+ +N1b2# +N1b2+ +N1b3# +N1b3+ +N1c2# +N1c2+ +N1c3# +N1c3+ +N1d2# +N1d2+ +N1d3# +N1d3+ +N1e2# +N1e2+ +N1e3# +N1e3+ +N1f2# +N1f2+ +N1f3# +N1f3+ +N1g2# +N1g2+ +N1g3# +N1g3+ +N1h2# +N1h2+ +N1h3# +N1h3+ +N1xa2 +N1xa3 +N1xb2 +N1xb3 +N1xc2 +N1xc3 +N1xd2 +N1xd3 +N1xe2 +N1xe3 +N1xf2 +N1xf3 +N1xg2 +N1xg3 +N1xh2 +N1xh3 +N2a3# +N2a3+ +N2a4# +N2a4+ +N2b3# +N2b3+ +N2b4# +N2b4+ +N2c3# +N2c3+ +N2c4# +N2c4+ +N2d3# +N2d3+ +N2d4# +N2d4+ +N2e3# +N2e3+ +N2e4# +N2e4+ +N2f3# +N2f3+ +N2f4# +N2f4+ +N2g3# +N2g3+ +N2g4# +N2g4+ +N2h3# +N2h3+ +N2h4# +N2h4+ +N2xa3 +N2xa4 +N2xb3 +N2xb4 +N2xc3 +N2xc4 +N2xd3 +N2xd4 +N2xe3 +N2xe4 +N2xf3 +N2xf4 +N2xg3 +N2xg4 +N2xh3 +N2xh4 +N3a2# +N3a2+ +N3a4# +N3a4+ +N3a5# +N3a5+ +N3b2# +N3b2+ +N3b4# +N3b4+ +N3b5# +N3b5+ +N3c2# +N3c2+ +N3c4# +N3c4+ +N3c5# +N3c5+ +N3d2# +N3d2+ +N3d4# +N3d4+ +N3d5# +N3d5+ +N3e2# +N3e2+ +N3e4# +N3e4+ +N3e5# +N3e5+ +N3f2# +N3f2+ +N3f4# +N3f4+ +N3f5# +N3f5+ +N3g2# +N3g2+ +N3g4# +N3g4+ +N3g5# +N3g5+ +N3h2# +N3h2+ +N3h4# +N3h4+ +N3h5# +N3h5+ +N3xa2 +N3xa4 +N3xa5 +N3xb2 +N3xb4 +N3xb5 +N3xc2 +N3xc4 +N3xc5 +N3xd2 +N3xd4 +N3xd5 +N3xe2 +N3xe4 +N3xe5 +N3xf2 +N3xf4 +N3xf5 +N3xg2 +N3xg4 +N3xg5 +N3xh2 +N3xh4 +N3xh5 +N4a3# +N4a3+ +N4a5# +N4a5+ +N4a6# +N4a6+ +N4b3# +N4b3+ +N4b5# +N4b5+ +N4b6# +N4b6+ +N4c3# +N4c3+ +N4c5# +N4c5+ +N4c6# +N4c6+ +N4d3# +N4d3+ +N4d5# +N4d5+ +N4d6# +N4d6+ +N4e3# +N4e3+ +N4e5# +N4e5+ +N4e6# +N4e6+ +N4f3# +N4f3+ +N4f5# +N4f5+ +N4f6# +N4f6+ +N4g3# +N4g3+ +N4g5# +N4g5+ +N4g6# +N4g6+ +N4h3# +N4h3+ +N4h5# +N4h5+ +N4h6# +N4h6+ +N4xa3 +N4xa5 +N4xa6 +N4xb3 +N4xb5 +N4xb6 +N4xc3 +N4xc5 +N4xc6 +N4xd3 +N4xd5 +N4xd6 +N4xe3 +N4xe5 +N4xe6 +N4xf3 +N4xf5 +N4xf6 +N4xg3 +N4xg5 +N4xg6 +N4xh3 +N4xh5 +N4xh6 +N5a3# +N5a3+ +N5a4# +N5a4+ +N5a6# +N5a6+ +N5b3# +N5b3+ +N5b4# +N5b4+ +N5b6# +N5b6+ +N5c3# +N5c3+ +N5c4# +N5c4+ +N5c6# +N5c6+ +N5d3# +N5d3+ +N5d4# +N5d4+ +N5d6# +N5d6+ +N5e3# +N5e3+ +N5e4# +N5e4+ +N5e6# +N5e6+ +N5f3# +N5f3+ +N5f4# +N5f4+ +N5f6# +N5f6+ +N5g3# +N5g3+ +N5g4# +N5g4+ +N5g6# +N5g6+ +N5h3# +N5h3+ +N5h4# +N5h4+ +N5h6# +N5h6+ +N5xa3 +N5xa4 +N5xa6 +N5xb3 +N5xb4 +N5xb6 +N5xc3 +N5xc4 +N5xc6 +N5xd3 +N5xd4 +N5xd6 +N5xe3 +N5xe4 +N5xe6 +N5xf3 +N5xf4 +N5xf6 +N5xg3 +N5xg4 +N5xg6 +N5xh3 +N5xh4 +N5xh6 +N6a4# +N6a4+ +N6a5# +N6a5+ +N6a7# +N6a7+ +N6b4# +N6b4+ +N6b5# +N6b5+ +N6b7# +N6b7+ +N6c4# +N6c4+ +N6c5# +N6c5+ +N6c7# +N6c7+ +N6d4# +N6d4+ +N6d5# +N6d5+ +N6d7# +N6d7+ +N6e4# +N6e4+ +N6e5# +N6e5+ +N6e7# +N6e7+ +N6f4# +N6f4+ +N6f5# +N6f5+ +N6f7# +N6f7+ +N6g4# +N6g4+ +N6g5# +N6g5+ +N6g7# +N6g7+ +N6h4# +N6h4+ +N6h5# +N6h5+ +N6h7# +N6h7+ +N6xa4 +N6xa5 +N6xa7 +N6xb4 +N6xb5 +N6xb7 +N6xc4 +N6xc5 +N6xc7 +N6xd4 +N6xd5 +N6xd7 +N6xe4 +N6xe5 +N6xe7 +N6xf4 +N6xf5 +N6xf7 +N6xg4 +N6xg5 +N6xg7 +N6xh4 +N6xh5 +N6xh7 +N7a5# +N7a5+ +N7a6# +N7a6+ +N7b5# +N7b5+ +N7b6# +N7b6+ +N7c5# +N7c5+ +N7c6# +N7c6+ +N7d5# +N7d5+ +N7d6# +N7d6+ +N7e5# +N7e5+ +N7e6# +N7e6+ +N7f5# +N7f5+ +N7f6# +N7f6+ +N7g5# +N7g5+ +N7g6# +N7g6+ +N7h5# +N7h5+ +N7h6# +N7h6+ +N7xa5 +N7xa6 +N7xb5 +N7xb6 +N7xc5 +N7xc6 +N7xd5 +N7xd6 +N7xe5 +N7xe6 +N7xf5 +N7xf6 +N7xg5 +N7xg6 +N7xh5 +N7xh6 +N8a6# +N8a6+ +N8a7# +N8a7+ +N8b6# +N8b6+ +N8b7# +N8b7+ +N8c6# +N8c6+ +N8c7# +N8c7+ +N8d6# +N8d6+ +N8d7# +N8d7+ +N8e6# +N8e6+ +N8e7# +N8e7+ +N8f6# +N8f6+ +N8f7# +N8f7+ +N8g6# +N8g6+ +N8g7# +N8g7+ +N8h6# +N8h6+ +N8h7# +N8h7+ +N8xa6 +N8xa7 +N8xb6 +N8xb7 +N8xc6 +N8xc7 +N8xd6 +N8xd7 +N8xe6 +N8xe7 +N8xf6 +N8xf7 +N8xg6 +N8xg7 +N8xh6 +N8xh7 +Na1b3 +Na1c2 +Na2b4 +Na2c3 +Na3b5 +Na3c2 +Na3c4 +Na4b6 +Na4c3 +Na4c5 +Na5b3 +Na5c4 +Na5c6 +Na6b4 +Na6c5 +Na6c7 +Na7b5 +Na7c6 +Na8b6 +Na8c7 +Nab1# +Nab1+ +Nab2# +Nab2+ +Nab3# +Nab3+ +Nab4# +Nab4+ +Nab5# +Nab5+ +Nab6# +Nab6+ +Nab7# +Nab7+ +Nab8# +Nab8+ +Nac1# +Nac1+ +Nac2# +Nac2+ +Nac3# +Nac3+ +Nac4# +Nac4+ +Nac5# +Nac5+ +Nac6# +Nac6+ +Nac7# +Nac7+ +Nac8# +Nac8+ +Naxb1 +Naxb2 +Naxb3 +Naxb4 +Naxb5 +Naxb6 +Naxb7 +Naxb8 +Naxc1 +Naxc2 +Naxc3 +Naxc4 +Naxc5 +Naxc6 +Naxc7 +Naxc8 +Nb1c3 +Nb1d2 +Nb2c4 +Nb2d3 +Nb3c5 +Nb3d2 +Nb3d4 +Nb4c6 +Nb4d3 +Nb4d5 +Nb5c3 +Nb5d4 +Nb5d6 +Nb6c4 +Nb6d5 +Nb6d7 +Nb7c5 +Nb7d6 +Nb8c6 +Nb8d7 +Nba1# +Nba1+ +Nba2# +Nba2+ +Nba3# +Nba3+ +Nba4# +Nba4+ +Nba5# +Nba5+ +Nba6# +Nba6+ +Nba7# +Nba7+ +Nba8# +Nba8+ +Nbc1# +Nbc1+ +Nbc2# +Nbc2+ +Nbc3# +Nbc3+ +Nbc4# +Nbc4+ +Nbc5# +Nbc5+ +Nbc6# +Nbc6+ +Nbc7# +Nbc7+ +Nbc8# +Nbc8+ +Nbd1# +Nbd1+ +Nbd2# +Nbd2+ +Nbd3# +Nbd3+ +Nbd4# +Nbd4+ +Nbd5# +Nbd5+ +Nbd6# +Nbd6+ +Nbd7# +Nbd7+ +Nbd8# +Nbd8+ +Nbxa1 +Nbxa2 +Nbxa3 +Nbxa4 +Nbxa5 +Nbxa6 +Nbxa7 +Nbxa8 +Nbxc1 +Nbxc2 +Nbxc3 +Nbxc4 +Nbxc5 +Nbxc6 +Nbxc7 +Nbxc8 +Nbxd1 +Nbxd2 +Nbxd3 +Nbxd4 +Nbxd5 +Nbxd6 +Nbxd7 +Nbxd8 +Nc1b3 +Nc1d3 +Nc1e2 +Nc2b4 +Nc2d4 +Nc2e3 +Nc3b5 +Nc3d5 +Nc3e2 +Nc3e4 +Nc4b6 +Nc4d6 +Nc4e3 +Nc4e5 +Nc5b3 +Nc5d3 +Nc5e4 +Nc5e6 +Nc6b4 +Nc6d4 +Nc6e5 +Nc6e7 +Nc7b5 +Nc7d5 +Nc7e6 +Nc8b6 +Nc8d6 +Nc8e7 +Nca1# +Nca1+ +Nca2# +Nca2+ +Nca3# +Nca3+ +Nca4# +Nca4+ +Nca5# +Nca5+ +Nca6# +Nca6+ +Nca7# +Nca7+ +Nca8# +Nca8+ +Ncb1# +Ncb1+ +Ncb2# +Ncb2+ +Ncb3# +Ncb3+ +Ncb4# +Ncb4+ +Ncb5# +Ncb5+ +Ncb6# +Ncb6+ +Ncb7# +Ncb7+ +Ncb8# +Ncb8+ +Ncd1# +Ncd1+ +Ncd2# +Ncd2+ +Ncd3# +Ncd3+ +Ncd4# +Ncd4+ +Ncd5# +Ncd5+ +Ncd6# +Ncd6+ +Ncd7# +Ncd7+ +Ncd8# +Ncd8+ +Nce1# +Nce1+ +Nce2# +Nce2+ +Nce3# +Nce3+ +Nce4# +Nce4+ +Nce5# +Nce5+ +Nce6# +Nce6+ +Nce7# +Nce7+ +Nce8# +Nce8+ +Ncxa1 +Ncxa2 +Ncxa3 +Ncxa4 +Ncxa5 +Ncxa6 +Ncxa7 +Ncxa8 +Ncxb1 +Ncxb2 +Ncxb3 +Ncxb4 +Ncxb5 +Ncxb6 +Ncxb7 +Ncxb8 +Ncxd1 +Ncxd2 +Ncxd3 +Ncxd4 +Ncxd5 +Ncxd6 +Ncxd7 +Ncxd8 +Ncxe1 +Ncxe2 +Ncxe3 +Ncxe4 +Ncxe5 +Ncxe6 +Ncxe7 +Ncxe8 +Nd1c3 +Nd1e3 +Nd1f2 +Nd2c4 +Nd2e4 +Nd2f3 +Nd3c5 +Nd3e5 +Nd3f2 +Nd3f4 +Nd4c6 +Nd4e6 +Nd4f3 +Nd4f5 +Nd5c3 +Nd5e3 +Nd5f4 +Nd5f6 +Nd6c4 +Nd6e4 +Nd6f5 +Nd6f7 +Nd7c5 +Nd7e5 +Nd7f6 +Nd8c6 +Nd8e6 +Nd8f7 +Ndb1# +Ndb1+ +Ndb2# +Ndb2+ +Ndb3# +Ndb3+ +Ndb4# +Ndb4+ +Ndb5# +Ndb5+ +Ndb6# +Ndb6+ +Ndb7# +Ndb7+ +Ndb8# +Ndb8+ +Ndc1# +Ndc1+ +Ndc2# +Ndc2+ +Ndc3# +Ndc3+ +Ndc4# +Ndc4+ +Ndc5# +Ndc5+ +Ndc6# +Ndc6+ +Ndc7# +Ndc7+ +Ndc8# +Ndc8+ +Nde1# +Nde1+ +Nde2# +Nde2+ +Nde3# +Nde3+ +Nde4# +Nde4+ +Nde5# +Nde5+ +Nde6# +Nde6+ +Nde7# +Nde7+ +Nde8# +Nde8+ +Ndf1# +Ndf1+ +Ndf2# +Ndf2+ +Ndf3# +Ndf3+ +Ndf4# +Ndf4+ +Ndf5# +Ndf5+ +Ndf6# +Ndf6+ +Ndf7# +Ndf7+ +Ndf8# +Ndf8+ +Ndxb1 +Ndxb2 +Ndxb3 +Ndxb4 +Ndxb5 +Ndxb6 +Ndxb7 +Ndxb8 +Ndxc1 +Ndxc2 +Ndxc3 +Ndxc4 +Ndxc5 +Ndxc6 +Ndxc7 +Ndxc8 +Ndxe1 +Ndxe2 +Ndxe3 +Ndxe4 +Ndxe5 +Ndxe6 +Ndxe7 +Ndxe8 +Ndxf1 +Ndxf2 +Ndxf3 +Ndxf4 +Ndxf5 +Ndxf6 +Ndxf7 +Ndxf8 +Ne1c2 +Ne1d3 +Ne1f3 +Ne2c3 +Ne2d4 +Ne2f4 +Ne3c2 +Ne3c4 +Ne3d5 +Ne3f5 +Ne4c3 +Ne4c5 +Ne4d6 +Ne4f6 +Ne5c4 +Ne5c6 +Ne5d3 +Ne5f3 +Ne6c5 +Ne6c7 +Ne6d4 +Ne6f4 +Ne7c6 +Ne7d5 +Ne7f5 +Ne8c7 +Ne8d6 +Ne8f6 +Nec1# +Nec1+ +Nec2# +Nec2+ +Nec3# +Nec3+ +Nec4# +Nec4+ +Nec5# +Nec5+ +Nec6# +Nec6+ +Nec7# +Nec7+ +Nec8# +Nec8+ +Ned1# +Ned1+ +Ned2# +Ned2+ +Ned3# +Ned3+ +Ned4# +Ned4+ +Ned5# +Ned5+ +Ned6# +Ned6+ +Ned7# +Ned7+ +Ned8# +Ned8+ +Nef1# +Nef1+ +Nef2# +Nef2+ +Nef3# +Nef3+ +Nef4# +Nef4+ +Nef5# +Nef5+ +Nef6# +Nef6+ +Nef7# +Nef7+ +Nef8# +Nef8+ +Neg1# +Neg1+ +Neg2# +Neg2+ +Neg3# +Neg3+ +Neg4# +Neg4+ +Neg5# +Neg5+ +Neg6# +Neg6+ +Neg7# +Neg7+ +Neg8# +Neg8+ +Nexc1 +Nexc2 +Nexc3 +Nexc4 +Nexc5 +Nexc6 +Nexc7 +Nexc8 +Nexd1 +Nexd2 +Nexd3 +Nexd4 +Nexd5 +Nexd6 +Nexd7 +Nexd8 +Nexf1 +Nexf2 +Nexf3 +Nexf4 +Nexf5 +Nexf6 +Nexf7 +Nexf8 +Nexg1 +Nexg2 +Nexg3 +Nexg4 +Nexg5 +Nexg6 +Nexg7 +Nexg8 +Nf1d2 +Nf1e3 +Nf1g3 +Nf2d3 +Nf2e4 +Nf2g4 +Nf3d2 +Nf3d4 +Nf3e5 +Nf3g5 +Nf4d3 +Nf4d5 +Nf4e6 +Nf4g6 +Nf5d4 +Nf5d6 +Nf5e3 +Nf5g3 +Nf6d5 +Nf6d7 +Nf6e4 +Nf6g4 +Nf7d6 +Nf7e5 +Nf7g5 +Nf8d7 +Nf8e6 +Nf8g6 +Nfd1# +Nfd1+ +Nfd2# +Nfd2+ +Nfd3# +Nfd3+ +Nfd4# +Nfd4+ +Nfd5# +Nfd5+ +Nfd6# +Nfd6+ +Nfd7# +Nfd7+ +Nfd8# +Nfd8+ +Nfe1# +Nfe1+ +Nfe2# +Nfe2+ +Nfe3# +Nfe3+ +Nfe4# +Nfe4+ +Nfe5# +Nfe5+ +Nfe6# +Nfe6+ +Nfe7# +Nfe7+ +Nfe8# +Nfe8+ +Nfg1# +Nfg1+ +Nfg2# +Nfg2+ +Nfg3# +Nfg3+ +Nfg4# +Nfg4+ +Nfg5# +Nfg5+ +Nfg6# +Nfg6+ +Nfg7# +Nfg7+ +Nfg8# +Nfg8+ +Nfh1# +Nfh1+ +Nfh2# +Nfh2+ +Nfh3# +Nfh3+ +Nfh4# +Nfh4+ +Nfh5# +Nfh5+ +Nfh6# +Nfh6+ +Nfh7# +Nfh7+ +Nfh8# +Nfh8+ +Nfxd1 +Nfxd2 +Nfxd3 +Nfxd4 +Nfxd5 +Nfxd6 +Nfxd7 +Nfxd8 +Nfxe1 +Nfxe2 +Nfxe3 +Nfxe4 +Nfxe5 +Nfxe6 +Nfxe7 +Nfxe8 +Nfxg1 +Nfxg2 +Nfxg3 +Nfxg4 +Nfxg5 +Nfxg6 +Nfxg7 +Nfxg8 +Nfxh1 +Nfxh2 +Nfxh3 +Nfxh4 +Nfxh5 +Nfxh6 +Nfxh7 +Nfxh8 +Ng1e2 +Ng1f3 +Ng2e3 +Ng2f4 +Ng3e2 +Ng3e4 +Ng3f5 +Ng4e3 +Ng4e5 +Ng4f6 +Ng5e4 +Ng5e6 +Ng5f3 +Ng6e5 +Ng6e7 +Ng6f4 +Ng7e6 +Ng7f5 +Ng8e7 +Ng8f6 +Nge1# +Nge1+ +Nge2# +Nge2+ +Nge3# +Nge3+ +Nge4# +Nge4+ +Nge5# +Nge5+ +Nge6# +Nge6+ +Nge7# +Nge7+ +Nge8# +Nge8+ +Ngf1# +Ngf1+ +Ngf2# +Ngf2+ +Ngf3# +Ngf3+ +Ngf4# +Ngf4+ +Ngf5# +Ngf5+ +Ngf6# +Ngf6+ +Ngf7# +Ngf7+ +Ngf8# +Ngf8+ +Ngh1# +Ngh1+ +Ngh2# +Ngh2+ +Ngh3# +Ngh3+ +Ngh4# +Ngh4+ +Ngh5# +Ngh5+ +Ngh6# +Ngh6+ +Ngh7# +Ngh7+ +Ngh8# +Ngh8+ +Ngxe1 +Ngxe2 +Ngxe3 +Ngxe4 +Ngxe5 +Ngxe6 +Ngxe7 +Ngxe8 +Ngxf1 +Ngxf2 +Ngxf3 +Ngxf4 +Ngxf5 +Ngxf6 +Ngxf7 +Ngxf8 +Ngxh1 +Ngxh2 +Ngxh3 +Ngxh4 +Ngxh5 +Ngxh6 +Ngxh7 +Ngxh8 +Nh1f2 +Nh1g3 +Nh2f3 +Nh2g4 +Nh3f2 +Nh3f4 +Nh3g5 +Nh4f3 +Nh4f5 +Nh4g6 +Nh5f4 +Nh5f6 +Nh5g3 +Nh6f5 +Nh6f7 +Nh6g4 +Nh7f6 +Nh7g5 +Nh8f7 +Nh8g6 +Nhf1# +Nhf1+ +Nhf2# +Nhf2+ +Nhf3# +Nhf3+ +Nhf4# +Nhf4+ +Nhf5# +Nhf5+ +Nhf6# +Nhf6+ +Nhf7# +Nhf7+ +Nhf8# +Nhf8+ +Nhg1# +Nhg1+ +Nhg2# +Nhg2+ +Nhg3# +Nhg3+ +Nhg4# +Nhg4+ +Nhg5# +Nhg5+ +Nhg6# +Nhg6+ +Nhg7# +Nhg7+ +Nhg8# +Nhg8+ +Nhxf1 +Nhxf2 +Nhxf3 +Nhxf4 +Nhxf5 +Nhxf6 +Nhxf7 +Nhxf8 +Nhxg1 +Nhxg2 +Nhxg3 +Nhxg4 +Nhxg5 +Nhxg6 +Nhxg7 +Nhxg8 +Nxa1# +Nxa1+ +Nxa2# +Nxa2+ +Nxa3# +Nxa3+ +Nxa4# +Nxa4+ +Nxa5# +Nxa5+ +Nxa6# +Nxa6+ +Nxa7# +Nxa7+ +Nxa8# +Nxa8+ +Nxb1# +Nxb1+ +Nxb2# +Nxb2+ +Nxb3# +Nxb3+ +Nxb4# +Nxb4+ +Nxb5# +Nxb5+ +Nxb6# +Nxb6+ +Nxb7# +Nxb7+ +Nxb8# +Nxb8+ +Nxc1# +Nxc1+ +Nxc2# +Nxc2+ +Nxc3# +Nxc3+ +Nxc4# +Nxc4+ +Nxc5# +Nxc5+ +Nxc6# +Nxc6+ +Nxc7# +Nxc7+ +Nxc8# +Nxc8+ +Nxd1# +Nxd1+ +Nxd2# +Nxd2+ +Nxd3# +Nxd3+ +Nxd4# +Nxd4+ +Nxd5# +Nxd5+ +Nxd6# +Nxd6+ +Nxd7# +Nxd7+ +Nxd8# +Nxd8+ +Nxe1# +Nxe1+ +Nxe2# +Nxe2+ +Nxe3# +Nxe3+ +Nxe4# +Nxe4+ +Nxe5# +Nxe5+ +Nxe6# +Nxe6+ +Nxe7# +Nxe7+ +Nxe8# +Nxe8+ +Nxf1# +Nxf1+ +Nxf2# +Nxf2+ +Nxf3# +Nxf3+ +Nxf4# +Nxf4+ +Nxf5# +Nxf5+ +Nxf6# +Nxf6+ +Nxf7# +Nxf7+ +Nxf8# +Nxf8+ +Nxg1# +Nxg1+ +Nxg2# +Nxg2+ +Nxg3# +Nxg3+ +Nxg4# +Nxg4+ +Nxg5# +Nxg5+ +Nxg6# +Nxg6+ +Nxg7# +Nxg7+ +Nxg8# +Nxg8+ +Nxh1# +Nxh1+ +Nxh2# +Nxh2+ +Nxh3# +Nxh3+ +Nxh4# +Nxh4+ +Nxh5# +Nxh5+ +Nxh6# +Nxh6+ +Nxh7# +Nxh7+ +Nxh8# +Nxh8+ +O-O-O +Q1a1# +Q1a1+ +Q1a2# +Q1a2+ +Q1a3# +Q1a3+ +Q1a4# +Q1a4+ +Q1a5# +Q1a5+ +Q1a6# +Q1a6+ +Q1a7# +Q1a7+ +Q1a8# +Q1a8+ +Q1b1# +Q1b1+ +Q1b2# +Q1b2+ +Q1b3# +Q1b3+ +Q1b4# +Q1b4+ +Q1b5# +Q1b5+ +Q1b6# +Q1b6+ +Q1b7# +Q1b7+ +Q1c1# +Q1c1+ +Q1c2# +Q1c2+ +Q1c3# +Q1c3+ +Q1c4# +Q1c4+ +Q1c5# +Q1c5+ +Q1c6# +Q1c6+ +Q1c7# +Q1c7+ +Q1d1# +Q1d1+ +Q1d2# +Q1d2+ +Q1d3# +Q1d3+ +Q1d4# +Q1d4+ +Q1d5# +Q1d5+ +Q1d6# +Q1d6+ +Q1d7# +Q1d7+ +Q1e1# +Q1e1+ +Q1e2# +Q1e2+ +Q1e3# +Q1e3+ +Q1e4# +Q1e4+ +Q1e5# +Q1e5+ +Q1e6# +Q1e6+ +Q1e7# +Q1e7+ +Q1f1# +Q1f1+ +Q1f2# +Q1f2+ +Q1f3# +Q1f3+ +Q1f4# +Q1f4+ +Q1f5# +Q1f5+ +Q1f6# +Q1f6+ +Q1f7# +Q1f7+ +Q1g1# +Q1g1+ +Q1g2# +Q1g2+ +Q1g3# +Q1g3+ +Q1g4# +Q1g4+ +Q1g5# +Q1g5+ +Q1g6# +Q1g6+ +Q1g7# +Q1g7+ +Q1h1# +Q1h1+ +Q1h2# +Q1h2+ +Q1h3# +Q1h3+ +Q1h4# +Q1h4+ +Q1h5# +Q1h5+ +Q1h6# +Q1h6+ +Q1h7# +Q1h7+ +Q1h8# +Q1h8+ +Q1xa1 +Q1xa2 +Q1xa3 +Q1xa4 +Q1xa5 +Q1xa6 +Q1xa7 +Q1xa8 +Q1xb1 +Q1xb2 +Q1xb3 +Q1xb4 +Q1xb5 +Q1xb6 +Q1xb7 +Q1xc1 +Q1xc2 +Q1xc3 +Q1xc4 +Q1xc5 +Q1xc6 +Q1xc7 +Q1xd1 +Q1xd2 +Q1xd3 +Q1xd4 +Q1xd5 +Q1xd6 +Q1xd7 +Q1xe1 +Q1xe2 +Q1xe3 +Q1xe4 +Q1xe5 +Q1xe6 +Q1xe7 +Q1xf1 +Q1xf2 +Q1xf3 +Q1xf4 +Q1xf5 +Q1xf6 +Q1xf7 +Q1xg1 +Q1xg2 +Q1xg3 +Q1xg4 +Q1xg5 +Q1xg6 +Q1xg7 +Q1xh1 +Q1xh2 +Q1xh3 +Q1xh4 +Q1xh5 +Q1xh6 +Q1xh7 +Q1xh8 +Q2a1# +Q2a1+ +Q2a2# +Q2a2+ +Q2a3# +Q2a3+ +Q2a4# +Q2a4+ +Q2a5# +Q2a5+ +Q2a6# +Q2a6+ +Q2a7# +Q2a7+ +Q2a8# +Q2a8+ +Q2b1# +Q2b1+ +Q2b2# +Q2b2+ +Q2b3# +Q2b3+ +Q2b4# +Q2b4+ +Q2b5# +Q2b5+ +Q2b6# +Q2b6+ +Q2b7# +Q2b7+ +Q2b8# +Q2b8+ +Q2c1# +Q2c1+ +Q2c2# +Q2c2+ +Q2c3# +Q2c3+ +Q2c4# +Q2c4+ +Q2c5# +Q2c5+ +Q2c6# +Q2c6+ +Q2c7# +Q2c7+ +Q2d1# +Q2d1+ +Q2d2# +Q2d2+ +Q2d3# +Q2d3+ +Q2d4# +Q2d4+ +Q2d5# +Q2d5+ +Q2d6# +Q2d6+ +Q2d7# +Q2d7+ +Q2e1# +Q2e1+ +Q2e2# +Q2e2+ +Q2e3# +Q2e3+ +Q2e4# +Q2e4+ +Q2e5# +Q2e5+ +Q2e6# +Q2e6+ +Q2e7# +Q2e7+ +Q2f1# +Q2f1+ +Q2f2# +Q2f2+ +Q2f3# +Q2f3+ +Q2f4# +Q2f4+ +Q2f5# +Q2f5+ +Q2f6# +Q2f6+ +Q2f7# +Q2f7+ +Q2g1# +Q2g1+ +Q2g2# +Q2g2+ +Q2g3# +Q2g3+ +Q2g4# +Q2g4+ +Q2g5# +Q2g5+ +Q2g6# +Q2g6+ +Q2g7# +Q2g7+ +Q2g8# +Q2g8+ +Q2h1# +Q2h1+ +Q2h2# +Q2h2+ +Q2h3# +Q2h3+ +Q2h4# +Q2h4+ +Q2h5# +Q2h5+ +Q2h6# +Q2h6+ +Q2h7# +Q2h7+ +Q2h8# +Q2h8+ +Q2xa1 +Q2xa2 +Q2xa3 +Q2xa4 +Q2xa5 +Q2xa6 +Q2xa7 +Q2xa8 +Q2xb1 +Q2xb2 +Q2xb3 +Q2xb4 +Q2xb5 +Q2xb6 +Q2xb7 +Q2xb8 +Q2xc1 +Q2xc2 +Q2xc3 +Q2xc4 +Q2xc5 +Q2xc6 +Q2xc7 +Q2xd1 +Q2xd2 +Q2xd3 +Q2xd4 +Q2xd5 +Q2xd6 +Q2xd7 +Q2xe1 +Q2xe2 +Q2xe3 +Q2xe4 +Q2xe5 +Q2xe6 +Q2xe7 +Q2xf1 +Q2xf2 +Q2xf3 +Q2xf4 +Q2xf5 +Q2xf6 +Q2xf7 +Q2xg1 +Q2xg2 +Q2xg3 +Q2xg4 +Q2xg5 +Q2xg6 +Q2xg7 +Q2xg8 +Q2xh1 +Q2xh2 +Q2xh3 +Q2xh4 +Q2xh5 +Q2xh6 +Q2xh7 +Q2xh8 +Q3a1# +Q3a1+ +Q3a2# +Q3a2+ +Q3a3# +Q3a3+ +Q3a4# +Q3a4+ +Q3a5# +Q3a5+ +Q3a6# +Q3a6+ +Q3a7# +Q3a7+ +Q3a8# +Q3a8+ +Q3b1# +Q3b1+ +Q3b2# +Q3b2+ +Q3b3# +Q3b3+ +Q3b4# +Q3b4+ +Q3b5# +Q3b5+ +Q3b6# +Q3b6+ +Q3b7# +Q3b7+ +Q3b8# +Q3b8+ +Q3c1# +Q3c1+ +Q3c2# +Q3c2+ +Q3c3# +Q3c3+ +Q3c4# +Q3c4+ +Q3c5# +Q3c5+ +Q3c6# +Q3c6+ +Q3c7# +Q3c7+ +Q3c8# +Q3c8+ +Q3d1# +Q3d1+ +Q3d2# +Q3d2+ +Q3d3# +Q3d3+ +Q3d4# +Q3d4+ +Q3d5# +Q3d5+ +Q3d6# +Q3d6+ +Q3d7# +Q3d7+ +Q3e1# +Q3e1+ +Q3e2# +Q3e2+ +Q3e3# +Q3e3+ +Q3e4# +Q3e4+ +Q3e5# +Q3e5+ +Q3e6# +Q3e6+ +Q3e7# +Q3e7+ +Q3f1# +Q3f1+ +Q3f2# +Q3f2+ +Q3f3# +Q3f3+ +Q3f4# +Q3f4+ +Q3f5# +Q3f5+ +Q3f6# +Q3f6+ +Q3f7# +Q3f7+ +Q3f8# +Q3f8+ +Q3g1# +Q3g1+ +Q3g2# +Q3g2+ +Q3g3# +Q3g3+ +Q3g4# +Q3g4+ +Q3g5# +Q3g5+ +Q3g6# +Q3g6+ +Q3g7# +Q3g7+ +Q3g8# +Q3g8+ +Q3h1# +Q3h1+ +Q3h2# +Q3h2+ +Q3h3# +Q3h3+ +Q3h4# +Q3h4+ +Q3h5# +Q3h5+ +Q3h6# +Q3h6+ +Q3h7# +Q3h7+ +Q3h8# +Q3h8+ +Q3xa1 +Q3xa2 +Q3xa3 +Q3xa4 +Q3xa5 +Q3xa6 +Q3xa7 +Q3xa8 +Q3xb1 +Q3xb2 +Q3xb3 +Q3xb4 +Q3xb5 +Q3xb6 +Q3xb7 +Q3xb8 +Q3xc1 +Q3xc2 +Q3xc3 +Q3xc4 +Q3xc5 +Q3xc6 +Q3xc7 +Q3xc8 +Q3xd1 +Q3xd2 +Q3xd3 +Q3xd4 +Q3xd5 +Q3xd6 +Q3xd7 +Q3xe1 +Q3xe2 +Q3xe3 +Q3xe4 +Q3xe5 +Q3xe6 +Q3xe7 +Q3xf1 +Q3xf2 +Q3xf3 +Q3xf4 +Q3xf5 +Q3xf6 +Q3xf7 +Q3xf8 +Q3xg1 +Q3xg2 +Q3xg3 +Q3xg4 +Q3xg5 +Q3xg6 +Q3xg7 +Q3xg8 +Q3xh1 +Q3xh2 +Q3xh3 +Q3xh4 +Q3xh5 +Q3xh6 +Q3xh7 +Q3xh8 +Q4a1# +Q4a1+ +Q4a2# +Q4a2+ +Q4a3# +Q4a3+ +Q4a4# +Q4a4+ +Q4a5# +Q4a5+ +Q4a6# +Q4a6+ +Q4a7# +Q4a7+ +Q4a8# +Q4a8+ +Q4b1# +Q4b1+ +Q4b2# +Q4b2+ +Q4b3# +Q4b3+ +Q4b4# +Q4b4+ +Q4b5# +Q4b5+ +Q4b6# +Q4b6+ +Q4b7# +Q4b7+ +Q4b8# +Q4b8+ +Q4c1# +Q4c1+ +Q4c2# +Q4c2+ +Q4c3# +Q4c3+ +Q4c4# +Q4c4+ +Q4c5# +Q4c5+ +Q4c6# +Q4c6+ +Q4c7# +Q4c7+ +Q4c8# +Q4c8+ +Q4d1# +Q4d1+ +Q4d2# +Q4d2+ +Q4d3# +Q4d3+ +Q4d4# +Q4d4+ +Q4d5# +Q4d5+ +Q4d6# +Q4d6+ +Q4d7# +Q4d7+ +Q4d8# +Q4d8+ +Q4e1# +Q4e1+ +Q4e2# +Q4e2+ +Q4e3# +Q4e3+ +Q4e4# +Q4e4+ +Q4e5# +Q4e5+ +Q4e6# +Q4e6+ +Q4e7# +Q4e7+ +Q4e8# +Q4e8+ +Q4f1# +Q4f1+ +Q4f2# +Q4f2+ +Q4f3# +Q4f3+ +Q4f4# +Q4f4+ +Q4f5# +Q4f5+ +Q4f6# +Q4f6+ +Q4f7# +Q4f7+ +Q4f8# +Q4f8+ +Q4g1# +Q4g1+ +Q4g2# +Q4g2+ +Q4g3# +Q4g3+ +Q4g4# +Q4g4+ +Q4g5# +Q4g5+ +Q4g6# +Q4g6+ +Q4g7# +Q4g7+ +Q4g8# +Q4g8+ +Q4h1# +Q4h1+ +Q4h2# +Q4h2+ +Q4h3# +Q4h3+ +Q4h4# +Q4h4+ +Q4h5# +Q4h5+ +Q4h6# +Q4h6+ +Q4h7# +Q4h7+ +Q4h8# +Q4h8+ +Q4xa1 +Q4xa2 +Q4xa3 +Q4xa4 +Q4xa5 +Q4xa6 +Q4xa7 +Q4xa8 +Q4xb1 +Q4xb2 +Q4xb3 +Q4xb4 +Q4xb5 +Q4xb6 +Q4xb7 +Q4xb8 +Q4xc1 +Q4xc2 +Q4xc3 +Q4xc4 +Q4xc5 +Q4xc6 +Q4xc7 +Q4xc8 +Q4xd1 +Q4xd2 +Q4xd3 +Q4xd4 +Q4xd5 +Q4xd6 +Q4xd7 +Q4xd8 +Q4xe1 +Q4xe2 +Q4xe3 +Q4xe4 +Q4xe5 +Q4xe6 +Q4xe7 +Q4xe8 +Q4xf1 +Q4xf2 +Q4xf3 +Q4xf4 +Q4xf5 +Q4xf6 +Q4xf7 +Q4xf8 +Q4xg1 +Q4xg2 +Q4xg3 +Q4xg4 +Q4xg5 +Q4xg6 +Q4xg7 +Q4xg8 +Q4xh1 +Q4xh2 +Q4xh3 +Q4xh4 +Q4xh5 +Q4xh6 +Q4xh7 +Q4xh8 +Q5a1# +Q5a1+ +Q5a2# +Q5a2+ +Q5a3# +Q5a3+ +Q5a4# +Q5a4+ +Q5a5# +Q5a5+ +Q5a6# +Q5a6+ +Q5a7# +Q5a7+ +Q5a8# +Q5a8+ +Q5b1# +Q5b1+ +Q5b2# +Q5b2+ +Q5b3# +Q5b3+ +Q5b4# +Q5b4+ +Q5b5# +Q5b5+ +Q5b6# +Q5b6+ +Q5b7# +Q5b7+ +Q5b8# +Q5b8+ +Q5c1# +Q5c1+ +Q5c2# +Q5c2+ +Q5c3# +Q5c3+ +Q5c4# +Q5c4+ +Q5c5# +Q5c5+ +Q5c6# +Q5c6+ +Q5c7# +Q5c7+ +Q5c8# +Q5c8+ +Q5d1# +Q5d1+ +Q5d2# +Q5d2+ +Q5d3# +Q5d3+ +Q5d4# +Q5d4+ +Q5d5# +Q5d5+ +Q5d6# +Q5d6+ +Q5d7# +Q5d7+ +Q5d8# +Q5d8+ +Q5e1# +Q5e1+ +Q5e2# +Q5e2+ +Q5e3# +Q5e3+ +Q5e4# +Q5e4+ +Q5e5# +Q5e5+ +Q5e6# +Q5e6+ +Q5e7# +Q5e7+ +Q5e8# +Q5e8+ +Q5f1# +Q5f1+ +Q5f2# +Q5f2+ +Q5f3# +Q5f3+ +Q5f4# +Q5f4+ +Q5f5# +Q5f5+ +Q5f6# +Q5f6+ +Q5f7# +Q5f7+ +Q5f8# +Q5f8+ +Q5g1# +Q5g1+ +Q5g2# +Q5g2+ +Q5g3# +Q5g3+ +Q5g4# +Q5g4+ +Q5g5# +Q5g5+ +Q5g6# +Q5g6+ +Q5g7# +Q5g7+ +Q5g8# +Q5g8+ +Q5h1# +Q5h1+ +Q5h2# +Q5h2+ +Q5h3# +Q5h3+ +Q5h4# +Q5h4+ +Q5h5# +Q5h5+ +Q5h6# +Q5h6+ +Q5h7# +Q5h7+ +Q5h8# +Q5h8+ +Q5xa1 +Q5xa2 +Q5xa3 +Q5xa4 +Q5xa5 +Q5xa6 +Q5xa7 +Q5xa8 +Q5xb1 +Q5xb2 +Q5xb3 +Q5xb4 +Q5xb5 +Q5xb6 +Q5xb7 +Q5xb8 +Q5xc1 +Q5xc2 +Q5xc3 +Q5xc4 +Q5xc5 +Q5xc6 +Q5xc7 +Q5xc8 +Q5xd1 +Q5xd2 +Q5xd3 +Q5xd4 +Q5xd5 +Q5xd6 +Q5xd7 +Q5xd8 +Q5xe1 +Q5xe2 +Q5xe3 +Q5xe4 +Q5xe5 +Q5xe6 +Q5xe7 +Q5xe8 +Q5xf1 +Q5xf2 +Q5xf3 +Q5xf4 +Q5xf5 +Q5xf6 +Q5xf7 +Q5xf8 +Q5xg1 +Q5xg2 +Q5xg3 +Q5xg4 +Q5xg5 +Q5xg6 +Q5xg7 +Q5xg8 +Q5xh1 +Q5xh2 +Q5xh3 +Q5xh4 +Q5xh5 +Q5xh6 +Q5xh7 +Q5xh8 +Q6a1# +Q6a1+ +Q6a2# +Q6a2+ +Q6a3# +Q6a3+ +Q6a4# +Q6a4+ +Q6a5# +Q6a5+ +Q6a6# +Q6a6+ +Q6a7# +Q6a7+ +Q6a8# +Q6a8+ +Q6b1# +Q6b1+ +Q6b2# +Q6b2+ +Q6b3# +Q6b3+ +Q6b4# +Q6b4+ +Q6b5# +Q6b5+ +Q6b6# +Q6b6+ +Q6b7# +Q6b7+ +Q6b8# +Q6b8+ +Q6c1# +Q6c1+ +Q6c2# +Q6c2+ +Q6c3# +Q6c3+ +Q6c4# +Q6c4+ +Q6c5# +Q6c5+ +Q6c6# +Q6c6+ +Q6c7# +Q6c7+ +Q6c8# +Q6c8+ +Q6d2# +Q6d2+ +Q6d3# +Q6d3+ +Q6d4# +Q6d4+ +Q6d5# +Q6d5+ +Q6d6# +Q6d6+ +Q6d7# +Q6d7+ +Q6d8# +Q6d8+ +Q6e2# +Q6e2+ +Q6e3# +Q6e3+ +Q6e4# +Q6e4+ +Q6e5# +Q6e5+ +Q6e6# +Q6e6+ +Q6e7# +Q6e7+ +Q6e8# +Q6e8+ +Q6f1# +Q6f1+ +Q6f2# +Q6f2+ +Q6f3# +Q6f3+ +Q6f4# +Q6f4+ +Q6f5# +Q6f5+ +Q6f6# +Q6f6+ +Q6f7# +Q6f7+ +Q6f8# +Q6f8+ +Q6g1# +Q6g1+ +Q6g2# +Q6g2+ +Q6g3# +Q6g3+ +Q6g4# +Q6g4+ +Q6g5# +Q6g5+ +Q6g6# +Q6g6+ +Q6g7# +Q6g7+ +Q6g8# +Q6g8+ +Q6h1# +Q6h1+ +Q6h2# +Q6h2+ +Q6h3# +Q6h3+ +Q6h4# +Q6h4+ +Q6h5# +Q6h5+ +Q6h6# +Q6h6+ +Q6h7# +Q6h7+ +Q6h8# +Q6h8+ +Q6xa1 +Q6xa2 +Q6xa3 +Q6xa4 +Q6xa5 +Q6xa6 +Q6xa7 +Q6xa8 +Q6xb1 +Q6xb2 +Q6xb3 +Q6xb4 +Q6xb5 +Q6xb6 +Q6xb7 +Q6xb8 +Q6xc1 +Q6xc2 +Q6xc3 +Q6xc4 +Q6xc5 +Q6xc6 +Q6xc7 +Q6xc8 +Q6xd2 +Q6xd3 +Q6xd4 +Q6xd5 +Q6xd6 +Q6xd7 +Q6xd8 +Q6xe2 +Q6xe3 +Q6xe4 +Q6xe5 +Q6xe6 +Q6xe7 +Q6xe8 +Q6xf1 +Q6xf2 +Q6xf3 +Q6xf4 +Q6xf5 +Q6xf6 +Q6xf7 +Q6xf8 +Q6xg1 +Q6xg2 +Q6xg3 +Q6xg4 +Q6xg5 +Q6xg6 +Q6xg7 +Q6xg8 +Q6xh1 +Q6xh2 +Q6xh3 +Q6xh4 +Q6xh5 +Q6xh6 +Q6xh7 +Q6xh8 +Q7a1# +Q7a1+ +Q7a2# +Q7a2+ +Q7a3# +Q7a3+ +Q7a4# +Q7a4+ +Q7a5# +Q7a5+ +Q7a6# +Q7a6+ +Q7a7# +Q7a7+ +Q7a8# +Q7a8+ +Q7b1# +Q7b1+ +Q7b2# +Q7b2+ +Q7b3# +Q7b3+ +Q7b4# +Q7b4+ +Q7b5# +Q7b5+ +Q7b6# +Q7b6+ +Q7b7# +Q7b7+ +Q7b8# +Q7b8+ +Q7c2# +Q7c2+ +Q7c3# +Q7c3+ +Q7c4# +Q7c4+ +Q7c5# +Q7c5+ +Q7c6# +Q7c6+ +Q7c7# +Q7c7+ +Q7c8# +Q7c8+ +Q7d2# +Q7d2+ +Q7d3# +Q7d3+ +Q7d4# +Q7d4+ +Q7d5# +Q7d5+ +Q7d6# +Q7d6+ +Q7d7# +Q7d7+ +Q7d8# +Q7d8+ +Q7e2# +Q7e2+ +Q7e3# +Q7e3+ +Q7e4# +Q7e4+ +Q7e5# +Q7e5+ +Q7e6# +Q7e6+ +Q7e7# +Q7e7+ +Q7e8# +Q7e8+ +Q7f2# +Q7f2+ +Q7f3# +Q7f3+ +Q7f4# +Q7f4+ +Q7f5# +Q7f5+ +Q7f6# +Q7f6+ +Q7f7# +Q7f7+ +Q7f8# +Q7f8+ +Q7g1# +Q7g1+ +Q7g2# +Q7g2+ +Q7g3# +Q7g3+ +Q7g4# +Q7g4+ +Q7g5# +Q7g5+ +Q7g6# +Q7g6+ +Q7g7# +Q7g7+ +Q7g8# +Q7g8+ +Q7h1# +Q7h1+ +Q7h2# +Q7h2+ +Q7h3# +Q7h3+ +Q7h4# +Q7h4+ +Q7h5# +Q7h5+ +Q7h6# +Q7h6+ +Q7h7# +Q7h7+ +Q7h8# +Q7h8+ +Q7xa1 +Q7xa2 +Q7xa3 +Q7xa4 +Q7xa5 +Q7xa6 +Q7xa7 +Q7xa8 +Q7xb1 +Q7xb2 +Q7xb3 +Q7xb4 +Q7xb5 +Q7xb6 +Q7xb7 +Q7xb8 +Q7xc2 +Q7xc3 +Q7xc4 +Q7xc5 +Q7xc6 +Q7xc7 +Q7xc8 +Q7xd2 +Q7xd3 +Q7xd4 +Q7xd5 +Q7xd6 +Q7xd7 +Q7xd8 +Q7xe2 +Q7xe3 +Q7xe4 +Q7xe5 +Q7xe6 +Q7xe7 +Q7xe8 +Q7xf2 +Q7xf3 +Q7xf4 +Q7xf5 +Q7xf6 +Q7xf7 +Q7xf8 +Q7xg1 +Q7xg2 +Q7xg3 +Q7xg4 +Q7xg5 +Q7xg6 +Q7xg7 +Q7xg8 +Q7xh1 +Q7xh2 +Q7xh3 +Q7xh4 +Q7xh5 +Q7xh6 +Q7xh7 +Q7xh8 +Q8a1# +Q8a1+ +Q8a2# +Q8a2+ +Q8a3# +Q8a3+ +Q8a4# +Q8a4+ +Q8a5# +Q8a5+ +Q8a6# +Q8a6+ +Q8a7# +Q8a7+ +Q8a8# +Q8a8+ +Q8b2# +Q8b2+ +Q8b3# +Q8b3+ +Q8b4# +Q8b4+ +Q8b5# +Q8b5+ +Q8b6# +Q8b6+ +Q8b7# +Q8b7+ +Q8b8# +Q8b8+ +Q8c2# +Q8c2+ +Q8c3# +Q8c3+ +Q8c4# +Q8c4+ +Q8c5# +Q8c5+ +Q8c6# +Q8c6+ +Q8c7# +Q8c7+ +Q8c8# +Q8c8+ +Q8d2# +Q8d2+ +Q8d3# +Q8d3+ +Q8d4# +Q8d4+ +Q8d5# +Q8d5+ +Q8d6# +Q8d6+ +Q8d7# +Q8d7+ +Q8d8# +Q8d8+ +Q8e2# +Q8e2+ +Q8e3# +Q8e3+ +Q8e4# +Q8e4+ +Q8e5# +Q8e5+ +Q8e6# +Q8e6+ +Q8e7# +Q8e7+ +Q8e8# +Q8e8+ +Q8f2# +Q8f2+ +Q8f3# +Q8f3+ +Q8f4# +Q8f4+ +Q8f5# +Q8f5+ +Q8f6# +Q8f6+ +Q8f7# +Q8f7+ +Q8f8# +Q8f8+ +Q8g2# +Q8g2+ +Q8g3# +Q8g3+ +Q8g4# +Q8g4+ +Q8g5# +Q8g5+ +Q8g6# +Q8g6+ +Q8g7# +Q8g7+ +Q8g8# +Q8g8+ +Q8h1# +Q8h1+ +Q8h2# +Q8h2+ +Q8h3# +Q8h3+ +Q8h4# +Q8h4+ +Q8h5# +Q8h5+ +Q8h6# +Q8h6+ +Q8h7# +Q8h7+ +Q8h8# +Q8h8+ +Q8xa1 +Q8xa2 +Q8xa3 +Q8xa4 +Q8xa5 +Q8xa6 +Q8xa7 +Q8xa8 +Q8xb2 +Q8xb3 +Q8xb4 +Q8xb5 +Q8xb6 +Q8xb7 +Q8xb8 +Q8xc2 +Q8xc3 +Q8xc4 +Q8xc5 +Q8xc6 +Q8xc7 +Q8xc8 +Q8xd2 +Q8xd3 +Q8xd4 +Q8xd5 +Q8xd6 +Q8xd7 +Q8xd8 +Q8xe2 +Q8xe3 +Q8xe4 +Q8xe5 +Q8xe6 +Q8xe7 +Q8xe8 +Q8xf2 +Q8xf3 +Q8xf4 +Q8xf5 +Q8xf6 +Q8xf7 +Q8xf8 +Q8xg2 +Q8xg3 +Q8xg4 +Q8xg5 +Q8xg6 +Q8xg7 +Q8xg8 +Q8xh1 +Q8xh2 +Q8xh3 +Q8xh4 +Q8xh5 +Q8xh6 +Q8xh7 +Q8xh8 +Qa1a2 +Qa1a3 +Qa1a4 +Qa1a5 +Qa1a6 +Qa1a7 +Qa1b1 +Qa1b2 +Qa1c1 +Qa1c3 +Qa1d1 +Qa1d4 +Qa1e1 +Qa1e5 +Qa1f1 +Qa1f6 +Qa1g1 +Qa1g7 +Qa1h8 +Qa2a3 +Qa2a4 +Qa2a5 +Qa2a6 +Qa2a7 +Qa2b1 +Qa2b2 +Qa2b3 +Qa2c2 +Qa2c4 +Qa2d2 +Qa2d5 +Qa2e2 +Qa2e6 +Qa2f2 +Qa2f7 +Qa2g2 +Qa2g8 +Qa3a2 +Qa3a4 +Qa3a5 +Qa3a6 +Qa3a7 +Qa3b2 +Qa3b3 +Qa3b4 +Qa3c1 +Qa3c3 +Qa3c5 +Qa3d3 +Qa3d6 +Qa3e3 +Qa3e7 +Qa3f3 +Qa3f8 +Qa4a2 +Qa4a3 +Qa4a5 +Qa4a6 +Qa4a7 +Qa4b3 +Qa4b4 +Qa4b5 +Qa4c2 +Qa4c4 +Qa4c6 +Qa4d1 +Qa4d4 +Qa4d7 +Qa4e4 +Qa4e8 +Qa5a2 +Qa5a3 +Qa5a4 +Qa5a6 +Qa5a7 +Qa5b4 +Qa5b5 +Qa5b6 +Qa5c3 +Qa5c5 +Qa5c7 +Qa5d2 +Qa5d5 +Qa5d8 +Qa5e1 +Qa5e5 +Qa6a2 +Qa6a3 +Qa6a4 +Qa6a5 +Qa6a7 +Qa6b5 +Qa6b6 +Qa6b7 +Qa6c4 +Qa6c6 +Qa6c8 +Qa6d3 +Qa6d6 +Qa6e2 +Qa6e6 +Qa6f1 +Qa6f6 +Qa7a2 +Qa7a3 +Qa7a4 +Qa7a5 +Qa7a6 +Qa7b6 +Qa7b7 +Qa7b8 +Qa7c5 +Qa7c7 +Qa7d4 +Qa7d7 +Qa7e3 +Qa7e7 +Qa7f2 +Qa7f7 +Qa7g1 +Qa7g7 +Qa8a2 +Qa8a3 +Qa8a4 +Qa8a5 +Qa8a6 +Qa8a7 +Qa8b7 +Qa8b8 +Qa8c6 +Qa8c8 +Qa8d5 +Qa8d8 +Qa8e4 +Qa8e8 +Qa8f3 +Qa8f8 +Qa8g2 +Qa8g8 +Qa8h1 +Qaa1# +Qaa1+ +Qaa2# +Qaa2+ +Qaa3# +Qaa3+ +Qaa4# +Qaa4+ +Qaa5# +Qaa5+ +Qaa6# +Qaa6+ +Qaa7# +Qaa7+ +Qaa8# +Qaa8+ +Qab1# +Qab1+ +Qab2# +Qab2+ +Qab3# +Qab3+ +Qab4# +Qab4+ +Qab5# +Qab5+ +Qab6# +Qab6+ +Qab7# +Qab7+ +Qab8# +Qab8+ +Qac1# +Qac1+ +Qac2# +Qac2+ +Qac3# +Qac3+ +Qac4# +Qac4+ +Qac5# +Qac5+ +Qac6# +Qac6+ +Qac7# +Qac7+ +Qac8# +Qac8+ +Qad1# +Qad1+ +Qad2# +Qad2+ +Qad3# +Qad3+ +Qad4# +Qad4+ +Qad5# +Qad5+ +Qad6# +Qad6+ +Qad7# +Qad7+ +Qad8# +Qad8+ +Qae1# +Qae1+ +Qae2# +Qae2+ +Qae3# +Qae3+ +Qae4# +Qae4+ +Qae5# +Qae5+ +Qae6# +Qae6+ +Qae7# +Qae7+ +Qae8# +Qae8+ +Qaf1# +Qaf1+ +Qaf2# +Qaf2+ +Qaf3# +Qaf3+ +Qaf4# +Qaf4+ +Qaf5# +Qaf5+ +Qaf6# +Qaf6+ +Qaf7# +Qaf7+ +Qaf8# +Qaf8+ +Qag1# +Qag1+ +Qag2# +Qag2+ +Qag3# +Qag3+ +Qag4# +Qag4+ +Qag5# +Qag5+ +Qag6# +Qag6+ +Qag7# +Qag7+ +Qag8# +Qag8+ +Qah1# +Qah1+ +Qah2# +Qah2+ +Qah3# +Qah3+ +Qah4# +Qah4+ +Qah5# +Qah5+ +Qah6# +Qah6+ +Qah7# +Qah7+ +Qah8# +Qah8+ +Qaxa1 +Qaxa2 +Qaxa3 +Qaxa4 +Qaxa5 +Qaxa6 +Qaxa7 +Qaxa8 +Qaxb1 +Qaxb2 +Qaxb3 +Qaxb4 +Qaxb5 +Qaxb6 +Qaxb7 +Qaxb8 +Qaxc1 +Qaxc2 +Qaxc3 +Qaxc4 +Qaxc5 +Qaxc6 +Qaxc7 +Qaxc8 +Qaxd1 +Qaxd2 +Qaxd3 +Qaxd4 +Qaxd5 +Qaxd6 +Qaxd7 +Qaxd8 +Qaxe1 +Qaxe2 +Qaxe3 +Qaxe4 +Qaxe5 +Qaxe6 +Qaxe7 +Qaxe8 +Qaxf1 +Qaxf2 +Qaxf3 +Qaxf4 +Qaxf5 +Qaxf6 +Qaxf7 +Qaxf8 +Qaxg1 +Qaxg2 +Qaxg3 +Qaxg4 +Qaxg5 +Qaxg6 +Qaxg7 +Qaxg8 +Qaxh1 +Qaxh2 +Qaxh3 +Qaxh4 +Qaxh5 +Qaxh6 +Qaxh7 +Qaxh8 +Qb1a2 +Qb1b2 +Qb1b3 +Qb1b4 +Qb1b5 +Qb1b6 +Qb1b7 +Qb1c1 +Qb1c2 +Qb1d1 +Qb1d3 +Qb1e1 +Qb1e4 +Qb1f1 +Qb1f5 +Qb1g1 +Qb1g6 +Qb1h7 +Qb2a1 +Qb2a3 +Qb2b3 +Qb2b4 +Qb2b5 +Qb2b6 +Qb2b7 +Qb2c1 +Qb2c2 +Qb2c3 +Qb2d2 +Qb2d4 +Qb2e2 +Qb2e5 +Qb2f2 +Qb2f6 +Qb2g2 +Qb2g7 +Qb2h8 +Qb3a2 +Qb3a4 +Qb3b2 +Qb3b4 +Qb3b5 +Qb3b6 +Qb3b7 +Qb3c2 +Qb3c3 +Qb3c4 +Qb3d1 +Qb3d3 +Qb3d5 +Qb3e3 +Qb3e6 +Qb3f3 +Qb3f7 +Qb3g3 +Qb3g8 +Qb4a3 +Qb4a5 +Qb4b2 +Qb4b3 +Qb4b5 +Qb4b6 +Qb4b7 +Qb4c3 +Qb4c4 +Qb4c5 +Qb4d2 +Qb4d4 +Qb4d6 +Qb4e1 +Qb4e4 +Qb4e7 +Qb4f4 +Qb4f8 +Qb5a4 +Qb5a6 +Qb5b2 +Qb5b3 +Qb5b4 +Qb5b6 +Qb5b7 +Qb5c4 +Qb5c5 +Qb5c6 +Qb5d3 +Qb5d5 +Qb5d7 +Qb5e2 +Qb5e5 +Qb5e8 +Qb5f1 +Qb5f5 +Qb6a5 +Qb6a7 +Qb6b2 +Qb6b3 +Qb6b4 +Qb6b5 +Qb6b7 +Qb6c5 +Qb6c6 +Qb6c7 +Qb6d4 +Qb6d6 +Qb6d8 +Qb6e3 +Qb6e6 +Qb6f2 +Qb6f6 +Qb6g1 +Qb6g6 +Qb7a6 +Qb7a8 +Qb7b2 +Qb7b3 +Qb7b4 +Qb7b5 +Qb7b6 +Qb7c6 +Qb7c7 +Qb7c8 +Qb7d5 +Qb7d7 +Qb7e4 +Qb7e7 +Qb7f3 +Qb7f7 +Qb7g2 +Qb7g7 +Qb7h1 +Qb8a7 +Qb8b2 +Qb8b3 +Qb8b4 +Qb8b5 +Qb8b6 +Qb8b7 +Qb8c7 +Qb8c8 +Qb8d6 +Qb8d8 +Qb8e5 +Qb8e8 +Qb8f4 +Qb8f8 +Qb8g3 +Qb8g8 +Qb8h2 +Qba1# +Qba1+ +Qba2# +Qba2+ +Qba3# +Qba3+ +Qba4# +Qba4+ +Qba5# +Qba5+ +Qba6# +Qba6+ +Qba7# +Qba7+ +Qba8# +Qba8+ +Qbb1# +Qbb1+ +Qbb2# +Qbb2+ +Qbb3# +Qbb3+ +Qbb4# +Qbb4+ +Qbb5# +Qbb5+ +Qbb6# +Qbb6+ +Qbb7# +Qbb7+ +Qbb8# +Qbb8+ +Qbc1# +Qbc1+ +Qbc2# +Qbc2+ +Qbc3# +Qbc3+ +Qbc4# +Qbc4+ +Qbc5# +Qbc5+ +Qbc6# +Qbc6+ +Qbc7# +Qbc7+ +Qbc8# +Qbc8+ +Qbd1# +Qbd1+ +Qbd2# +Qbd2+ +Qbd3# +Qbd3+ +Qbd4# +Qbd4+ +Qbd5# +Qbd5+ +Qbd6# +Qbd6+ +Qbd7# +Qbd7+ +Qbd8# +Qbd8+ +Qbe1# +Qbe1+ +Qbe2# +Qbe2+ +Qbe3# +Qbe3+ +Qbe4# +Qbe4+ +Qbe5# +Qbe5+ +Qbe6# +Qbe6+ +Qbe7# +Qbe7+ +Qbe8# +Qbe8+ +Qbf1# +Qbf1+ +Qbf2# +Qbf2+ +Qbf3# +Qbf3+ +Qbf4# +Qbf4+ +Qbf5# +Qbf5+ +Qbf6# +Qbf6+ +Qbf7# +Qbf7+ +Qbf8# +Qbf8+ +Qbg1# +Qbg1+ +Qbg2# +Qbg2+ +Qbg3# +Qbg3+ +Qbg4# +Qbg4+ +Qbg5# +Qbg5+ +Qbg6# +Qbg6+ +Qbg7# +Qbg7+ +Qbg8# +Qbg8+ +Qbh1# +Qbh1+ +Qbh2# +Qbh2+ +Qbh3# +Qbh3+ +Qbh4# +Qbh4+ +Qbh5# +Qbh5+ +Qbh6# +Qbh6+ +Qbh7# +Qbh7+ +Qbh8# +Qbh8+ +Qbxa1 +Qbxa2 +Qbxa3 +Qbxa4 +Qbxa5 +Qbxa6 +Qbxa7 +Qbxa8 +Qbxb1 +Qbxb2 +Qbxb3 +Qbxb4 +Qbxb5 +Qbxb6 +Qbxb7 +Qbxb8 +Qbxc1 +Qbxc2 +Qbxc3 +Qbxc4 +Qbxc5 +Qbxc6 +Qbxc7 +Qbxc8 +Qbxd1 +Qbxd2 +Qbxd3 +Qbxd4 +Qbxd5 +Qbxd6 +Qbxd7 +Qbxd8 +Qbxe1 +Qbxe2 +Qbxe3 +Qbxe4 +Qbxe5 +Qbxe6 +Qbxe7 +Qbxe8 +Qbxf1 +Qbxf2 +Qbxf3 +Qbxf4 +Qbxf5 +Qbxf6 +Qbxf7 +Qbxf8 +Qbxg1 +Qbxg2 +Qbxg3 +Qbxg4 +Qbxg5 +Qbxg6 +Qbxg7 +Qbxg8 +Qbxh1 +Qbxh2 +Qbxh3 +Qbxh4 +Qbxh5 +Qbxh6 +Qbxh7 +Qbxh8 +Qc1a3 +Qc1b1 +Qc1b2 +Qc1c2 +Qc1c3 +Qc1c4 +Qc1c5 +Qc1c6 +Qc1d1 +Qc1d2 +Qc1e1 +Qc1e3 +Qc1f1 +Qc1f4 +Qc1g1 +Qc1g5 +Qc1h6 +Qc2a4 +Qc2b1 +Qc2b2 +Qc2b3 +Qc2c3 +Qc2c4 +Qc2c5 +Qc2c6 +Qc2c7 +Qc2d1 +Qc2d2 +Qc2d3 +Qc2e2 +Qc2e4 +Qc2f2 +Qc2f5 +Qc2g2 +Qc2g6 +Qc2h7 +Qc3a1 +Qc3a5 +Qc3b2 +Qc3b3 +Qc3b4 +Qc3c2 +Qc3c4 +Qc3c5 +Qc3c6 +Qc3c7 +Qc3d2 +Qc3d3 +Qc3d4 +Qc3e1 +Qc3e3 +Qc3e5 +Qc3f3 +Qc3f6 +Qc3g3 +Qc3g7 +Qc3h8 +Qc4a2 +Qc4a6 +Qc4b3 +Qc4b4 +Qc4b5 +Qc4c2 +Qc4c3 +Qc4c5 +Qc4c6 +Qc4c7 +Qc4d3 +Qc4d4 +Qc4d5 +Qc4e2 +Qc4e4 +Qc4e6 +Qc4f1 +Qc4f4 +Qc4f7 +Qc4g4 +Qc4g8 +Qc5a3 +Qc5a7 +Qc5b4 +Qc5b5 +Qc5b6 +Qc5c2 +Qc5c3 +Qc5c4 +Qc5c6 +Qc5c7 +Qc5d4 +Qc5d5 +Qc5d6 +Qc5e3 +Qc5e5 +Qc5e7 +Qc5f2 +Qc5f5 +Qc5f8 +Qc5g1 +Qc5g5 +Qc6a4 +Qc6a8 +Qc6b5 +Qc6b6 +Qc6b7 +Qc6c2 +Qc6c3 +Qc6c4 +Qc6c5 +Qc6c7 +Qc6d5 +Qc6d6 +Qc6d7 +Qc6e4 +Qc6e6 +Qc6e8 +Qc6f3 +Qc6f6 +Qc6g2 +Qc6g6 +Qc6h1 +Qc7a5 +Qc7b6 +Qc7b7 +Qc7b8 +Qc7c2 +Qc7c3 +Qc7c4 +Qc7c5 +Qc7c6 +Qc7d6 +Qc7d7 +Qc7d8 +Qc7e5 +Qc7e7 +Qc7f4 +Qc7f7 +Qc7g3 +Qc7g7 +Qc7h2 +Qc8a6 +Qc8b7 +Qc8b8 +Qc8c3 +Qc8c4 +Qc8c5 +Qc8c6 +Qc8c7 +Qc8d7 +Qc8d8 +Qc8e6 +Qc8e8 +Qc8f5 +Qc8f8 +Qc8g4 +Qc8g8 +Qc8h3 +Qca1# +Qca1+ +Qca2# +Qca2+ +Qca3# +Qca3+ +Qca4# +Qca4+ +Qca5# +Qca5+ +Qca6# +Qca6+ +Qca7# +Qca7+ +Qca8# +Qca8+ +Qcb1# +Qcb1+ +Qcb2# +Qcb2+ +Qcb3# +Qcb3+ +Qcb4# +Qcb4+ +Qcb5# +Qcb5+ +Qcb6# +Qcb6+ +Qcb7# +Qcb7+ +Qcb8# +Qcb8+ +Qcc1# +Qcc1+ +Qcc2# +Qcc2+ +Qcc3# +Qcc3+ +Qcc4# +Qcc4+ +Qcc5# +Qcc5+ +Qcc6# +Qcc6+ +Qcc7# +Qcc7+ +Qcc8# +Qcc8+ +Qcd1# +Qcd1+ +Qcd2# +Qcd2+ +Qcd3# +Qcd3+ +Qcd4# +Qcd4+ +Qcd5# +Qcd5+ +Qcd6# +Qcd6+ +Qcd7# +Qcd7+ +Qcd8# +Qcd8+ +Qce1# +Qce1+ +Qce2# +Qce2+ +Qce3# +Qce3+ +Qce4# +Qce4+ +Qce5# +Qce5+ +Qce6# +Qce6+ +Qce7# +Qce7+ +Qce8# +Qce8+ +Qcf1# +Qcf1+ +Qcf2# +Qcf2+ +Qcf3# +Qcf3+ +Qcf4# +Qcf4+ +Qcf5# +Qcf5+ +Qcf6# +Qcf6+ +Qcf7# +Qcf7+ +Qcf8# +Qcf8+ +Qcg1# +Qcg1+ +Qcg2# +Qcg2+ +Qcg3# +Qcg3+ +Qcg4# +Qcg4+ +Qcg5# +Qcg5+ +Qcg6# +Qcg6+ +Qcg7# +Qcg7+ +Qcg8# +Qcg8+ +Qch1# +Qch1+ +Qch2# +Qch2+ +Qch3# +Qch3+ +Qch4# +Qch4+ +Qch5# +Qch5+ +Qch6# +Qch6+ +Qch7# +Qch7+ +Qch8# +Qch8+ +Qcxa1 +Qcxa2 +Qcxa3 +Qcxa4 +Qcxa5 +Qcxa6 +Qcxa7 +Qcxa8 +Qcxb1 +Qcxb2 +Qcxb3 +Qcxb4 +Qcxb5 +Qcxb6 +Qcxb7 +Qcxb8 +Qcxc1 +Qcxc2 +Qcxc3 +Qcxc4 +Qcxc5 +Qcxc6 +Qcxc7 +Qcxc8 +Qcxd1 +Qcxd2 +Qcxd3 +Qcxd4 +Qcxd5 +Qcxd6 +Qcxd7 +Qcxd8 +Qcxe1 +Qcxe2 +Qcxe3 +Qcxe4 +Qcxe5 +Qcxe6 +Qcxe7 +Qcxe8 +Qcxf1 +Qcxf2 +Qcxf3 +Qcxf4 +Qcxf5 +Qcxf6 +Qcxf7 +Qcxf8 +Qcxg1 +Qcxg2 +Qcxg3 +Qcxg4 +Qcxg5 +Qcxg6 +Qcxg7 +Qcxg8 +Qcxh1 +Qcxh2 +Qcxh3 +Qcxh4 +Qcxh5 +Qcxh6 +Qcxh7 +Qcxh8 +Qd1a4 +Qd1b1 +Qd1b3 +Qd1c1 +Qd1c2 +Qd1d2 +Qd1d3 +Qd1d4 +Qd1d5 +Qd1e1 +Qd1e2 +Qd1f1 +Qd1f3 +Qd1g1 +Qd1g4 +Qd1h5 +Qd2a5 +Qd2b2 +Qd2b4 +Qd2c1 +Qd2c2 +Qd2c3 +Qd2d3 +Qd2d4 +Qd2d5 +Qd2d6 +Qd2e1 +Qd2e2 +Qd2e3 +Qd2f2 +Qd2f4 +Qd2g2 +Qd2g5 +Qd2h6 +Qd3a6 +Qd3b1 +Qd3b3 +Qd3b5 +Qd3c2 +Qd3c3 +Qd3c4 +Qd3d2 +Qd3d4 +Qd3d5 +Qd3d6 +Qd3d7 +Qd3e2 +Qd3e3 +Qd3e4 +Qd3f1 +Qd3f3 +Qd3f5 +Qd3g3 +Qd3g6 +Qd3h7 +Qd4a1 +Qd4a7 +Qd4b2 +Qd4b4 +Qd4b6 +Qd4c3 +Qd4c4 +Qd4c5 +Qd4d2 +Qd4d3 +Qd4d5 +Qd4d6 +Qd4d7 +Qd4e3 +Qd4e4 +Qd4e5 +Qd4f2 +Qd4f4 +Qd4f6 +Qd4g1 +Qd4g4 +Qd4g7 +Qd4h8 +Qd5a2 +Qd5a8 +Qd5b3 +Qd5b5 +Qd5b7 +Qd5c4 +Qd5c5 +Qd5c6 +Qd5d2 +Qd5d3 +Qd5d4 +Qd5d6 +Qd5d7 +Qd5e4 +Qd5e5 +Qd5e6 +Qd5f3 +Qd5f5 +Qd5f7 +Qd5g2 +Qd5g5 +Qd5g8 +Qd5h1 +Qd6a3 +Qd6b4 +Qd6b6 +Qd6b8 +Qd6c5 +Qd6c6 +Qd6c7 +Qd6d2 +Qd6d3 +Qd6d4 +Qd6d5 +Qd6d7 +Qd6e5 +Qd6e6 +Qd6e7 +Qd6f4 +Qd6f6 +Qd6f8 +Qd6g3 +Qd6g6 +Qd6h2 +Qd7a4 +Qd7b5 +Qd7b7 +Qd7c6 +Qd7c7 +Qd7c8 +Qd7d3 +Qd7d4 +Qd7d5 +Qd7d6 +Qd7e6 +Qd7e7 +Qd7e8 +Qd7f5 +Qd7f7 +Qd7g4 +Qd7g7 +Qd7h3 +Qd8a5 +Qd8b6 +Qd8b8 +Qd8c7 +Qd8c8 +Qd8d4 +Qd8d5 +Qd8d6 +Qd8d7 +Qd8e7 +Qd8e8 +Qd8f6 +Qd8f8 +Qd8g5 +Qd8g8 +Qd8h4 +Qda1# +Qda1+ +Qda2# +Qda2+ +Qda3# +Qda3+ +Qda4# +Qda4+ +Qda5# +Qda5+ +Qda6# +Qda6+ +Qda7# +Qda7+ +Qda8# +Qda8+ +Qdb1# +Qdb1+ +Qdb2# +Qdb2+ +Qdb3# +Qdb3+ +Qdb4# +Qdb4+ +Qdb5# +Qdb5+ +Qdb6# +Qdb6+ +Qdb7# +Qdb7+ +Qdb8# +Qdb8+ +Qdc1# +Qdc1+ +Qdc2# +Qdc2+ +Qdc3# +Qdc3+ +Qdc4# +Qdc4+ +Qdc5# +Qdc5+ +Qdc6# +Qdc6+ +Qdc7# +Qdc7+ +Qdc8# +Qdc8+ +Qdd1# +Qdd1+ +Qdd2# +Qdd2+ +Qdd3# +Qdd3+ +Qdd4# +Qdd4+ +Qdd5# +Qdd5+ +Qdd6# +Qdd6+ +Qdd7# +Qdd7+ +Qdd8# +Qdd8+ +Qde1# +Qde1+ +Qde2# +Qde2+ +Qde3# +Qde3+ +Qde4# +Qde4+ +Qde5# +Qde5+ +Qde6# +Qde6+ +Qde7# +Qde7+ +Qde8# +Qde8+ +Qdf1# +Qdf1+ +Qdf2# +Qdf2+ +Qdf3# +Qdf3+ +Qdf4# +Qdf4+ +Qdf5# +Qdf5+ +Qdf6# +Qdf6+ +Qdf7# +Qdf7+ +Qdf8# +Qdf8+ +Qdg1# +Qdg1+ +Qdg2# +Qdg2+ +Qdg3# +Qdg3+ +Qdg4# +Qdg4+ +Qdg5# +Qdg5+ +Qdg6# +Qdg6+ +Qdg7# +Qdg7+ +Qdg8# +Qdg8+ +Qdh1# +Qdh1+ +Qdh2# +Qdh2+ +Qdh3# +Qdh3+ +Qdh4# +Qdh4+ +Qdh5# +Qdh5+ +Qdh6# +Qdh6+ +Qdh7# +Qdh7+ +Qdh8# +Qdh8+ +Qdxa1 +Qdxa2 +Qdxa3 +Qdxa4 +Qdxa5 +Qdxa6 +Qdxa7 +Qdxa8 +Qdxb1 +Qdxb2 +Qdxb3 +Qdxb4 +Qdxb5 +Qdxb6 +Qdxb7 +Qdxb8 +Qdxc1 +Qdxc2 +Qdxc3 +Qdxc4 +Qdxc5 +Qdxc6 +Qdxc7 +Qdxc8 +Qdxd1 +Qdxd2 +Qdxd3 +Qdxd4 +Qdxd5 +Qdxd6 +Qdxd7 +Qdxd8 +Qdxe1 +Qdxe2 +Qdxe3 +Qdxe4 +Qdxe5 +Qdxe6 +Qdxe7 +Qdxe8 +Qdxf1 +Qdxf2 +Qdxf3 +Qdxf4 +Qdxf5 +Qdxf6 +Qdxf7 +Qdxf8 +Qdxg1 +Qdxg2 +Qdxg3 +Qdxg4 +Qdxg5 +Qdxg6 +Qdxg7 +Qdxg8 +Qdxh1 +Qdxh2 +Qdxh3 +Qdxh4 +Qdxh5 +Qdxh6 +Qdxh7 +Qdxh8 +Qe1a5 +Qe1b1 +Qe1b4 +Qe1c1 +Qe1c3 +Qe1d1 +Qe1d2 +Qe1e2 +Qe1e3 +Qe1e4 +Qe1e5 +Qe1f1 +Qe1f2 +Qe1g1 +Qe1g3 +Qe1h4 +Qe2a6 +Qe2b2 +Qe2b5 +Qe2c2 +Qe2c4 +Qe2d1 +Qe2d2 +Qe2d3 +Qe2e3 +Qe2e4 +Qe2e5 +Qe2e6 +Qe2f1 +Qe2f2 +Qe2f3 +Qe2g2 +Qe2g4 +Qe2h5 +Qe3a7 +Qe3b3 +Qe3b6 +Qe3c1 +Qe3c3 +Qe3c5 +Qe3d2 +Qe3d3 +Qe3d4 +Qe3e2 +Qe3e4 +Qe3e5 +Qe3e6 +Qe3e7 +Qe3f2 +Qe3f3 +Qe3f4 +Qe3g1 +Qe3g3 +Qe3g5 +Qe3h6 +Qe4a8 +Qe4b1 +Qe4b4 +Qe4b7 +Qe4c2 +Qe4c4 +Qe4c6 +Qe4d3 +Qe4d4 +Qe4d5 +Qe4e2 +Qe4e3 +Qe4e5 +Qe4e6 +Qe4e7 +Qe4f3 +Qe4f4 +Qe4f5 +Qe4g2 +Qe4g4 +Qe4g6 +Qe4h1 +Qe4h7 +Qe5a1 +Qe5b2 +Qe5b5 +Qe5b8 +Qe5c3 +Qe5c5 +Qe5c7 +Qe5d4 +Qe5d5 +Qe5d6 +Qe5e2 +Qe5e3 +Qe5e4 +Qe5e6 +Qe5e7 +Qe5f4 +Qe5f5 +Qe5f6 +Qe5g3 +Qe5g5 +Qe5g7 +Qe5h2 +Qe5h8 +Qe6a2 +Qe6b3 +Qe6b6 +Qe6c4 +Qe6c6 +Qe6c8 +Qe6d5 +Qe6d6 +Qe6d7 +Qe6e2 +Qe6e3 +Qe6e4 +Qe6e5 +Qe6e7 +Qe6f5 +Qe6f6 +Qe6f7 +Qe6g4 +Qe6g6 +Qe6g8 +Qe6h3 +Qe7a3 +Qe7b4 +Qe7b7 +Qe7c5 +Qe7c7 +Qe7d6 +Qe7d7 +Qe7d8 +Qe7e3 +Qe7e4 +Qe7e5 +Qe7e6 +Qe7f6 +Qe7f7 +Qe7f8 +Qe7g5 +Qe7g7 +Qe7h4 +Qe8a4 +Qe8b5 +Qe8b8 +Qe8c6 +Qe8c8 +Qe8d7 +Qe8d8 +Qe8e4 +Qe8e5 +Qe8e6 +Qe8e7 +Qe8f7 +Qe8f8 +Qe8g6 +Qe8g8 +Qe8h5 +Qea1# +Qea1+ +Qea2# +Qea2+ +Qea3# +Qea3+ +Qea4# +Qea4+ +Qea5# +Qea5+ +Qea6# +Qea6+ +Qea7# +Qea7+ +Qea8# +Qea8+ +Qeb1# +Qeb1+ +Qeb2# +Qeb2+ +Qeb3# +Qeb3+ +Qeb4# +Qeb4+ +Qeb5# +Qeb5+ +Qeb6# +Qeb6+ +Qeb7# +Qeb7+ +Qeb8# +Qeb8+ +Qec1# +Qec1+ +Qec2# +Qec2+ +Qec3# +Qec3+ +Qec4# +Qec4+ +Qec5# +Qec5+ +Qec6# +Qec6+ +Qec7# +Qec7+ +Qec8# +Qec8+ +Qed1# +Qed1+ +Qed2# +Qed2+ +Qed3# +Qed3+ +Qed4# +Qed4+ +Qed5# +Qed5+ +Qed6# +Qed6+ +Qed7# +Qed7+ +Qed8# +Qed8+ +Qee1# +Qee1+ +Qee2# +Qee2+ +Qee3# +Qee3+ +Qee4# +Qee4+ +Qee5# +Qee5+ +Qee6# +Qee6+ +Qee7# +Qee7+ +Qee8# +Qee8+ +Qef1# +Qef1+ +Qef2# +Qef2+ +Qef3# +Qef3+ +Qef4# +Qef4+ +Qef5# +Qef5+ +Qef6# +Qef6+ +Qef7# +Qef7+ +Qef8# +Qef8+ +Qeg1# +Qeg1+ +Qeg2# +Qeg2+ +Qeg3# +Qeg3+ +Qeg4# +Qeg4+ +Qeg5# +Qeg5+ +Qeg6# +Qeg6+ +Qeg7# +Qeg7+ +Qeg8# +Qeg8+ +Qeh1# +Qeh1+ +Qeh2# +Qeh2+ +Qeh3# +Qeh3+ +Qeh4# +Qeh4+ +Qeh5# +Qeh5+ +Qeh6# +Qeh6+ +Qeh7# +Qeh7+ +Qeh8# +Qeh8+ +Qexa1 +Qexa2 +Qexa3 +Qexa4 +Qexa5 +Qexa6 +Qexa7 +Qexa8 +Qexb1 +Qexb2 +Qexb3 +Qexb4 +Qexb5 +Qexb6 +Qexb7 +Qexb8 +Qexc1 +Qexc2 +Qexc3 +Qexc4 +Qexc5 +Qexc6 +Qexc7 +Qexc8 +Qexd1 +Qexd2 +Qexd3 +Qexd4 +Qexd5 +Qexd6 +Qexd7 +Qexd8 +Qexe1 +Qexe2 +Qexe3 +Qexe4 +Qexe5 +Qexe6 +Qexe7 +Qexe8 +Qexf1 +Qexf2 +Qexf3 +Qexf4 +Qexf5 +Qexf6 +Qexf7 +Qexf8 +Qexg1 +Qexg2 +Qexg3 +Qexg4 +Qexg5 +Qexg6 +Qexg7 +Qexg8 +Qexh1 +Qexh2 +Qexh3 +Qexh4 +Qexh5 +Qexh6 +Qexh7 +Qexh8 +Qf1a6 +Qf1b1 +Qf1b5 +Qf1c1 +Qf1c4 +Qf1d1 +Qf1d3 +Qf1e1 +Qf1e2 +Qf1f2 +Qf1f3 +Qf1f4 +Qf1f5 +Qf1f6 +Qf1g1 +Qf1g2 +Qf1h3 +Qf2a7 +Qf2b2 +Qf2b6 +Qf2c2 +Qf2c5 +Qf2d2 +Qf2d4 +Qf2e1 +Qf2e2 +Qf2e3 +Qf2f3 +Qf2f4 +Qf2f5 +Qf2f6 +Qf2f7 +Qf2g1 +Qf2g2 +Qf2g3 +Qf2h4 +Qf3a8 +Qf3b3 +Qf3b7 +Qf3c3 +Qf3c6 +Qf3d1 +Qf3d3 +Qf3d5 +Qf3e2 +Qf3e3 +Qf3e4 +Qf3f2 +Qf3f4 +Qf3f5 +Qf3f6 +Qf3f7 +Qf3g2 +Qf3g3 +Qf3g4 +Qf3h1 +Qf3h5 +Qf4b4 +Qf4b8 +Qf4c1 +Qf4c4 +Qf4c7 +Qf4d2 +Qf4d4 +Qf4d6 +Qf4e3 +Qf4e4 +Qf4e5 +Qf4f2 +Qf4f3 +Qf4f5 +Qf4f6 +Qf4f7 +Qf4g3 +Qf4g4 +Qf4g5 +Qf4h2 +Qf4h6 +Qf5b1 +Qf5b5 +Qf5c2 +Qf5c5 +Qf5c8 +Qf5d3 +Qf5d5 +Qf5d7 +Qf5e4 +Qf5e5 +Qf5e6 +Qf5f2 +Qf5f3 +Qf5f4 +Qf5f6 +Qf5f7 +Qf5g4 +Qf5g5 +Qf5g6 +Qf5h3 +Qf5h7 +Qf6a1 +Qf6b2 +Qf6b6 +Qf6c3 +Qf6c6 +Qf6d4 +Qf6d6 +Qf6d8 +Qf6e5 +Qf6e6 +Qf6e7 +Qf6f2 +Qf6f3 +Qf6f4 +Qf6f5 +Qf6f7 +Qf6g5 +Qf6g6 +Qf6g7 +Qf6h4 +Qf6h8 +Qf7a2 +Qf7b3 +Qf7b7 +Qf7c4 +Qf7c7 +Qf7d5 +Qf7d7 +Qf7e6 +Qf7e7 +Qf7e8 +Qf7f2 +Qf7f3 +Qf7f4 +Qf7f5 +Qf7f6 +Qf7g6 +Qf7g7 +Qf7g8 +Qf7h5 +Qf8a3 +Qf8b4 +Qf8b8 +Qf8c5 +Qf8c8 +Qf8d6 +Qf8d8 +Qf8e7 +Qf8e8 +Qf8f3 +Qf8f4 +Qf8f5 +Qf8f6 +Qf8f7 +Qf8g7 +Qf8g8 +Qf8h6 +Qfa1# +Qfa1+ +Qfa2# +Qfa2+ +Qfa3# +Qfa3+ +Qfa4# +Qfa4+ +Qfa5# +Qfa5+ +Qfa6# +Qfa6+ +Qfa7# +Qfa7+ +Qfa8# +Qfa8+ +Qfb1# +Qfb1+ +Qfb2# +Qfb2+ +Qfb3# +Qfb3+ +Qfb4# +Qfb4+ +Qfb5# +Qfb5+ +Qfb6# +Qfb6+ +Qfb7# +Qfb7+ +Qfb8# +Qfb8+ +Qfc1# +Qfc1+ +Qfc2# +Qfc2+ +Qfc3# +Qfc3+ +Qfc4# +Qfc4+ +Qfc5# +Qfc5+ +Qfc6# +Qfc6+ +Qfc7# +Qfc7+ +Qfc8# +Qfc8+ +Qfd1# +Qfd1+ +Qfd2# +Qfd2+ +Qfd3# +Qfd3+ +Qfd4# +Qfd4+ +Qfd5# +Qfd5+ +Qfd6# +Qfd6+ +Qfd7# +Qfd7+ +Qfd8# +Qfd8+ +Qfe1# +Qfe1+ +Qfe2# +Qfe2+ +Qfe3# +Qfe3+ +Qfe4# +Qfe4+ +Qfe5# +Qfe5+ +Qfe6# +Qfe6+ +Qfe7# +Qfe7+ +Qfe8# +Qfe8+ +Qff1# +Qff1+ +Qff2# +Qff2+ +Qff3# +Qff3+ +Qff4# +Qff4+ +Qff5# +Qff5+ +Qff6# +Qff6+ +Qff7# +Qff7+ +Qff8# +Qff8+ +Qfg1# +Qfg1+ +Qfg2# +Qfg2+ +Qfg3# +Qfg3+ +Qfg4# +Qfg4+ +Qfg5# +Qfg5+ +Qfg6# +Qfg6+ +Qfg7# +Qfg7+ +Qfg8# +Qfg8+ +Qfh1# +Qfh1+ +Qfh2# +Qfh2+ +Qfh3# +Qfh3+ +Qfh4# +Qfh4+ +Qfh5# +Qfh5+ +Qfh6# +Qfh6+ +Qfh7# +Qfh7+ +Qfh8# +Qfh8+ +Qfxa1 +Qfxa2 +Qfxa3 +Qfxa4 +Qfxa5 +Qfxa6 +Qfxa7 +Qfxa8 +Qfxb1 +Qfxb2 +Qfxb3 +Qfxb4 +Qfxb5 +Qfxb6 +Qfxb7 +Qfxb8 +Qfxc1 +Qfxc2 +Qfxc3 +Qfxc4 +Qfxc5 +Qfxc6 +Qfxc7 +Qfxc8 +Qfxd1 +Qfxd2 +Qfxd3 +Qfxd4 +Qfxd5 +Qfxd6 +Qfxd7 +Qfxd8 +Qfxe1 +Qfxe2 +Qfxe3 +Qfxe4 +Qfxe5 +Qfxe6 +Qfxe7 +Qfxe8 +Qfxf1 +Qfxf2 +Qfxf3 +Qfxf4 +Qfxf5 +Qfxf6 +Qfxf7 +Qfxf8 +Qfxg1 +Qfxg2 +Qfxg3 +Qfxg4 +Qfxg5 +Qfxg6 +Qfxg7 +Qfxg8 +Qfxh1 +Qfxh2 +Qfxh3 +Qfxh4 +Qfxh5 +Qfxh6 +Qfxh7 +Qfxh8 +Qg1a7 +Qg1b1 +Qg1b6 +Qg1c1 +Qg1c5 +Qg1d1 +Qg1d4 +Qg1e1 +Qg1e3 +Qg1f1 +Qg1f2 +Qg1g2 +Qg1g3 +Qg1g4 +Qg1g5 +Qg1g6 +Qg1g7 +Qg1h2 +Qg2a8 +Qg2b2 +Qg2b7 +Qg2c2 +Qg2c6 +Qg2d2 +Qg2d5 +Qg2e2 +Qg2e4 +Qg2f1 +Qg2f2 +Qg2f3 +Qg2g3 +Qg2g4 +Qg2g5 +Qg2g6 +Qg2g7 +Qg2h1 +Qg2h3 +Qg3b3 +Qg3b8 +Qg3c3 +Qg3c7 +Qg3d3 +Qg3d6 +Qg3e1 +Qg3e3 +Qg3e5 +Qg3f2 +Qg3f3 +Qg3f4 +Qg3g2 +Qg3g4 +Qg3g5 +Qg3g6 +Qg3g7 +Qg3h2 +Qg3h4 +Qg4c4 +Qg4c8 +Qg4d1 +Qg4d4 +Qg4d7 +Qg4e2 +Qg4e4 +Qg4e6 +Qg4f3 +Qg4f4 +Qg4f5 +Qg4g2 +Qg4g3 +Qg4g5 +Qg4g6 +Qg4g7 +Qg4h3 +Qg4h5 +Qg5c1 +Qg5c5 +Qg5d2 +Qg5d5 +Qg5d8 +Qg5e3 +Qg5e5 +Qg5e7 +Qg5f4 +Qg5f5 +Qg5f6 +Qg5g2 +Qg5g3 +Qg5g4 +Qg5g6 +Qg5g7 +Qg5h4 +Qg5h6 +Qg6b1 +Qg6b6 +Qg6c2 +Qg6c6 +Qg6d3 +Qg6d6 +Qg6e4 +Qg6e6 +Qg6e8 +Qg6f5 +Qg6f6 +Qg6f7 +Qg6g2 +Qg6g3 +Qg6g4 +Qg6g5 +Qg6g7 +Qg6h5 +Qg6h7 +Qg7a1 +Qg7b2 +Qg7b7 +Qg7c3 +Qg7c7 +Qg7d4 +Qg7d7 +Qg7e5 +Qg7e7 +Qg7f6 +Qg7f7 +Qg7f8 +Qg7g2 +Qg7g3 +Qg7g4 +Qg7g5 +Qg7g6 +Qg7h6 +Qg7h8 +Qg8a2 +Qg8b3 +Qg8b8 +Qg8c4 +Qg8c8 +Qg8d5 +Qg8d8 +Qg8e6 +Qg8e8 +Qg8f7 +Qg8f8 +Qg8g2 +Qg8g3 +Qg8g4 +Qg8g5 +Qg8g6 +Qg8g7 +Qg8h7 +Qga1# +Qga1+ +Qga2# +Qga2+ +Qga3# +Qga3+ +Qga4# +Qga4+ +Qga5# +Qga5+ +Qga6# +Qga6+ +Qga7# +Qga7+ +Qga8# +Qga8+ +Qgb1# +Qgb1+ +Qgb2# +Qgb2+ +Qgb3# +Qgb3+ +Qgb4# +Qgb4+ +Qgb5# +Qgb5+ +Qgb6# +Qgb6+ +Qgb7# +Qgb7+ +Qgb8# +Qgb8+ +Qgc1# +Qgc1+ +Qgc2# +Qgc2+ +Qgc3# +Qgc3+ +Qgc4# +Qgc4+ +Qgc5# +Qgc5+ +Qgc6# +Qgc6+ +Qgc7# +Qgc7+ +Qgc8# +Qgc8+ +Qgd1# +Qgd1+ +Qgd2# +Qgd2+ +Qgd3# +Qgd3+ +Qgd4# +Qgd4+ +Qgd5# +Qgd5+ +Qgd6# +Qgd6+ +Qgd7# +Qgd7+ +Qgd8# +Qgd8+ +Qge1# +Qge1+ +Qge2# +Qge2+ +Qge3# +Qge3+ +Qge4# +Qge4+ +Qge5# +Qge5+ +Qge6# +Qge6+ +Qge7# +Qge7+ +Qge8# +Qge8+ +Qgf1# +Qgf1+ +Qgf2# +Qgf2+ +Qgf3# +Qgf3+ +Qgf4# +Qgf4+ +Qgf5# +Qgf5+ +Qgf6# +Qgf6+ +Qgf7# +Qgf7+ +Qgf8# +Qgf8+ +Qgg1# +Qgg1+ +Qgg2# +Qgg2+ +Qgg3# +Qgg3+ +Qgg4# +Qgg4+ +Qgg5# +Qgg5+ +Qgg6# +Qgg6+ +Qgg7# +Qgg7+ +Qgg8# +Qgg8+ +Qgh1# +Qgh1+ +Qgh2# +Qgh2+ +Qgh3# +Qgh3+ +Qgh4# +Qgh4+ +Qgh5# +Qgh5+ +Qgh6# +Qgh6+ +Qgh7# +Qgh7+ +Qgh8# +Qgh8+ +Qgxa1 +Qgxa2 +Qgxa3 +Qgxa4 +Qgxa5 +Qgxa6 +Qgxa7 +Qgxa8 +Qgxb1 +Qgxb2 +Qgxb3 +Qgxb4 +Qgxb5 +Qgxb6 +Qgxb7 +Qgxb8 +Qgxc1 +Qgxc2 +Qgxc3 +Qgxc4 +Qgxc5 +Qgxc6 +Qgxc7 +Qgxc8 +Qgxd1 +Qgxd2 +Qgxd3 +Qgxd4 +Qgxd5 +Qgxd6 +Qgxd7 +Qgxd8 +Qgxe1 +Qgxe2 +Qgxe3 +Qgxe4 +Qgxe5 +Qgxe6 +Qgxe7 +Qgxe8 +Qgxf1 +Qgxf2 +Qgxf3 +Qgxf4 +Qgxf5 +Qgxf6 +Qgxf7 +Qgxf8 +Qgxg1 +Qgxg2 +Qgxg3 +Qgxg4 +Qgxg5 +Qgxg6 +Qgxg7 +Qgxg8 +Qgxh1 +Qgxh2 +Qgxh3 +Qgxh4 +Qgxh5 +Qgxh6 +Qgxh7 +Qgxh8 +Qh1a8 +Qh1b1 +Qh1b7 +Qh1c1 +Qh1c6 +Qh1d1 +Qh1d5 +Qh1e1 +Qh1e4 +Qh1f1 +Qh1f3 +Qh1g1 +Qh1g2 +Qh1h2 +Qh1h3 +Qh1h4 +Qh1h5 +Qh1h6 +Qh1h7 +Qh2b2 +Qh2b8 +Qh2c2 +Qh2c7 +Qh2d2 +Qh2d6 +Qh2e2 +Qh2e5 +Qh2f2 +Qh2f4 +Qh2g1 +Qh2g2 +Qh2g3 +Qh2h3 +Qh2h4 +Qh2h5 +Qh2h6 +Qh2h7 +Qh3c3 +Qh3c8 +Qh3d3 +Qh3d7 +Qh3e3 +Qh3e6 +Qh3f1 +Qh3f3 +Qh3f5 +Qh3g2 +Qh3g3 +Qh3g4 +Qh3h2 +Qh3h4 +Qh3h5 +Qh3h6 +Qh3h7 +Qh4d4 +Qh4d8 +Qh4e1 +Qh4e4 +Qh4e7 +Qh4f2 +Qh4f4 +Qh4f6 +Qh4g3 +Qh4g4 +Qh4g5 +Qh4h2 +Qh4h3 +Qh4h5 +Qh4h6 +Qh4h7 +Qh5d1 +Qh5d5 +Qh5e2 +Qh5e5 +Qh5e8 +Qh5f3 +Qh5f5 +Qh5f7 +Qh5g4 +Qh5g5 +Qh5g6 +Qh5h2 +Qh5h3 +Qh5h4 +Qh5h6 +Qh5h7 +Qh6c1 +Qh6c6 +Qh6d2 +Qh6d6 +Qh6e3 +Qh6e6 +Qh6f4 +Qh6f6 +Qh6f8 +Qh6g5 +Qh6g6 +Qh6g7 +Qh6h2 +Qh6h3 +Qh6h4 +Qh6h5 +Qh6h7 +Qh7b1 +Qh7b7 +Qh7c2 +Qh7c7 +Qh7d3 +Qh7d7 +Qh7e4 +Qh7e7 +Qh7f5 +Qh7f7 +Qh7g6 +Qh7g7 +Qh7g8 +Qh7h2 +Qh7h3 +Qh7h4 +Qh7h5 +Qh7h6 +Qh8a1 +Qh8b2 +Qh8b8 +Qh8c3 +Qh8c8 +Qh8d4 +Qh8d8 +Qh8e5 +Qh8e8 +Qh8f6 +Qh8f8 +Qh8g7 +Qh8g8 +Qh8h2 +Qh8h3 +Qh8h4 +Qh8h5 +Qh8h6 +Qh8h7 +Qha1# +Qha1+ +Qha2# +Qha2+ +Qha3# +Qha3+ +Qha4# +Qha4+ +Qha5# +Qha5+ +Qha6# +Qha6+ +Qha7# +Qha7+ +Qha8# +Qha8+ +Qhb1# +Qhb1+ +Qhb2# +Qhb2+ +Qhb3# +Qhb3+ +Qhb4# +Qhb4+ +Qhb5# +Qhb5+ +Qhb6# +Qhb6+ +Qhb7# +Qhb7+ +Qhb8# +Qhb8+ +Qhc1# +Qhc1+ +Qhc2# +Qhc2+ +Qhc3# +Qhc3+ +Qhc4# +Qhc4+ +Qhc5# +Qhc5+ +Qhc6# +Qhc6+ +Qhc7# +Qhc7+ +Qhc8# +Qhc8+ +Qhd1# +Qhd1+ +Qhd2# +Qhd2+ +Qhd3# +Qhd3+ +Qhd4# +Qhd4+ +Qhd5# +Qhd5+ +Qhd6# +Qhd6+ +Qhd7# +Qhd7+ +Qhd8# +Qhd8+ +Qhe1# +Qhe1+ +Qhe2# +Qhe2+ +Qhe3# +Qhe3+ +Qhe4# +Qhe4+ +Qhe5# +Qhe5+ +Qhe6# +Qhe6+ +Qhe7# +Qhe7+ +Qhe8# +Qhe8+ +Qhf1# +Qhf1+ +Qhf2# +Qhf2+ +Qhf3# +Qhf3+ +Qhf4# +Qhf4+ +Qhf5# +Qhf5+ +Qhf6# +Qhf6+ +Qhf7# +Qhf7+ +Qhf8# +Qhf8+ +Qhg1# +Qhg1+ +Qhg2# +Qhg2+ +Qhg3# +Qhg3+ +Qhg4# +Qhg4+ +Qhg5# +Qhg5+ +Qhg6# +Qhg6+ +Qhg7# +Qhg7+ +Qhg8# +Qhg8+ +Qhh1# +Qhh1+ +Qhh2# +Qhh2+ +Qhh3# +Qhh3+ +Qhh4# +Qhh4+ +Qhh5# +Qhh5+ +Qhh6# +Qhh6+ +Qhh7# +Qhh7+ +Qhh8# +Qhh8+ +Qhxa1 +Qhxa2 +Qhxa3 +Qhxa4 +Qhxa5 +Qhxa6 +Qhxa7 +Qhxa8 +Qhxb1 +Qhxb2 +Qhxb3 +Qhxb4 +Qhxb5 +Qhxb6 +Qhxb7 +Qhxb8 +Qhxc1 +Qhxc2 +Qhxc3 +Qhxc4 +Qhxc5 +Qhxc6 +Qhxc7 +Qhxc8 +Qhxd1 +Qhxd2 +Qhxd3 +Qhxd4 +Qhxd5 +Qhxd6 +Qhxd7 +Qhxd8 +Qhxe1 +Qhxe2 +Qhxe3 +Qhxe4 +Qhxe5 +Qhxe6 +Qhxe7 +Qhxe8 +Qhxf1 +Qhxf2 +Qhxf3 +Qhxf4 +Qhxf5 +Qhxf6 +Qhxf7 +Qhxf8 +Qhxg1 +Qhxg2 +Qhxg3 +Qhxg4 +Qhxg5 +Qhxg6 +Qhxg7 +Qhxg8 +Qhxh1 +Qhxh2 +Qhxh3 +Qhxh4 +Qhxh5 +Qhxh6 +Qhxh7 +Qhxh8 +Qxa1# +Qxa1+ +Qxa2# +Qxa2+ +Qxa3# +Qxa3+ +Qxa4# +Qxa4+ +Qxa5# +Qxa5+ +Qxa6# +Qxa6+ +Qxa7# +Qxa7+ +Qxa8# +Qxa8+ +Qxb1# +Qxb1+ +Qxb2# +Qxb2+ +Qxb3# +Qxb3+ +Qxb4# +Qxb4+ +Qxb5# +Qxb5+ +Qxb6# +Qxb6+ +Qxb7# +Qxb7+ +Qxb8# +Qxb8+ +Qxc1# +Qxc1+ +Qxc2# +Qxc2+ +Qxc3# +Qxc3+ +Qxc4# +Qxc4+ +Qxc5# +Qxc5+ +Qxc6# +Qxc6+ +Qxc7# +Qxc7+ +Qxc8# +Qxc8+ +Qxd1# +Qxd1+ +Qxd2# +Qxd2+ +Qxd3# +Qxd3+ +Qxd4# +Qxd4+ +Qxd5# +Qxd5+ +Qxd6# +Qxd6+ +Qxd7# +Qxd7+ +Qxd8# +Qxd8+ +Qxe1# +Qxe1+ +Qxe2# +Qxe2+ +Qxe3# +Qxe3+ +Qxe4# +Qxe4+ +Qxe5# +Qxe5+ +Qxe6# +Qxe6+ +Qxe7# +Qxe7+ +Qxe8# +Qxe8+ +Qxf1# +Qxf1+ +Qxf2# +Qxf2+ +Qxf3# +Qxf3+ +Qxf4# +Qxf4+ +Qxf5# +Qxf5+ +Qxf6# +Qxf6+ +Qxf7# +Qxf7+ +Qxf8# +Qxf8+ +Qxg1# +Qxg1+ +Qxg2# +Qxg2+ +Qxg3# +Qxg3+ +Qxg4# +Qxg4+ +Qxg5# +Qxg5+ +Qxg6# +Qxg6+ +Qxg7# +Qxg7+ +Qxg8# +Qxg8+ +Qxh1# +Qxh1+ +Qxh2# +Qxh2+ +Qxh3# +Qxh3+ +Qxh4# +Qxh4+ +Qxh5# +Qxh5+ +Qxh6# +Qxh6+ +Qxh7# +Qxh7+ +Qxh8# +Qxh8+ +R1a2# +R1a2+ +R1a3# +R1a3+ +R1a4# +R1a4+ +R1a5# +R1a5+ +R1a6# +R1a6+ +R1a7# +R1a7+ +R1b2# +R1b2+ +R1b3# +R1b3+ +R1b4# +R1b4+ +R1b5# +R1b5+ +R1b6# +R1b6+ +R1b7# +R1b7+ +R1c2# +R1c2+ +R1c3# +R1c3+ +R1c4# +R1c4+ +R1c5# +R1c5+ +R1c6# +R1c6+ +R1c7# +R1c7+ +R1d2# +R1d2+ +R1d3# +R1d3+ +R1d4# +R1d4+ +R1d5# +R1d5+ +R1d6# +R1d6+ +R1d7# +R1d7+ +R1e2# +R1e2+ +R1e3# +R1e3+ +R1e4# +R1e4+ +R1e5# +R1e5+ +R1e6# +R1e6+ +R1e7# +R1e7+ +R1f2# +R1f2+ +R1f3# +R1f3+ +R1f4# +R1f4+ +R1f5# +R1f5+ +R1f6# +R1f6+ +R1f7# +R1f7+ +R1g2# +R1g2+ +R1g3# +R1g3+ +R1g4# +R1g4+ +R1g5# +R1g5+ +R1g6# +R1g6+ +R1g7# +R1g7+ +R1h2# +R1h2+ +R1h3# +R1h3+ +R1h4# +R1h4+ +R1h5# +R1h5+ +R1h6# +R1h6+ +R1h7# +R1h7+ +R1xa2 +R1xa3 +R1xa4 +R1xa5 +R1xa6 +R1xa7 +R1xb2 +R1xb3 +R1xb4 +R1xb5 +R1xb6 +R1xb7 +R1xc2 +R1xc3 +R1xc4 +R1xc5 +R1xc6 +R1xc7 +R1xd2 +R1xd3 +R1xd4 +R1xd5 +R1xd6 +R1xd7 +R1xe2 +R1xe3 +R1xe4 +R1xe5 +R1xe6 +R1xe7 +R1xf2 +R1xf3 +R1xf4 +R1xf5 +R1xf6 +R1xf7 +R1xg2 +R1xg3 +R1xg4 +R1xg5 +R1xg6 +R1xg7 +R1xh2 +R1xh3 +R1xh4 +R1xh5 +R1xh6 +R1xh7 +R2a3# +R2a3+ +R2a4# +R2a4+ +R2a5# +R2a5+ +R2a6# +R2a6+ +R2a7# +R2a7+ +R2b3# +R2b3+ +R2b4# +R2b4+ +R2b5# +R2b5+ +R2b6# +R2b6+ +R2b7# +R2b7+ +R2c3# +R2c3+ +R2c4# +R2c4+ +R2c5# +R2c5+ +R2c6# +R2c6+ +R2c7# +R2c7+ +R2d3# +R2d3+ +R2d4# +R2d4+ +R2d5# +R2d5+ +R2d6# +R2d6+ +R2d7# +R2d7+ +R2e3# +R2e3+ +R2e4# +R2e4+ +R2e5# +R2e5+ +R2e6# +R2e6+ +R2e7# +R2e7+ +R2f3# +R2f3+ +R2f4# +R2f4+ +R2f5# +R2f5+ +R2f6# +R2f6+ +R2f7# +R2f7+ +R2g3# +R2g3+ +R2g4# +R2g4+ +R2g5# +R2g5+ +R2g6# +R2g6+ +R2g7# +R2g7+ +R2h3# +R2h3+ +R2h4# +R2h4+ +R2h5# +R2h5+ +R2h6# +R2h6+ +R2h7# +R2h7+ +R2xa3 +R2xa4 +R2xa5 +R2xa6 +R2xa7 +R2xb3 +R2xb4 +R2xb5 +R2xb6 +R2xb7 +R2xc3 +R2xc4 +R2xc5 +R2xc6 +R2xc7 +R2xd3 +R2xd4 +R2xd5 +R2xd6 +R2xd7 +R2xe3 +R2xe4 +R2xe5 +R2xe6 +R2xe7 +R2xf3 +R2xf4 +R2xf5 +R2xf6 +R2xf7 +R2xg3 +R2xg4 +R2xg5 +R2xg6 +R2xg7 +R2xh3 +R2xh4 +R2xh5 +R2xh6 +R2xh7 +R3a2# +R3a2+ +R3a4# +R3a4+ +R3a5# +R3a5+ +R3a6# +R3a6+ +R3a7# +R3a7+ +R3b2# +R3b2+ +R3b4# +R3b4+ +R3b5# +R3b5+ +R3b6# +R3b6+ +R3b7# +R3b7+ +R3c2# +R3c2+ +R3c4# +R3c4+ +R3c5# +R3c5+ +R3c6# +R3c6+ +R3c7# +R3c7+ +R3d2# +R3d2+ +R3d4# +R3d4+ +R3d5# +R3d5+ +R3d6# +R3d6+ +R3d7# +R3d7+ +R3e2# +R3e2+ +R3e4# +R3e4+ +R3e5# +R3e5+ +R3e6# +R3e6+ +R3e7# +R3e7+ +R3f2# +R3f2+ +R3f4# +R3f4+ +R3f5# +R3f5+ +R3f6# +R3f6+ +R3f7# +R3f7+ +R3g2# +R3g2+ +R3g4# +R3g4+ +R3g5# +R3g5+ +R3g6# +R3g6+ +R3g7# +R3g7+ +R3h2# +R3h2+ +R3h4# +R3h4+ +R3h5# +R3h5+ +R3h6# +R3h6+ +R3h7# +R3h7+ +R3xa2 +R3xa4 +R3xa5 +R3xa6 +R3xa7 +R3xb2 +R3xb4 +R3xb5 +R3xb6 +R3xb7 +R3xc2 +R3xc4 +R3xc5 +R3xc6 +R3xc7 +R3xd2 +R3xd4 +R3xd5 +R3xd6 +R3xd7 +R3xe2 +R3xe4 +R3xe5 +R3xe6 +R3xe7 +R3xf2 +R3xf4 +R3xf5 +R3xf6 +R3xf7 +R3xg2 +R3xg4 +R3xg5 +R3xg6 +R3xg7 +R3xh2 +R3xh4 +R3xh5 +R3xh6 +R3xh7 +R4a2# +R4a2+ +R4a3# +R4a3+ +R4a5# +R4a5+ +R4a6# +R4a6+ +R4a7# +R4a7+ +R4b2# +R4b2+ +R4b3# +R4b3+ +R4b5# +R4b5+ +R4b6# +R4b6+ +R4b7# +R4b7+ +R4c2# +R4c2+ +R4c3# +R4c3+ +R4c5# +R4c5+ +R4c6# +R4c6+ +R4c7# +R4c7+ +R4d2# +R4d2+ +R4d3# +R4d3+ +R4d5# +R4d5+ +R4d6# +R4d6+ +R4d7# +R4d7+ +R4e2# +R4e2+ +R4e3# +R4e3+ +R4e5# +R4e5+ +R4e6# +R4e6+ +R4e7# +R4e7+ +R4f2# +R4f2+ +R4f3# +R4f3+ +R4f5# +R4f5+ +R4f6# +R4f6+ +R4f7# +R4f7+ +R4g2# +R4g2+ +R4g3# +R4g3+ +R4g5# +R4g5+ +R4g6# +R4g6+ +R4g7# +R4g7+ +R4h2# +R4h2+ +R4h3# +R4h3+ +R4h5# +R4h5+ +R4h6# +R4h6+ +R4h7# +R4h7+ +R4xa2 +R4xa3 +R4xa5 +R4xa6 +R4xa7 +R4xb2 +R4xb3 +R4xb5 +R4xb6 +R4xb7 +R4xc2 +R4xc3 +R4xc5 +R4xc6 +R4xc7 +R4xd2 +R4xd3 +R4xd5 +R4xd6 +R4xd7 +R4xe2 +R4xe3 +R4xe5 +R4xe6 +R4xe7 +R4xf2 +R4xf3 +R4xf5 +R4xf6 +R4xf7 +R4xg2 +R4xg3 +R4xg5 +R4xg6 +R4xg7 +R4xh2 +R4xh3 +R4xh5 +R4xh6 +R4xh7 +R5a2# +R5a2+ +R5a3# +R5a3+ +R5a4# +R5a4+ +R5a6# +R5a6+ +R5a7# +R5a7+ +R5b2# +R5b2+ +R5b3# +R5b3+ +R5b4# +R5b4+ +R5b6# +R5b6+ +R5b7# +R5b7+ +R5c2# +R5c2+ +R5c3# +R5c3+ +R5c4# +R5c4+ +R5c6# +R5c6+ +R5c7# +R5c7+ +R5d2# +R5d2+ +R5d3# +R5d3+ +R5d4# +R5d4+ +R5d6# +R5d6+ +R5d7# +R5d7+ +R5e2# +R5e2+ +R5e3# +R5e3+ +R5e4# +R5e4+ +R5e6# +R5e6+ +R5e7# +R5e7+ +R5f2# +R5f2+ +R5f3# +R5f3+ +R5f4# +R5f4+ +R5f6# +R5f6+ +R5f7# +R5f7+ +R5g2# +R5g2+ +R5g3# +R5g3+ +R5g4# +R5g4+ +R5g6# +R5g6+ +R5g7# +R5g7+ +R5h2# +R5h2+ +R5h3# +R5h3+ +R5h4# +R5h4+ +R5h6# +R5h6+ +R5h7# +R5h7+ +R5xa2 +R5xa3 +R5xa4 +R5xa6 +R5xa7 +R5xb2 +R5xb3 +R5xb4 +R5xb6 +R5xb7 +R5xc2 +R5xc3 +R5xc4 +R5xc6 +R5xc7 +R5xd2 +R5xd3 +R5xd4 +R5xd6 +R5xd7 +R5xe2 +R5xe3 +R5xe4 +R5xe6 +R5xe7 +R5xf2 +R5xf3 +R5xf4 +R5xf6 +R5xf7 +R5xg2 +R5xg3 +R5xg4 +R5xg6 +R5xg7 +R5xh2 +R5xh3 +R5xh4 +R5xh6 +R5xh7 +R6a2# +R6a2+ +R6a3# +R6a3+ +R6a4# +R6a4+ +R6a5# +R6a5+ +R6a7# +R6a7+ +R6b2# +R6b2+ +R6b3# +R6b3+ +R6b4# +R6b4+ +R6b5# +R6b5+ +R6b7# +R6b7+ +R6c2# +R6c2+ +R6c3# +R6c3+ +R6c4# +R6c4+ +R6c5# +R6c5+ +R6c7# +R6c7+ +R6d2# +R6d2+ +R6d3# +R6d3+ +R6d4# +R6d4+ +R6d5# +R6d5+ +R6d7# +R6d7+ +R6e2# +R6e2+ +R6e3# +R6e3+ +R6e4# +R6e4+ +R6e5# +R6e5+ +R6e7# +R6e7+ +R6f2# +R6f2+ +R6f3# +R6f3+ +R6f4# +R6f4+ +R6f5# +R6f5+ +R6f7# +R6f7+ +R6g2# +R6g2+ +R6g3# +R6g3+ +R6g4# +R6g4+ +R6g5# +R6g5+ +R6g7# +R6g7+ +R6h2# +R6h2+ +R6h3# +R6h3+ +R6h4# +R6h4+ +R6h5# +R6h5+ +R6h7# +R6h7+ +R6xa2 +R6xa3 +R6xa4 +R6xa5 +R6xa7 +R6xb2 +R6xb3 +R6xb4 +R6xb5 +R6xb7 +R6xc2 +R6xc3 +R6xc4 +R6xc5 +R6xc7 +R6xd2 +R6xd3 +R6xd4 +R6xd5 +R6xd7 +R6xe2 +R6xe3 +R6xe4 +R6xe5 +R6xe7 +R6xf2 +R6xf3 +R6xf4 +R6xf5 +R6xf7 +R6xg2 +R6xg3 +R6xg4 +R6xg5 +R6xg7 +R6xh2 +R6xh3 +R6xh4 +R6xh5 +R6xh7 +R7a2# +R7a2+ +R7a3# +R7a3+ +R7a4# +R7a4+ +R7a5# +R7a5+ +R7a6# +R7a6+ +R7b2# +R7b2+ +R7b3# +R7b3+ +R7b4# +R7b4+ +R7b5# +R7b5+ +R7b6# +R7b6+ +R7c2# +R7c2+ +R7c3# +R7c3+ +R7c4# +R7c4+ +R7c5# +R7c5+ +R7c6# +R7c6+ +R7d2# +R7d2+ +R7d3# +R7d3+ +R7d4# +R7d4+ +R7d5# +R7d5+ +R7d6# +R7d6+ +R7e2# +R7e2+ +R7e3# +R7e3+ +R7e4# +R7e4+ +R7e5# +R7e5+ +R7e6# +R7e6+ +R7f2# +R7f2+ +R7f3# +R7f3+ +R7f4# +R7f4+ +R7f5# +R7f5+ +R7f6# +R7f6+ +R7g2# +R7g2+ +R7g3# +R7g3+ +R7g4# +R7g4+ +R7g5# +R7g5+ +R7g6# +R7g6+ +R7h2# +R7h2+ +R7h3# +R7h3+ +R7h4# +R7h4+ +R7h5# +R7h5+ +R7h6# +R7h6+ +R7xa2 +R7xa3 +R7xa4 +R7xa5 +R7xa6 +R7xb2 +R7xb3 +R7xb4 +R7xb5 +R7xb6 +R7xc2 +R7xc3 +R7xc4 +R7xc5 +R7xc6 +R7xd2 +R7xd3 +R7xd4 +R7xd5 +R7xd6 +R7xe2 +R7xe3 +R7xe4 +R7xe5 +R7xe6 +R7xf2 +R7xf3 +R7xf4 +R7xf5 +R7xf6 +R7xg2 +R7xg3 +R7xg4 +R7xg5 +R7xg6 +R7xh2 +R7xh3 +R7xh4 +R7xh5 +R7xh6 +R8a2# +R8a2+ +R8a3# +R8a3+ +R8a4# +R8a4+ +R8a5# +R8a5+ +R8a6# +R8a6+ +R8a7# +R8a7+ +R8b2# +R8b2+ +R8b3# +R8b3+ +R8b4# +R8b4+ +R8b5# +R8b5+ +R8b6# +R8b6+ +R8b7# +R8b7+ +R8c2# +R8c2+ +R8c3# +R8c3+ +R8c4# +R8c4+ +R8c5# +R8c5+ +R8c6# +R8c6+ +R8c7# +R8c7+ +R8d2# +R8d2+ +R8d3# +R8d3+ +R8d4# +R8d4+ +R8d5# +R8d5+ +R8d6# +R8d6+ +R8d7# +R8d7+ +R8e2# +R8e2+ +R8e3# +R8e3+ +R8e4# +R8e4+ +R8e5# +R8e5+ +R8e6# +R8e6+ +R8e7# +R8e7+ +R8f2# +R8f2+ +R8f3# +R8f3+ +R8f4# +R8f4+ +R8f5# +R8f5+ +R8f6# +R8f6+ +R8f7# +R8f7+ +R8g2# +R8g2+ +R8g3# +R8g3+ +R8g4# +R8g4+ +R8g5# +R8g5+ +R8g6# +R8g6+ +R8g7# +R8g7+ +R8h2# +R8h2+ +R8h3# +R8h3+ +R8h4# +R8h4+ +R8h5# +R8h5+ +R8h6# +R8h6+ +R8h7# +R8h7+ +R8xa2 +R8xa3 +R8xa4 +R8xa5 +R8xa6 +R8xa7 +R8xb2 +R8xb3 +R8xb4 +R8xb5 +R8xb6 +R8xb7 +R8xc2 +R8xc3 +R8xc4 +R8xc5 +R8xc6 +R8xc7 +R8xd2 +R8xd3 +R8xd4 +R8xd5 +R8xd6 +R8xd7 +R8xe2 +R8xe3 +R8xe4 +R8xe5 +R8xe6 +R8xe7 +R8xf2 +R8xf3 +R8xf4 +R8xf5 +R8xf6 +R8xf7 +R8xg2 +R8xg3 +R8xg4 +R8xg5 +R8xg6 +R8xg7 +R8xh2 +R8xh3 +R8xh4 +R8xh5 +R8xh6 +R8xh7 +Raa1# +Raa1+ +Raa2# +Raa2+ +Raa3# +Raa3+ +Raa4# +Raa4+ +Raa5# +Raa5+ +Raa6# +Raa6+ +Raa7# +Raa7+ +Raa8# +Raa8+ +Rab1# +Rab1+ +Rab2# +Rab2+ +Rab3# +Rab3+ +Rab4# +Rab4+ +Rab5# +Rab5+ +Rab6# +Rab6+ +Rab7# +Rab7+ +Rab8# +Rab8+ +Rac1# +Rac1+ +Rac2# +Rac2+ +Rac3# +Rac3+ +Rac4# +Rac4+ +Rac5# +Rac5+ +Rac6# +Rac6+ +Rac7# +Rac7+ +Rac8# +Rac8+ +Rad1# +Rad1+ +Rad2# +Rad2+ +Rad3# +Rad3+ +Rad4# +Rad4+ +Rad5# +Rad5+ +Rad6# +Rad6+ +Rad7# +Rad7+ +Rad8# +Rad8+ +Rae1# +Rae1+ +Rae2# +Rae2+ +Rae3# +Rae3+ +Rae4# +Rae4+ +Rae5# +Rae5+ +Rae6# +Rae6+ +Rae7# +Rae7+ +Rae8# +Rae8+ +Raf1# +Raf1+ +Raf2# +Raf2+ +Raf3# +Raf3+ +Raf4# +Raf4+ +Raf5# +Raf5+ +Raf6# +Raf6+ +Raf7# +Raf7+ +Raf8# +Raf8+ +Rag1# +Rag1+ +Rag2# +Rag2+ +Rag3# +Rag3+ +Rag4# +Rag4+ +Rag5# +Rag5+ +Rag6# +Rag6+ +Rag7# +Rag7+ +Rag8# +Rag8+ +Rah1# +Rah1+ +Rah2# +Rah2+ +Rah3# +Rah3+ +Rah4# +Rah4+ +Rah5# +Rah5+ +Rah6# +Rah6+ +Rah7# +Rah7+ +Rah8# +Rah8+ +Raxa1 +Raxa2 +Raxa3 +Raxa4 +Raxa5 +Raxa6 +Raxa7 +Raxa8 +Raxb1 +Raxb2 +Raxb3 +Raxb4 +Raxb5 +Raxb6 +Raxb7 +Raxb8 +Raxc1 +Raxc2 +Raxc3 +Raxc4 +Raxc5 +Raxc6 +Raxc7 +Raxc8 +Raxd1 +Raxd2 +Raxd3 +Raxd4 +Raxd5 +Raxd6 +Raxd7 +Raxd8 +Raxe1 +Raxe2 +Raxe3 +Raxe4 +Raxe5 +Raxe6 +Raxe7 +Raxe8 +Raxf1 +Raxf2 +Raxf3 +Raxf4 +Raxf5 +Raxf6 +Raxf7 +Raxf8 +Raxg1 +Raxg2 +Raxg3 +Raxg4 +Raxg5 +Raxg6 +Raxg7 +Raxg8 +Raxh1 +Raxh2 +Raxh3 +Raxh4 +Raxh5 +Raxh6 +Raxh7 +Raxh8 +Rba1# +Rba1+ +Rba2# +Rba2+ +Rba3# +Rba3+ +Rba4# +Rba4+ +Rba5# +Rba5+ +Rba6# +Rba6+ +Rba7# +Rba7+ +Rba8# +Rba8+ +Rbb1# +Rbb1+ +Rbb2# +Rbb2+ +Rbb3# +Rbb3+ +Rbb4# +Rbb4+ +Rbb5# +Rbb5+ +Rbb6# +Rbb6+ +Rbb7# +Rbb7+ +Rbb8# +Rbb8+ +Rbc1# +Rbc1+ +Rbc2# +Rbc2+ +Rbc3# +Rbc3+ +Rbc4# +Rbc4+ +Rbc5# +Rbc5+ +Rbc6# +Rbc6+ +Rbc7# +Rbc7+ +Rbc8# +Rbc8+ +Rbd1# +Rbd1+ +Rbd2# +Rbd2+ +Rbd3# +Rbd3+ +Rbd4# +Rbd4+ +Rbd5# +Rbd5+ +Rbd6# +Rbd6+ +Rbd7# +Rbd7+ +Rbd8# +Rbd8+ +Rbe1# +Rbe1+ +Rbe2# +Rbe2+ +Rbe3# +Rbe3+ +Rbe4# +Rbe4+ +Rbe5# +Rbe5+ +Rbe6# +Rbe6+ +Rbe7# +Rbe7+ +Rbe8# +Rbe8+ +Rbf1# +Rbf1+ +Rbf2# +Rbf2+ +Rbf3# +Rbf3+ +Rbf4# +Rbf4+ +Rbf5# +Rbf5+ +Rbf6# +Rbf6+ +Rbf7# +Rbf7+ +Rbf8# +Rbf8+ +Rbg1# +Rbg1+ +Rbg2# +Rbg2+ +Rbg3# +Rbg3+ +Rbg4# +Rbg4+ +Rbg5# +Rbg5+ +Rbg6# +Rbg6+ +Rbg7# +Rbg7+ +Rbg8# +Rbg8+ +Rbh1# +Rbh1+ +Rbh2# +Rbh2+ +Rbh3# +Rbh3+ +Rbh4# +Rbh4+ +Rbh5# +Rbh5+ +Rbh6# +Rbh6+ +Rbh7# +Rbh7+ +Rbh8# +Rbh8+ +Rbxa1 +Rbxa2 +Rbxa3 +Rbxa4 +Rbxa5 +Rbxa6 +Rbxa7 +Rbxa8 +Rbxb1 +Rbxb2 +Rbxb3 +Rbxb4 +Rbxb5 +Rbxb6 +Rbxb7 +Rbxb8 +Rbxc1 +Rbxc2 +Rbxc3 +Rbxc4 +Rbxc5 +Rbxc6 +Rbxc7 +Rbxc8 +Rbxd1 +Rbxd2 +Rbxd3 +Rbxd4 +Rbxd5 +Rbxd6 +Rbxd7 +Rbxd8 +Rbxe1 +Rbxe2 +Rbxe3 +Rbxe4 +Rbxe5 +Rbxe6 +Rbxe7 +Rbxe8 +Rbxf1 +Rbxf2 +Rbxf3 +Rbxf4 +Rbxf5 +Rbxf6 +Rbxf7 +Rbxf8 +Rbxg1 +Rbxg2 +Rbxg3 +Rbxg4 +Rbxg5 +Rbxg6 +Rbxg7 +Rbxg8 +Rbxh1 +Rbxh2 +Rbxh3 +Rbxh4 +Rbxh5 +Rbxh6 +Rbxh7 +Rbxh8 +Rca1# +Rca1+ +Rca2# +Rca2+ +Rca3# +Rca3+ +Rca4# +Rca4+ +Rca5# +Rca5+ +Rca6# +Rca6+ +Rca7# +Rca7+ +Rca8# +Rca8+ +Rcb1# +Rcb1+ +Rcb2# +Rcb2+ +Rcb3# +Rcb3+ +Rcb4# +Rcb4+ +Rcb5# +Rcb5+ +Rcb6# +Rcb6+ +Rcb7# +Rcb7+ +Rcb8# +Rcb8+ +Rcc1# +Rcc1+ +Rcc2# +Rcc2+ +Rcc3# +Rcc3+ +Rcc4# +Rcc4+ +Rcc5# +Rcc5+ +Rcc6# +Rcc6+ +Rcc7# +Rcc7+ +Rcc8# +Rcc8+ +Rcd1# +Rcd1+ +Rcd2# +Rcd2+ +Rcd3# +Rcd3+ +Rcd4# +Rcd4+ +Rcd5# +Rcd5+ +Rcd6# +Rcd6+ +Rcd7# +Rcd7+ +Rcd8# +Rcd8+ +Rce1# +Rce1+ +Rce2# +Rce2+ +Rce3# +Rce3+ +Rce4# +Rce4+ +Rce5# +Rce5+ +Rce6# +Rce6+ +Rce7# +Rce7+ +Rce8# +Rce8+ +Rcf1# +Rcf1+ +Rcf2# +Rcf2+ +Rcf3# +Rcf3+ +Rcf4# +Rcf4+ +Rcf5# +Rcf5+ +Rcf6# +Rcf6+ +Rcf7# +Rcf7+ +Rcf8# +Rcf8+ +Rcg1# +Rcg1+ +Rcg2# +Rcg2+ +Rcg3# +Rcg3+ +Rcg4# +Rcg4+ +Rcg5# +Rcg5+ +Rcg6# +Rcg6+ +Rcg7# +Rcg7+ +Rcg8# +Rcg8+ +Rch1# +Rch1+ +Rch2# +Rch2+ +Rch3# +Rch3+ +Rch4# +Rch4+ +Rch5# +Rch5+ +Rch6# +Rch6+ +Rch7# +Rch7+ +Rch8# +Rch8+ +Rcxa1 +Rcxa2 +Rcxa3 +Rcxa4 +Rcxa5 +Rcxa6 +Rcxa7 +Rcxa8 +Rcxb1 +Rcxb2 +Rcxb3 +Rcxb4 +Rcxb5 +Rcxb6 +Rcxb7 +Rcxb8 +Rcxc1 +Rcxc2 +Rcxc3 +Rcxc4 +Rcxc5 +Rcxc6 +Rcxc7 +Rcxc8 +Rcxd1 +Rcxd2 +Rcxd3 +Rcxd4 +Rcxd5 +Rcxd6 +Rcxd7 +Rcxd8 +Rcxe1 +Rcxe2 +Rcxe3 +Rcxe4 +Rcxe5 +Rcxe6 +Rcxe7 +Rcxe8 +Rcxf1 +Rcxf2 +Rcxf3 +Rcxf4 +Rcxf5 +Rcxf6 +Rcxf7 +Rcxf8 +Rcxg1 +Rcxg2 +Rcxg3 +Rcxg4 +Rcxg5 +Rcxg6 +Rcxg7 +Rcxg8 +Rcxh1 +Rcxh2 +Rcxh3 +Rcxh4 +Rcxh5 +Rcxh6 +Rcxh7 +Rcxh8 +Rda1# +Rda1+ +Rda2# +Rda2+ +Rda3# +Rda3+ +Rda4# +Rda4+ +Rda5# +Rda5+ +Rda6# +Rda6+ +Rda7# +Rda7+ +Rda8# +Rda8+ +Rdb1# +Rdb1+ +Rdb2# +Rdb2+ +Rdb3# +Rdb3+ +Rdb4# +Rdb4+ +Rdb5# +Rdb5+ +Rdb6# +Rdb6+ +Rdb7# +Rdb7+ +Rdb8# +Rdb8+ +Rdc1# +Rdc1+ +Rdc2# +Rdc2+ +Rdc3# +Rdc3+ +Rdc4# +Rdc4+ +Rdc5# +Rdc5+ +Rdc6# +Rdc6+ +Rdc7# +Rdc7+ +Rdc8# +Rdc8+ +Rdd1# +Rdd1+ +Rdd2# +Rdd2+ +Rdd3# +Rdd3+ +Rdd4# +Rdd4+ +Rdd5# +Rdd5+ +Rdd6# +Rdd6+ +Rdd7# +Rdd7+ +Rdd8# +Rdd8+ +Rde1# +Rde1+ +Rde2# +Rde2+ +Rde3# +Rde3+ +Rde4# +Rde4+ +Rde5# +Rde5+ +Rde6# +Rde6+ +Rde7# +Rde7+ +Rde8# +Rde8+ +Rdf1# +Rdf1+ +Rdf2# +Rdf2+ +Rdf3# +Rdf3+ +Rdf4# +Rdf4+ +Rdf5# +Rdf5+ +Rdf6# +Rdf6+ +Rdf7# +Rdf7+ +Rdf8# +Rdf8+ +Rdg1# +Rdg1+ +Rdg2# +Rdg2+ +Rdg3# +Rdg3+ +Rdg4# +Rdg4+ +Rdg5# +Rdg5+ +Rdg6# +Rdg6+ +Rdg7# +Rdg7+ +Rdg8# +Rdg8+ +Rdh1# +Rdh1+ +Rdh2# +Rdh2+ +Rdh3# +Rdh3+ +Rdh4# +Rdh4+ +Rdh5# +Rdh5+ +Rdh6# +Rdh6+ +Rdh7# +Rdh7+ +Rdh8# +Rdh8+ +Rdxa1 +Rdxa2 +Rdxa3 +Rdxa4 +Rdxa5 +Rdxa6 +Rdxa7 +Rdxa8 +Rdxb1 +Rdxb2 +Rdxb3 +Rdxb4 +Rdxb5 +Rdxb6 +Rdxb7 +Rdxb8 +Rdxc1 +Rdxc2 +Rdxc3 +Rdxc4 +Rdxc5 +Rdxc6 +Rdxc7 +Rdxc8 +Rdxd1 +Rdxd2 +Rdxd3 +Rdxd4 +Rdxd5 +Rdxd6 +Rdxd7 +Rdxd8 +Rdxe1 +Rdxe2 +Rdxe3 +Rdxe4 +Rdxe5 +Rdxe6 +Rdxe7 +Rdxe8 +Rdxf1 +Rdxf2 +Rdxf3 +Rdxf4 +Rdxf5 +Rdxf6 +Rdxf7 +Rdxf8 +Rdxg1 +Rdxg2 +Rdxg3 +Rdxg4 +Rdxg5 +Rdxg6 +Rdxg7 +Rdxg8 +Rdxh1 +Rdxh2 +Rdxh3 +Rdxh4 +Rdxh5 +Rdxh6 +Rdxh7 +Rdxh8 +Rea1# +Rea1+ +Rea2# +Rea2+ +Rea3# +Rea3+ +Rea4# +Rea4+ +Rea5# +Rea5+ +Rea6# +Rea6+ +Rea7# +Rea7+ +Rea8# +Rea8+ +Reb1# +Reb1+ +Reb2# +Reb2+ +Reb3# +Reb3+ +Reb4# +Reb4+ +Reb5# +Reb5+ +Reb6# +Reb6+ +Reb7# +Reb7+ +Reb8# +Reb8+ +Rec1# +Rec1+ +Rec2# +Rec2+ +Rec3# +Rec3+ +Rec4# +Rec4+ +Rec5# +Rec5+ +Rec6# +Rec6+ +Rec7# +Rec7+ +Rec8# +Rec8+ +Red1# +Red1+ +Red2# +Red2+ +Red3# +Red3+ +Red4# +Red4+ +Red5# +Red5+ +Red6# +Red6+ +Red7# +Red7+ +Red8# +Red8+ +Ree1# +Ree1+ +Ree2# +Ree2+ +Ree3# +Ree3+ +Ree4# +Ree4+ +Ree5# +Ree5+ +Ree6# +Ree6+ +Ree7# +Ree7+ +Ree8# +Ree8+ +Ref1# +Ref1+ +Ref2# +Ref2+ +Ref3# +Ref3+ +Ref4# +Ref4+ +Ref5# +Ref5+ +Ref6# +Ref6+ +Ref7# +Ref7+ +Ref8# +Ref8+ +Reg1# +Reg1+ +Reg2# +Reg2+ +Reg3# +Reg3+ +Reg4# +Reg4+ +Reg5# +Reg5+ +Reg6# +Reg6+ +Reg7# +Reg7+ +Reg8# +Reg8+ +Reh1# +Reh1+ +Reh2# +Reh2+ +Reh3# +Reh3+ +Reh4# +Reh4+ +Reh5# +Reh5+ +Reh6# +Reh6+ +Reh7# +Reh7+ +Reh8# +Reh8+ +Rexa1 +Rexa2 +Rexa3 +Rexa4 +Rexa5 +Rexa6 +Rexa7 +Rexa8 +Rexb1 +Rexb2 +Rexb3 +Rexb4 +Rexb5 +Rexb6 +Rexb7 +Rexb8 +Rexc1 +Rexc2 +Rexc3 +Rexc4 +Rexc5 +Rexc6 +Rexc7 +Rexc8 +Rexd1 +Rexd2 +Rexd3 +Rexd4 +Rexd5 +Rexd6 +Rexd7 +Rexd8 +Rexe1 +Rexe2 +Rexe3 +Rexe4 +Rexe5 +Rexe6 +Rexe7 +Rexe8 +Rexf1 +Rexf2 +Rexf3 +Rexf4 +Rexf5 +Rexf6 +Rexf7 +Rexf8 +Rexg1 +Rexg2 +Rexg3 +Rexg4 +Rexg5 +Rexg6 +Rexg7 +Rexg8 +Rexh1 +Rexh2 +Rexh3 +Rexh4 +Rexh5 +Rexh6 +Rexh7 +Rexh8 +Rfa1# +Rfa1+ +Rfa2# +Rfa2+ +Rfa3# +Rfa3+ +Rfa4# +Rfa4+ +Rfa5# +Rfa5+ +Rfa6# +Rfa6+ +Rfa7# +Rfa7+ +Rfa8# +Rfa8+ +Rfb1# +Rfb1+ +Rfb2# +Rfb2+ +Rfb3# +Rfb3+ +Rfb4# +Rfb4+ +Rfb5# +Rfb5+ +Rfb6# +Rfb6+ +Rfb7# +Rfb7+ +Rfb8# +Rfb8+ +Rfc1# +Rfc1+ +Rfc2# +Rfc2+ +Rfc3# +Rfc3+ +Rfc4# +Rfc4+ +Rfc5# +Rfc5+ +Rfc6# +Rfc6+ +Rfc7# +Rfc7+ +Rfc8# +Rfc8+ +Rfd1# +Rfd1+ +Rfd2# +Rfd2+ +Rfd3# +Rfd3+ +Rfd4# +Rfd4+ +Rfd5# +Rfd5+ +Rfd6# +Rfd6+ +Rfd7# +Rfd7+ +Rfd8# +Rfd8+ +Rfe1# +Rfe1+ +Rfe2# +Rfe2+ +Rfe3# +Rfe3+ +Rfe4# +Rfe4+ +Rfe5# +Rfe5+ +Rfe6# +Rfe6+ +Rfe7# +Rfe7+ +Rfe8# +Rfe8+ +Rff1# +Rff1+ +Rff2# +Rff2+ +Rff3# +Rff3+ +Rff4# +Rff4+ +Rff5# +Rff5+ +Rff6# +Rff6+ +Rff7# +Rff7+ +Rff8# +Rff8+ +Rfg1# +Rfg1+ +Rfg2# +Rfg2+ +Rfg3# +Rfg3+ +Rfg4# +Rfg4+ +Rfg5# +Rfg5+ +Rfg6# +Rfg6+ +Rfg7# +Rfg7+ +Rfg8# +Rfg8+ +Rfh1# +Rfh1+ +Rfh2# +Rfh2+ +Rfh3# +Rfh3+ +Rfh4# +Rfh4+ +Rfh5# +Rfh5+ +Rfh6# +Rfh6+ +Rfh7# +Rfh7+ +Rfh8# +Rfh8+ +Rfxa1 +Rfxa2 +Rfxa3 +Rfxa4 +Rfxa5 +Rfxa6 +Rfxa7 +Rfxa8 +Rfxb1 +Rfxb2 +Rfxb3 +Rfxb4 +Rfxb5 +Rfxb6 +Rfxb7 +Rfxb8 +Rfxc1 +Rfxc2 +Rfxc3 +Rfxc4 +Rfxc5 +Rfxc6 +Rfxc7 +Rfxc8 +Rfxd1 +Rfxd2 +Rfxd3 +Rfxd4 +Rfxd5 +Rfxd6 +Rfxd7 +Rfxd8 +Rfxe1 +Rfxe2 +Rfxe3 +Rfxe4 +Rfxe5 +Rfxe6 +Rfxe7 +Rfxe8 +Rfxf1 +Rfxf2 +Rfxf3 +Rfxf4 +Rfxf5 +Rfxf6 +Rfxf7 +Rfxf8 +Rfxg1 +Rfxg2 +Rfxg3 +Rfxg4 +Rfxg5 +Rfxg6 +Rfxg7 +Rfxg8 +Rfxh1 +Rfxh2 +Rfxh3 +Rfxh4 +Rfxh5 +Rfxh6 +Rfxh7 +Rfxh8 +Rga1# +Rga1+ +Rga2# +Rga2+ +Rga3# +Rga3+ +Rga4# +Rga4+ +Rga5# +Rga5+ +Rga6# +Rga6+ +Rga7# +Rga7+ +Rga8# +Rga8+ +Rgb1# +Rgb1+ +Rgb2# +Rgb2+ +Rgb3# +Rgb3+ +Rgb4# +Rgb4+ +Rgb5# +Rgb5+ +Rgb6# +Rgb6+ +Rgb7# +Rgb7+ +Rgb8# +Rgb8+ +Rgc1# +Rgc1+ +Rgc2# +Rgc2+ +Rgc3# +Rgc3+ +Rgc4# +Rgc4+ +Rgc5# +Rgc5+ +Rgc6# +Rgc6+ +Rgc7# +Rgc7+ +Rgc8# +Rgc8+ +Rgd1# +Rgd1+ +Rgd2# +Rgd2+ +Rgd3# +Rgd3+ +Rgd4# +Rgd4+ +Rgd5# +Rgd5+ +Rgd6# +Rgd6+ +Rgd7# +Rgd7+ +Rgd8# +Rgd8+ +Rge1# +Rge1+ +Rge2# +Rge2+ +Rge3# +Rge3+ +Rge4# +Rge4+ +Rge5# +Rge5+ +Rge6# +Rge6+ +Rge7# +Rge7+ +Rge8# +Rge8+ +Rgf1# +Rgf1+ +Rgf2# +Rgf2+ +Rgf3# +Rgf3+ +Rgf4# +Rgf4+ +Rgf5# +Rgf5+ +Rgf6# +Rgf6+ +Rgf7# +Rgf7+ +Rgf8# +Rgf8+ +Rgg1# +Rgg1+ +Rgg2# +Rgg2+ +Rgg3# +Rgg3+ +Rgg4# +Rgg4+ +Rgg5# +Rgg5+ +Rgg6# +Rgg6+ +Rgg7# +Rgg7+ +Rgg8# +Rgg8+ +Rgh1# +Rgh1+ +Rgh2# +Rgh2+ +Rgh3# +Rgh3+ +Rgh4# +Rgh4+ +Rgh5# +Rgh5+ +Rgh6# +Rgh6+ +Rgh7# +Rgh7+ +Rgh8# +Rgh8+ +Rgxa1 +Rgxa2 +Rgxa3 +Rgxa4 +Rgxa5 +Rgxa6 +Rgxa7 +Rgxa8 +Rgxb1 +Rgxb2 +Rgxb3 +Rgxb4 +Rgxb5 +Rgxb6 +Rgxb7 +Rgxb8 +Rgxc1 +Rgxc2 +Rgxc3 +Rgxc4 +Rgxc5 +Rgxc6 +Rgxc7 +Rgxc8 +Rgxd1 +Rgxd2 +Rgxd3 +Rgxd4 +Rgxd5 +Rgxd6 +Rgxd7 +Rgxd8 +Rgxe1 +Rgxe2 +Rgxe3 +Rgxe4 +Rgxe5 +Rgxe6 +Rgxe7 +Rgxe8 +Rgxf1 +Rgxf2 +Rgxf3 +Rgxf4 +Rgxf5 +Rgxf6 +Rgxf7 +Rgxf8 +Rgxg1 +Rgxg2 +Rgxg3 +Rgxg4 +Rgxg5 +Rgxg6 +Rgxg7 +Rgxg8 +Rgxh1 +Rgxh2 +Rgxh3 +Rgxh4 +Rgxh5 +Rgxh6 +Rgxh7 +Rgxh8 +Rha1# +Rha1+ +Rha2# +Rha2+ +Rha3# +Rha3+ +Rha4# +Rha4+ +Rha5# +Rha5+ +Rha6# +Rha6+ +Rha7# +Rha7+ +Rha8# +Rha8+ +Rhb1# +Rhb1+ +Rhb2# +Rhb2+ +Rhb3# +Rhb3+ +Rhb4# +Rhb4+ +Rhb5# +Rhb5+ +Rhb6# +Rhb6+ +Rhb7# +Rhb7+ +Rhb8# +Rhb8+ +Rhc1# +Rhc1+ +Rhc2# +Rhc2+ +Rhc3# +Rhc3+ +Rhc4# +Rhc4+ +Rhc5# +Rhc5+ +Rhc6# +Rhc6+ +Rhc7# +Rhc7+ +Rhc8# +Rhc8+ +Rhd1# +Rhd1+ +Rhd2# +Rhd2+ +Rhd3# +Rhd3+ +Rhd4# +Rhd4+ +Rhd5# +Rhd5+ +Rhd6# +Rhd6+ +Rhd7# +Rhd7+ +Rhd8# +Rhd8+ +Rhe1# +Rhe1+ +Rhe2# +Rhe2+ +Rhe3# +Rhe3+ +Rhe4# +Rhe4+ +Rhe5# +Rhe5+ +Rhe6# +Rhe6+ +Rhe7# +Rhe7+ +Rhe8# +Rhe8+ +Rhf1# +Rhf1+ +Rhf2# +Rhf2+ +Rhf3# +Rhf3+ +Rhf4# +Rhf4+ +Rhf5# +Rhf5+ +Rhf6# +Rhf6+ +Rhf7# +Rhf7+ +Rhf8# +Rhf8+ +Rhg1# +Rhg1+ +Rhg2# +Rhg2+ +Rhg3# +Rhg3+ +Rhg4# +Rhg4+ +Rhg5# +Rhg5+ +Rhg6# +Rhg6+ +Rhg7# +Rhg7+ +Rhg8# +Rhg8+ +Rhh1# +Rhh1+ +Rhh2# +Rhh2+ +Rhh3# +Rhh3+ +Rhh4# +Rhh4+ +Rhh5# +Rhh5+ +Rhh6# +Rhh6+ +Rhh7# +Rhh7+ +Rhh8# +Rhh8+ +Rhxa1 +Rhxa2 +Rhxa3 +Rhxa4 +Rhxa5 +Rhxa6 +Rhxa7 +Rhxa8 +Rhxb1 +Rhxb2 +Rhxb3 +Rhxb4 +Rhxb5 +Rhxb6 +Rhxb7 +Rhxb8 +Rhxc1 +Rhxc2 +Rhxc3 +Rhxc4 +Rhxc5 +Rhxc6 +Rhxc7 +Rhxc8 +Rhxd1 +Rhxd2 +Rhxd3 +Rhxd4 +Rhxd5 +Rhxd6 +Rhxd7 +Rhxd8 +Rhxe1 +Rhxe2 +Rhxe3 +Rhxe4 +Rhxe5 +Rhxe6 +Rhxe7 +Rhxe8 +Rhxf1 +Rhxf2 +Rhxf3 +Rhxf4 +Rhxf5 +Rhxf6 +Rhxf7 +Rhxf8 +Rhxg1 +Rhxg2 +Rhxg3 +Rhxg4 +Rhxg5 +Rhxg6 +Rhxg7 +Rhxg8 +Rhxh1 +Rhxh2 +Rhxh3 +Rhxh4 +Rhxh5 +Rhxh6 +Rhxh7 +Rhxh8 +Rxa1# +Rxa1+ +Rxa2# +Rxa2+ +Rxa3# +Rxa3+ +Rxa4# +Rxa4+ +Rxa5# +Rxa5+ +Rxa6# +Rxa6+ +Rxa7# +Rxa7+ +Rxa8# +Rxa8+ +Rxb1# +Rxb1+ +Rxb2# +Rxb2+ +Rxb3# +Rxb3+ +Rxb4# +Rxb4+ +Rxb5# +Rxb5+ +Rxb6# +Rxb6+ +Rxb7# +Rxb7+ +Rxb8# +Rxb8+ +Rxc1# +Rxc1+ +Rxc2# +Rxc2+ +Rxc3# +Rxc3+ +Rxc4# +Rxc4+ +Rxc5# +Rxc5+ +Rxc6# +Rxc6+ +Rxc7# +Rxc7+ +Rxc8# +Rxc8+ +Rxd1# +Rxd1+ +Rxd2# +Rxd2+ +Rxd3# +Rxd3+ +Rxd4# +Rxd4+ +Rxd5# +Rxd5+ +Rxd6# +Rxd6+ +Rxd7# +Rxd7+ +Rxd8# +Rxd8+ +Rxe1# +Rxe1+ +Rxe2# +Rxe2+ +Rxe3# +Rxe3+ +Rxe4# +Rxe4+ +Rxe5# +Rxe5+ +Rxe6# +Rxe6+ +Rxe7# +Rxe7+ +Rxe8# +Rxe8+ +Rxf1# +Rxf1+ +Rxf2# +Rxf2+ +Rxf3# +Rxf3+ +Rxf4# +Rxf4+ +Rxf5# +Rxf5+ +Rxf6# +Rxf6+ +Rxf7# +Rxf7+ +Rxf8# +Rxf8+ +Rxg1# +Rxg1+ +Rxg2# +Rxg2+ +Rxg3# +Rxg3+ +Rxg4# +Rxg4+ +Rxg5# +Rxg5+ +Rxg6# +Rxg6+ +Rxg7# +Rxg7+ +Rxg8# +Rxg8+ +Rxh1# +Rxh1+ +Rxh2# +Rxh2+ +Rxh3# +Rxh3+ +Rxh4# +Rxh4+ +Rxh5# +Rxh5+ +Rxh6# +Rxh6+ +Rxh7# +Rxh7+ +Rxh8# +Rxh8+ +a1=B# +a1=B+ +a1=N# +a1=N+ +a1=Q# +a1=Q+ +a1=R# +a1=R+ +a8=B# +a8=B+ +a8=N# +a8=N+ +a8=Q# +a8=Q+ +a8=R# +a8=R+ +axb2# +axb2+ +axb3# +axb3+ +axb4# +axb4+ +axb5# +axb5+ +axb6# +axb6+ +axb7# +axb7+ +b1=B# +b1=B+ +b1=N# +b1=N+ +b1=Q# +b1=Q+ +b1=R# +b1=R+ +b8=B# +b8=B+ +b8=N# +b8=N+ +b8=Q# +b8=Q+ +b8=R# +b8=R+ +bxa2# +bxa2+ +bxa3# +bxa3+ +bxa4# +bxa4+ +bxa5# +bxa5+ +bxa6# +bxa6+ +bxa7# +bxa7+ +bxc2# +bxc2+ +bxc3# +bxc3+ +bxc4# +bxc4+ +bxc5# +bxc5+ +bxc6# +bxc6+ +bxc7# +bxc7+ +c1=B# +c1=B+ +c1=N# +c1=N+ +c1=Q# +c1=Q+ +c1=R# +c1=R+ +c8=B# +c8=B+ +c8=N# +c8=N+ +c8=Q# +c8=Q+ +c8=R# +c8=R+ +cxb2# +cxb2+ +cxb3# +cxb3+ +cxb4# +cxb4+ +cxb5# +cxb5+ +cxb6# +cxb6+ +cxb7# +cxb7+ +cxd2# +cxd2+ +cxd3# +cxd3+ +cxd4# +cxd4+ +cxd5# +cxd5+ +cxd6# +cxd6+ +cxd7# +cxd7+ +d1=B# +d1=B+ +d1=N# +d1=N+ +d1=Q# +d1=Q+ +d1=R# +d1=R+ +d8=B# +d8=B+ +d8=N# +d8=N+ +d8=Q# +d8=Q+ +d8=R# +d8=R+ +dxc2# +dxc2+ +dxc3# +dxc3+ +dxc4# +dxc4+ +dxc5# +dxc5+ +dxc6# +dxc6+ +dxc7# +dxc7+ +dxe2# +dxe2+ +dxe3# +dxe3+ +dxe4# +dxe4+ +dxe5# +dxe5+ +dxe6# +dxe6+ +dxe7# +dxe7+ +e1=B# +e1=B+ +e1=N# +e1=N+ +e1=Q# +e1=Q+ +e1=R# +e1=R+ +e8=B# +e8=B+ +e8=N# +e8=N+ +e8=Q# +e8=Q+ +e8=R# +e8=R+ +exd2# +exd2+ +exd3# +exd3+ +exd4# +exd4+ +exd5# +exd5+ +exd6# +exd6+ +exd7# +exd7+ +exf2# +exf2+ +exf3# +exf3+ +exf4# +exf4+ +exf5# +exf5+ +exf6# +exf6+ +exf7# +exf7+ +f1=B# +f1=B+ +f1=N# +f1=N+ +f1=Q# +f1=Q+ +f1=R# +f1=R+ +f8=B# +f8=B+ +f8=N# +f8=N+ +f8=Q# +f8=Q+ +f8=R# +f8=R+ +fxe2# +fxe2+ +fxe3# +fxe3+ +fxe4# +fxe4+ +fxe5# +fxe5+ +fxe6# +fxe6+ +fxe7# +fxe7+ +fxg2# +fxg2+ +fxg3# +fxg3+ +fxg4# +fxg4+ +fxg5# +fxg5+ +fxg6# +fxg6+ +fxg7# +fxg7+ +g1=B# +g1=B+ +g1=N# +g1=N+ +g1=Q# +g1=Q+ +g1=R# +g1=R+ +g8=B# +g8=B+ +g8=N# +g8=N+ +g8=Q# +g8=Q+ +g8=R# +g8=R+ +gxf2# +gxf2+ +gxf3# +gxf3+ +gxf4# +gxf4+ +gxf5# +gxf5+ +gxf6# +gxf6+ +gxf7# +gxf7+ +gxh2# +gxh2+ +gxh3# +gxh3+ +gxh4# +gxh4+ +gxh5# +gxh5+ +gxh6# +gxh6+ +gxh7# +gxh7+ +h1=B# +h1=B+ +h1=N# +h1=N+ +h1=Q# +h1=Q+ +h1=R# +h1=R+ +h8=B# +h8=B+ +h8=N# +h8=N+ +h8=Q# +h8=Q+ +h8=R# +h8=R+ +hxg2# +hxg2+ +hxg3# +hxg3+ +hxg4# +hxg4+ +hxg5# +hxg5+ +hxg6# +hxg6+ +hxg7# +hxg7+ +B1xa2# +B1xa2+ +B1xa3# +B1xa3+ +B1xa4# +B1xa4+ +B1xb2# +B1xb2+ +B1xb3# +B1xb3+ +B1xb4# +B1xb4+ +B1xc2# +B1xc2+ +B1xc3# +B1xc3+ +B1xc4# +B1xc4+ +B1xd2# +B1xd2+ +B1xd3# +B1xd3+ +B1xd4# +B1xd4+ +B1xe2# +B1xe2+ +B1xe3# +B1xe3+ +B1xe4# +B1xe4+ +B1xf2# +B1xf2+ +B1xf3# +B1xf3+ +B1xf4# +B1xf4+ +B1xg2# +B1xg2+ +B1xg3# +B1xg3+ +B1xg4# +B1xg4+ +B1xh2# +B1xh2+ +B1xh3# +B1xh3+ +B1xh4# +B1xh4+ +B2xa3# +B2xa3+ +B2xa4# +B2xa4+ +B2xa5# +B2xa5+ +B2xb3# +B2xb3+ +B2xb4# +B2xb4+ +B2xb5# +B2xb5+ +B2xc3# +B2xc3+ +B2xc4# +B2xc4+ +B2xc5# +B2xc5+ +B2xd3# +B2xd3+ +B2xd4# +B2xd4+ +B2xd5# +B2xd5+ +B2xe3# +B2xe3+ +B2xe4# +B2xe4+ +B2xe5# +B2xe5+ +B2xf3# +B2xf3+ +B2xf4# +B2xf4+ +B2xf5# +B2xf5+ +B2xg3# +B2xg3+ +B2xg4# +B2xg4+ +B2xg5# +B2xg5+ +B2xh3# +B2xh3+ +B2xh4# +B2xh4+ +B2xh5# +B2xh5+ +B3xa2# +B3xa2+ +B3xa4# +B3xa4+ +B3xa5# +B3xa5+ +B3xb2# +B3xb2+ +B3xb4# +B3xb4+ +B3xb5# +B3xb5+ +B3xc2# +B3xc2+ +B3xc4# +B3xc4+ +B3xc5# +B3xc5+ +B3xd2# +B3xd2+ +B3xd4# +B3xd4+ +B3xd5# +B3xd5+ +B3xe2# +B3xe2+ +B3xe4# +B3xe4+ +B3xe5# +B3xe5+ +B3xf2# +B3xf2+ +B3xf4# +B3xf4+ +B3xf5# +B3xf5+ +B3xg2# +B3xg2+ +B3xg4# +B3xg4+ +B3xg5# +B3xg5+ +B3xh2# +B3xh2+ +B3xh4# +B3xh4+ +B3xh5# +B3xh5+ +B4xa3# +B4xa3+ +B4xa5# +B4xa5+ +B4xa6# +B4xa6+ +B4xb3# +B4xb3+ +B4xb5# +B4xb5+ +B4xb6# +B4xb6+ +B4xc3# +B4xc3+ +B4xc5# +B4xc5+ +B4xc6# +B4xc6+ +B4xd3# +B4xd3+ +B4xd5# +B4xd5+ +B4xd6# +B4xd6+ +B4xe3# +B4xe3+ +B4xe5# +B4xe5+ +B4xe6# +B4xe6+ +B4xf3# +B4xf3+ +B4xf5# +B4xf5+ +B4xf6# +B4xf6+ +B4xg3# +B4xg3+ +B4xg5# +B4xg5+ +B4xg6# +B4xg6+ +B4xh3# +B4xh3+ +B4xh5# +B4xh5+ +B4xh6# +B4xh6+ +B5xa3# +B5xa3+ +B5xa4# +B5xa4+ +B5xa6# +B5xa6+ +B5xb3# +B5xb3+ +B5xb4# +B5xb4+ +B5xb6# +B5xb6+ +B5xc3# +B5xc3+ +B5xc4# +B5xc4+ +B5xc6# +B5xc6+ +B5xd3# +B5xd3+ +B5xd4# +B5xd4+ +B5xd6# +B5xd6+ +B5xe3# +B5xe3+ +B5xe4# +B5xe4+ +B5xe6# +B5xe6+ +B5xf3# +B5xf3+ +B5xf4# +B5xf4+ +B5xf6# +B5xf6+ +B5xg3# +B5xg3+ +B5xg4# +B5xg4+ +B5xg6# +B5xg6+ +B5xh3# +B5xh3+ +B5xh4# +B5xh4+ +B5xh6# +B5xh6+ +B6xa4# +B6xa4+ +B6xa5# +B6xa5+ +B6xa7# +B6xa7+ +B6xb4# +B6xb4+ +B6xb5# +B6xb5+ +B6xb7# +B6xb7+ +B6xc4# +B6xc4+ +B6xc5# +B6xc5+ +B6xc7# +B6xc7+ +B6xd4# +B6xd4+ +B6xd5# +B6xd5+ +B6xd7# +B6xd7+ +B6xe4# +B6xe4+ +B6xe5# +B6xe5+ +B6xe7# +B6xe7+ +B6xf4# +B6xf4+ +B6xf5# +B6xf5+ +B6xf7# +B6xf7+ +B6xg4# +B6xg4+ +B6xg5# +B6xg5+ +B6xg7# +B6xg7+ +B6xh4# +B6xh4+ +B6xh5# +B6xh5+ +B6xh7# +B6xh7+ +B7xa4# +B7xa4+ +B7xa5# +B7xa5+ +B7xa6# +B7xa6+ +B7xb4# +B7xb4+ +B7xb5# +B7xb5+ +B7xb6# +B7xb6+ +B7xc4# +B7xc4+ +B7xc5# +B7xc5+ +B7xc6# +B7xc6+ +B7xd4# +B7xd4+ +B7xd5# +B7xd5+ +B7xd6# +B7xd6+ +B7xe4# +B7xe4+ +B7xe5# +B7xe5+ +B7xe6# +B7xe6+ +B7xf4# +B7xf4+ +B7xf5# +B7xf5+ +B7xf6# +B7xf6+ +B7xg4# +B7xg4+ +B7xg5# +B7xg5+ +B7xg6# +B7xg6+ +B7xh4# +B7xh4+ +B7xh5# +B7xh5+ +B7xh6# +B7xh6+ +B8xa5# +B8xa5+ +B8xa6# +B8xa6+ +B8xa7# +B8xa7+ +B8xb5# +B8xb5+ +B8xb6# +B8xb6+ +B8xb7# +B8xb7+ +B8xc5# +B8xc5+ +B8xc6# +B8xc6+ +B8xc7# +B8xc7+ +B8xd5# +B8xd5+ +B8xd6# +B8xd6+ +B8xd7# +B8xd7+ +B8xe5# +B8xe5+ +B8xe6# +B8xe6+ +B8xe7# +B8xe7+ +B8xf5# +B8xf5+ +B8xf6# +B8xf6+ +B8xf7# +B8xf7+ +B8xg5# +B8xg5+ +B8xg6# +B8xg6+ +B8xg7# +B8xg7+ +B8xh5# +B8xh5+ +B8xh6# +B8xh6+ +B8xh7# +B8xh7+ +Ba1b2# +Ba1b2+ +Ba1c3# +Ba1c3+ +Ba1d4# +Ba1d4+ +Ba1xb2 +Ba1xc3 +Ba1xd4 +Ba2b3# +Ba2b3+ +Ba2c4# +Ba2c4+ +Ba2d5# +Ba2d5+ +Ba2xb3 +Ba2xc4 +Ba2xd5 +Ba3b2# +Ba3b2+ +Ba3b4# +Ba3b4+ +Ba3c5# +Ba3c5+ +Ba3xb2 +Ba3xb4 +Ba3xc5 +Ba4b3# +Ba4b3+ +Ba4b5# +Ba4b5+ +Ba4c6# +Ba4c6+ +Ba4xb3 +Ba4xb5 +Ba4xc6 +Ba5b4# +Ba5b4+ +Ba5b6# +Ba5b6+ +Ba5c3# +Ba5c3+ +Ba5xb4 +Ba5xb6 +Ba5xc3 +Ba6b5# +Ba6b5+ +Ba6b7# +Ba6b7+ +Ba6c4# +Ba6c4+ +Ba6xb5 +Ba6xb7 +Ba6xc4 +Ba7b6# +Ba7b6+ +Ba7c5# +Ba7c5+ +Ba7d4# +Ba7d4+ +Ba7xb6 +Ba7xc5 +Ba7xd4 +Ba8b7# +Ba8b7+ +Ba8c6# +Ba8c6+ +Ba8d5# +Ba8d5+ +Ba8xb7 +Ba8xc6 +Ba8xd5 +Baxb1# +Baxb1+ +Baxb2# +Baxb2+ +Baxb3# +Baxb3+ +Baxb4# +Baxb4+ +Baxb5# +Baxb5+ +Baxb6# +Baxb6+ +Baxb7# +Baxb7+ +Baxb8# +Baxb8+ +Baxc1# +Baxc1+ +Baxc2# +Baxc2+ +Baxc3# +Baxc3+ +Baxc4# +Baxc4+ +Baxc5# +Baxc5+ +Baxc6# +Baxc6+ +Baxc7# +Baxc7+ +Baxc8# +Baxc8+ +Baxd1# +Baxd1+ +Baxd2# +Baxd2+ +Baxd3# +Baxd3+ +Baxd4# +Baxd4+ +Baxd5# +Baxd5+ +Baxd6# +Baxd6+ +Baxd7# +Baxd7+ +Baxd8# +Baxd8+ +Baxe1# +Baxe1+ +Baxe2# +Baxe2+ +Baxe3# +Baxe3+ +Baxe4# +Baxe4+ +Baxe5# +Baxe5+ +Baxe6# +Baxe6+ +Baxe7# +Baxe7+ +Baxe8# +Baxe8+ +Baxf1# +Baxf1+ +Baxf2# +Baxf2+ +Baxf3# +Baxf3+ +Baxf6# +Baxf6+ +Baxf7# +Baxf7+ +Baxf8# +Baxf8+ +Baxg1# +Baxg1+ +Baxg2# +Baxg2+ +Baxg7# +Baxg7+ +Baxg8# +Baxg8+ +Bb1c2# +Bb1c2+ +Bb1d3# +Bb1d3+ +Bb1e4# +Bb1e4+ +Bb1xc2 +Bb1xd3 +Bb1xe4 +Bb2c3# +Bb2c3+ +Bb2d4# +Bb2d4+ +Bb2e5# +Bb2e5+ +Bb2xc3 +Bb2xd4 +Bb2xe5 +Bb3c2# +Bb3c2+ +Bb3c4# +Bb3c4+ +Bb3d5# +Bb3d5+ +Bb3xc2 +Bb3xc4 +Bb3xd5 +Bb4c3# +Bb4c3+ +Bb4c5# +Bb4c5+ +Bb4d6# +Bb4d6+ +Bb4xc3 +Bb4xc5 +Bb4xd6 +Bb5c4# +Bb5c4+ +Bb5c6# +Bb5c6+ +Bb5d3# +Bb5d3+ +Bb5xc4 +Bb5xc6 +Bb5xd3 +Bb6c5# +Bb6c5+ +Bb6c7# +Bb6c7+ +Bb6d4# +Bb6d4+ +Bb6xc5 +Bb6xc7 +Bb6xd4 +Bb7c6# +Bb7c6+ +Bb7d5# +Bb7d5+ +Bb7e4# +Bb7e4+ +Bb7xc6 +Bb7xd5 +Bb7xe4 +Bb8c7# +Bb8c7+ +Bb8d6# +Bb8d6+ +Bb8e5# +Bb8e5+ +Bb8xc7 +Bb8xd6 +Bb8xe5 +Bbxa2# +Bbxa2+ +Bbxa3# +Bbxa3+ +Bbxa4# +Bbxa4+ +Bbxa5# +Bbxa5+ +Bbxa6# +Bbxa6+ +Bbxa7# +Bbxa7+ +Bbxc1# +Bbxc1+ +Bbxc2# +Bbxc2+ +Bbxc3# +Bbxc3+ +Bbxc4# +Bbxc4+ +Bbxc5# +Bbxc5+ +Bbxc6# +Bbxc6+ +Bbxc7# +Bbxc7+ +Bbxc8# +Bbxc8+ +Bbxd1# +Bbxd1+ +Bbxd2# +Bbxd2+ +Bbxd3# +Bbxd3+ +Bbxd4# +Bbxd4+ +Bbxd5# +Bbxd5+ +Bbxd6# +Bbxd6+ +Bbxd7# +Bbxd7+ +Bbxd8# +Bbxd8+ +Bbxe1# +Bbxe1+ +Bbxe2# +Bbxe2+ +Bbxe3# +Bbxe3+ +Bbxe4# +Bbxe4+ +Bbxe5# +Bbxe5+ +Bbxe6# +Bbxe6+ +Bbxe7# +Bbxe7+ +Bbxe8# +Bbxe8+ +Bbxf1# +Bbxf1+ +Bbxf2# +Bbxf2+ +Bbxf3# +Bbxf3+ +Bbxf4# +Bbxf4+ +Bbxf5# +Bbxf5+ +Bbxf6# +Bbxf6+ +Bbxf7# +Bbxf7+ +Bbxf8# +Bbxf8+ +Bbxg1# +Bbxg1+ +Bbxg2# +Bbxg2+ +Bbxg3# +Bbxg3+ +Bbxg6# +Bbxg6+ +Bbxg7# +Bbxg7+ +Bbxg8# +Bbxg8+ +Bbxh2# +Bbxh2+ +Bbxh7# +Bbxh7+ +Bc1b2# +Bc1b2+ +Bc1d2# +Bc1d2+ +Bc1e3# +Bc1e3+ +Bc1xb2 +Bc1xd2 +Bc1xe3 +Bc2b3# +Bc2b3+ +Bc2d3# +Bc2d3+ +Bc2e4# +Bc2e4+ +Bc2xb3 +Bc2xd3 +Bc2xe4 +Bc3b2# +Bc3b2+ +Bc3b4# +Bc3b4+ +Bc3d2# +Bc3d2+ +Bc3d4# +Bc3d4+ +Bc3e5# +Bc3e5+ +Bc3xb2 +Bc3xb4 +Bc3xd2 +Bc3xd4 +Bc3xe5 +Bc4b3# +Bc4b3+ +Bc4b5# +Bc4b5+ +Bc4d3# +Bc4d3+ +Bc4d5# +Bc4d5+ +Bc4e6# +Bc4e6+ +Bc4xb3 +Bc4xb5 +Bc4xd3 +Bc4xd5 +Bc4xe6 +Bc5b4# +Bc5b4+ +Bc5b6# +Bc5b6+ +Bc5d4# +Bc5d4+ +Bc5d6# +Bc5d6+ +Bc5e3# +Bc5e3+ +Bc5xb4 +Bc5xb6 +Bc5xd4 +Bc5xd6 +Bc5xe3 +Bc6b5# +Bc6b5+ +Bc6b7# +Bc6b7+ +Bc6d5# +Bc6d5+ +Bc6d7# +Bc6d7+ +Bc6e4# +Bc6e4+ +Bc6xb5 +Bc6xb7 +Bc6xd5 +Bc6xd7 +Bc6xe4 +Bc7b6# +Bc7b6+ +Bc7d6# +Bc7d6+ +Bc7e5# +Bc7e5+ +Bc7xb6 +Bc7xd6 +Bc7xe5 +Bc8b7# +Bc8b7+ +Bc8d7# +Bc8d7+ +Bc8e6# +Bc8e6+ +Bc8xb7 +Bc8xd7 +Bc8xe6 +Bcxa2# +Bcxa2+ +Bcxa3# +Bcxa3+ +Bcxa4# +Bcxa4+ +Bcxa5# +Bcxa5+ +Bcxa6# +Bcxa6+ +Bcxa7# +Bcxa7+ +Bcxb1# +Bcxb1+ +Bcxb2# +Bcxb2+ +Bcxb3# +Bcxb3+ +Bcxb4# +Bcxb4+ +Bcxb5# +Bcxb5+ +Bcxb6# +Bcxb6+ +Bcxb7# +Bcxb7+ +Bcxb8# +Bcxb8+ +Bcxd1# +Bcxd1+ +Bcxd2# +Bcxd2+ +Bcxd3# +Bcxd3+ +Bcxd4# +Bcxd4+ +Bcxd5# +Bcxd5+ +Bcxd6# +Bcxd6+ +Bcxd7# +Bcxd7+ +Bcxd8# +Bcxd8+ +Bcxe1# +Bcxe1+ +Bcxe2# +Bcxe2+ +Bcxe3# +Bcxe3+ +Bcxe4# +Bcxe4+ +Bcxe5# +Bcxe5+ +Bcxe6# +Bcxe6+ +Bcxe7# +Bcxe7+ +Bcxe8# +Bcxe8+ +Bcxf1# +Bcxf1+ +Bcxf2# +Bcxf2+ +Bcxf3# +Bcxf3+ +Bcxf4# +Bcxf4+ +Bcxf5# +Bcxf5+ +Bcxf6# +Bcxf6+ +Bcxf7# +Bcxf7+ +Bcxf8# +Bcxf8+ +Bcxg1# +Bcxg1+ +Bcxg2# +Bcxg2+ +Bcxg3# +Bcxg3+ +Bcxg4# +Bcxg4+ +Bcxg5# +Bcxg5+ +Bcxg6# +Bcxg6+ +Bcxg7# +Bcxg7+ +Bcxg8# +Bcxg8+ +Bcxh2# +Bcxh2+ +Bcxh3# +Bcxh3+ +Bcxh6# +Bcxh6+ +Bcxh7# +Bcxh7+ +Bd1c2# +Bd1c2+ +Bd1e2# +Bd1e2+ +Bd1f3# +Bd1f3+ +Bd1xc2 +Bd1xe2 +Bd1xf3 +Bd2c3# +Bd2c3+ +Bd2e3# +Bd2e3+ +Bd2f4# +Bd2f4+ +Bd2xc3 +Bd2xe3 +Bd2xf4 +Bd3c2# +Bd3c2+ +Bd3c4# +Bd3c4+ +Bd3e2# +Bd3e2+ +Bd3e4# +Bd3e4+ +Bd3f5# +Bd3f5+ +Bd3xc2 +Bd3xc4 +Bd3xe2 +Bd3xe4 +Bd3xf5 +Bd4c3# +Bd4c3+ +Bd4c5# +Bd4c5+ +Bd4e3# +Bd4e3+ +Bd4e5# +Bd4e5+ +Bd4f6# +Bd4f6+ +Bd4xc3 +Bd4xc5 +Bd4xe3 +Bd4xe5 +Bd4xf6 +Bd5c4# +Bd5c4+ +Bd5c6# +Bd5c6+ +Bd5e4# +Bd5e4+ +Bd5e6# +Bd5e6+ +Bd5f3# +Bd5f3+ +Bd5xc4 +Bd5xc6 +Bd5xe4 +Bd5xe6 +Bd5xf3 +Bd6c5# +Bd6c5+ +Bd6c7# +Bd6c7+ +Bd6e5# +Bd6e5+ +Bd6e7# +Bd6e7+ +Bd6f4# +Bd6f4+ +Bd6xc5 +Bd6xc7 +Bd6xe5 +Bd6xe7 +Bd6xf4 +Bd7c6# +Bd7c6+ +Bd7e6# +Bd7e6+ +Bd7f5# +Bd7f5+ +Bd7xc6 +Bd7xe6 +Bd7xf5 +Bd8c7# +Bd8c7+ +Bd8e7# +Bd8e7+ +Bd8f6# +Bd8f6+ +Bd8xc7 +Bd8xe7 +Bd8xf6 +Bdxa2# +Bdxa2+ +Bdxa3# +Bdxa3+ +Bdxa4# +Bdxa4+ +Bdxa5# +Bdxa5+ +Bdxa6# +Bdxa6+ +Bdxa7# +Bdxa7+ +Bdxb1# +Bdxb1+ +Bdxb2# +Bdxb2+ +Bdxb3# +Bdxb3+ +Bdxb4# +Bdxb4+ +Bdxb5# +Bdxb5+ +Bdxb6# +Bdxb6+ +Bdxb7# +Bdxb7+ +Bdxb8# +Bdxb8+ +Bdxc1# +Bdxc1+ +Bdxc2# +Bdxc2+ +Bdxc3# +Bdxc3+ +Bdxc4# +Bdxc4+ +Bdxc5# +Bdxc5+ +Bdxc6# +Bdxc6+ +Bdxc7# +Bdxc7+ +Bdxc8# +Bdxc8+ +Bdxe1# +Bdxe1+ +Bdxe2# +Bdxe2+ +Bdxe3# +Bdxe3+ +Bdxe4# +Bdxe4+ +Bdxe5# +Bdxe5+ +Bdxe6# +Bdxe6+ +Bdxe7# +Bdxe7+ +Bdxe8# +Bdxe8+ +Bdxf1# +Bdxf1+ +Bdxf2# +Bdxf2+ +Bdxf3# +Bdxf3+ +Bdxf4# +Bdxf4+ +Bdxf5# +Bdxf5+ +Bdxf6# +Bdxf6+ +Bdxf7# +Bdxf7+ +Bdxf8# +Bdxf8+ +Bdxg1# +Bdxg1+ +Bdxg2# +Bdxg2+ +Bdxg3# +Bdxg3+ +Bdxg4# +Bdxg4+ +Bdxg5# +Bdxg5+ +Bdxg6# +Bdxg6+ +Bdxg7# +Bdxg7+ +Bdxg8# +Bdxg8+ +Bdxh2# +Bdxh2+ +Bdxh3# +Bdxh3+ +Bdxh4# +Bdxh4+ +Bdxh5# +Bdxh5+ +Bdxh6# +Bdxh6+ +Bdxh7# +Bdxh7+ +Be1c3# +Be1c3+ +Be1d2# +Be1d2+ +Be1f2# +Be1f2+ +Be1xc3 +Be1xd2 +Be1xf2 +Be2c4# +Be2c4+ +Be2d3# +Be2d3+ +Be2f3# +Be2f3+ +Be2xc4 +Be2xd3 +Be2xf3 +Be3c5# +Be3c5+ +Be3d2# +Be3d2+ +Be3d4# +Be3d4+ +Be3f2# +Be3f2+ +Be3f4# +Be3f4+ +Be3xc5 +Be3xd2 +Be3xd4 +Be3xf2 +Be3xf4 +Be4c6# +Be4c6+ +Be4d3# +Be4d3+ +Be4d5# +Be4d5+ +Be4f3# +Be4f3+ +Be4f5# +Be4f5+ +Be4xc6 +Be4xd3 +Be4xd5 +Be4xf3 +Be4xf5 +Be5c3# +Be5c3+ +Be5d4# +Be5d4+ +Be5d6# +Be5d6+ +Be5f4# +Be5f4+ +Be5f6# +Be5f6+ +Be5xc3 +Be5xd4 +Be5xd6 +Be5xf4 +Be5xf6 +Be6c4# +Be6c4+ +Be6d5# +Be6d5+ +Be6d7# +Be6d7+ +Be6f5# +Be6f5+ +Be6f7# +Be6f7+ +Be6xc4 +Be6xd5 +Be6xd7 +Be6xf5 +Be6xf7 +Be7c5# +Be7c5+ +Be7d6# +Be7d6+ +Be7f6# +Be7f6+ +Be7xc5 +Be7xd6 +Be7xf6 +Be8c6# +Be8c6+ +Be8d7# +Be8d7+ +Be8f7# +Be8f7+ +Be8xc6 +Be8xd7 +Be8xf7 +Bexa2# +Bexa2+ +Bexa3# +Bexa3+ +Bexa4# +Bexa4+ +Bexa5# +Bexa5+ +Bexa6# +Bexa6+ +Bexa7# +Bexa7+ +Bexb1# +Bexb1+ +Bexb2# +Bexb2+ +Bexb3# +Bexb3+ +Bexb4# +Bexb4+ +Bexb5# +Bexb5+ +Bexb6# +Bexb6+ +Bexb7# +Bexb7+ +Bexb8# +Bexb8+ +Bexc1# +Bexc1+ +Bexc2# +Bexc2+ +Bexc3# +Bexc3+ +Bexc4# +Bexc4+ +Bexc5# +Bexc5+ +Bexc6# +Bexc6+ +Bexc7# +Bexc7+ +Bexc8# +Bexc8+ +Bexd1# +Bexd1+ +Bexd2# +Bexd2+ +Bexd3# +Bexd3+ +Bexd4# +Bexd4+ +Bexd5# +Bexd5+ +Bexd6# +Bexd6+ +Bexd7# +Bexd7+ +Bexd8# +Bexd8+ +Bexf1# +Bexf1+ +Bexf2# +Bexf2+ +Bexf3# +Bexf3+ +Bexf4# +Bexf4+ +Bexf5# +Bexf5+ +Bexf6# +Bexf6+ +Bexf7# +Bexf7+ +Bexf8# +Bexf8+ +Bexg1# +Bexg1+ +Bexg2# +Bexg2+ +Bexg3# +Bexg3+ +Bexg4# +Bexg4+ +Bexg5# +Bexg5+ +Bexg6# +Bexg6+ +Bexg7# +Bexg7+ +Bexg8# +Bexg8+ +Bexh2# +Bexh2+ +Bexh3# +Bexh3+ +Bexh4# +Bexh4+ +Bexh5# +Bexh5+ +Bexh6# +Bexh6+ +Bexh7# +Bexh7+ +Bf1d3# +Bf1d3+ +Bf1e2# +Bf1e2+ +Bf1g2# +Bf1g2+ +Bf1xd3 +Bf1xe2 +Bf1xg2 +Bf2d4# +Bf2d4+ +Bf2e3# +Bf2e3+ +Bf2g3# +Bf2g3+ +Bf2xd4 +Bf2xe3 +Bf2xg3 +Bf3d5# +Bf3d5+ +Bf3e2# +Bf3e2+ +Bf3e4# +Bf3e4+ +Bf3g2# +Bf3g2+ +Bf3g4# +Bf3g4+ +Bf3xd5 +Bf3xe2 +Bf3xe4 +Bf3xg2 +Bf3xg4 +Bf4d6# +Bf4d6+ +Bf4e3# +Bf4e3+ +Bf4e5# +Bf4e5+ +Bf4g3# +Bf4g3+ +Bf4g5# +Bf4g5+ +Bf4xd6 +Bf4xe3 +Bf4xe5 +Bf4xg3 +Bf4xg5 +Bf5d3# +Bf5d3+ +Bf5e4# +Bf5e4+ +Bf5e6# +Bf5e6+ +Bf5g4# +Bf5g4+ +Bf5g6# +Bf5g6+ +Bf5xd3 +Bf5xe4 +Bf5xe6 +Bf5xg4 +Bf5xg6 +Bf6d4# +Bf6d4+ +Bf6e5# +Bf6e5+ +Bf6e7# +Bf6e7+ +Bf6g5# +Bf6g5+ +Bf6g7# +Bf6g7+ +Bf6xd4 +Bf6xe5 +Bf6xe7 +Bf6xg5 +Bf6xg7 +Bf7d5# +Bf7d5+ +Bf7e6# +Bf7e6+ +Bf7g6# +Bf7g6+ +Bf7xd5 +Bf7xe6 +Bf7xg6 +Bf8d6# +Bf8d6+ +Bf8e7# +Bf8e7+ +Bf8g7# +Bf8g7+ +Bf8xd6 +Bf8xe7 +Bf8xg7 +Bfxa2# +Bfxa2+ +Bfxa3# +Bfxa3+ +Bfxa6# +Bfxa6+ +Bfxa7# +Bfxa7+ +Bfxb1# +Bfxb1+ +Bfxb2# +Bfxb2+ +Bfxb3# +Bfxb3+ +Bfxb4# +Bfxb4+ +Bfxb5# +Bfxb5+ +Bfxb6# +Bfxb6+ +Bfxb7# +Bfxb7+ +Bfxb8# +Bfxb8+ +Bfxc1# +Bfxc1+ +Bfxc2# +Bfxc2+ +Bfxc3# +Bfxc3+ +Bfxc4# +Bfxc4+ +Bfxc5# +Bfxc5+ +Bfxc6# +Bfxc6+ +Bfxc7# +Bfxc7+ +Bfxc8# +Bfxc8+ +Bfxd1# +Bfxd1+ +Bfxd2# +Bfxd2+ +Bfxd3# +Bfxd3+ +Bfxd4# +Bfxd4+ +Bfxd5# +Bfxd5+ +Bfxd6# +Bfxd6+ +Bfxd7# +Bfxd7+ +Bfxd8# +Bfxd8+ +Bfxe1# +Bfxe1+ +Bfxe2# +Bfxe2+ +Bfxe3# +Bfxe3+ +Bfxe4# +Bfxe4+ +Bfxe5# +Bfxe5+ +Bfxe6# +Bfxe6+ +Bfxe7# +Bfxe7+ +Bfxe8# +Bfxe8+ +Bfxg1# +Bfxg1+ +Bfxg2# +Bfxg2+ +Bfxg3# +Bfxg3+ +Bfxg4# +Bfxg4+ +Bfxg5# +Bfxg5+ +Bfxg6# +Bfxg6+ +Bfxg7# +Bfxg7+ +Bfxg8# +Bfxg8+ +Bfxh2# +Bfxh2+ +Bfxh3# +Bfxh3+ +Bfxh4# +Bfxh4+ +Bfxh5# +Bfxh5+ +Bfxh6# +Bfxh6+ +Bfxh7# +Bfxh7+ +Bg1d4# +Bg1d4+ +Bg1e3# +Bg1e3+ +Bg1f2# +Bg1f2+ +Bg1xd4 +Bg1xe3 +Bg1xf2 +Bg2d5# +Bg2d5+ +Bg2e4# +Bg2e4+ +Bg2f3# +Bg2f3+ +Bg2xd5 +Bg2xe4 +Bg2xf3 +Bg3e5# +Bg3e5+ +Bg3f2# +Bg3f2+ +Bg3f4# +Bg3f4+ +Bg3xe5 +Bg3xf2 +Bg3xf4 +Bg4e6# +Bg4e6+ +Bg4f3# +Bg4f3+ +Bg4f5# +Bg4f5+ +Bg4xe6 +Bg4xf3 +Bg4xf5 +Bg5e3# +Bg5e3+ +Bg5f4# +Bg5f4+ +Bg5f6# +Bg5f6+ +Bg5xe3 +Bg5xf4 +Bg5xf6 +Bg6e4# +Bg6e4+ +Bg6f5# +Bg6f5+ +Bg6f7# +Bg6f7+ +Bg6xe4 +Bg6xf5 +Bg6xf7 +Bg7d4# +Bg7d4+ +Bg7e5# +Bg7e5+ +Bg7f6# +Bg7f6+ +Bg7xd4 +Bg7xe5 +Bg7xf6 +Bg8d5# +Bg8d5+ +Bg8e6# +Bg8e6+ +Bg8f7# +Bg8f7+ +Bg8xd5 +Bg8xe6 +Bg8xf7 +Bgxa2# +Bgxa2+ +Bgxa7# +Bgxa7+ +Bgxb1# +Bgxb1+ +Bgxb2# +Bgxb2+ +Bgxb3# +Bgxb3+ +Bgxb6# +Bgxb6+ +Bgxb7# +Bgxb7+ +Bgxb8# +Bgxb8+ +Bgxc1# +Bgxc1+ +Bgxc2# +Bgxc2+ +Bgxc3# +Bgxc3+ +Bgxc4# +Bgxc4+ +Bgxc5# +Bgxc5+ +Bgxc6# +Bgxc6+ +Bgxc7# +Bgxc7+ +Bgxc8# +Bgxc8+ +Bgxd1# +Bgxd1+ +Bgxd2# +Bgxd2+ +Bgxd3# +Bgxd3+ +Bgxd4# +Bgxd4+ +Bgxd5# +Bgxd5+ +Bgxd6# +Bgxd6+ +Bgxd7# +Bgxd7+ +Bgxd8# +Bgxd8+ +Bgxe1# +Bgxe1+ +Bgxe2# +Bgxe2+ +Bgxe3# +Bgxe3+ +Bgxe4# +Bgxe4+ +Bgxe5# +Bgxe5+ +Bgxe6# +Bgxe6+ +Bgxe7# +Bgxe7+ +Bgxe8# +Bgxe8+ +Bgxf1# +Bgxf1+ +Bgxf2# +Bgxf2+ +Bgxf3# +Bgxf3+ +Bgxf4# +Bgxf4+ +Bgxf5# +Bgxf5+ +Bgxf6# +Bgxf6+ +Bgxf7# +Bgxf7+ +Bgxf8# +Bgxf8+ +Bgxh2# +Bgxh2+ +Bgxh3# +Bgxh3+ +Bgxh4# +Bgxh4+ +Bgxh5# +Bgxh5+ +Bgxh6# +Bgxh6+ +Bgxh7# +Bgxh7+ +Bh1e4# +Bh1e4+ +Bh1f3# +Bh1f3+ +Bh1g2# +Bh1g2+ +Bh1xe4 +Bh1xf3 +Bh1xg2 +Bh2e5# +Bh2e5+ +Bh2f4# +Bh2f4+ +Bh2g3# +Bh2g3+ +Bh2xe5 +Bh2xf4 +Bh2xg3 +Bh3f5# +Bh3f5+ +Bh3g2# +Bh3g2+ +Bh3g4# +Bh3g4+ +Bh3xf5 +Bh3xg2 +Bh3xg4 +Bh4f6# +Bh4f6+ +Bh4g3# +Bh4g3+ +Bh4g5# +Bh4g5+ +Bh4xf6 +Bh4xg3 +Bh4xg5 +Bh5f3# +Bh5f3+ +Bh5g4# +Bh5g4+ +Bh5g6# +Bh5g6+ +Bh5xf3 +Bh5xg4 +Bh5xg6 +Bh6f4# +Bh6f4+ +Bh6g5# +Bh6g5+ +Bh6g7# +Bh6g7+ +Bh6xf4 +Bh6xg5 +Bh6xg7 +Bh7e4# +Bh7e4+ +Bh7f5# +Bh7f5+ +Bh7g6# +Bh7g6+ +Bh7xe4 +Bh7xf5 +Bh7xg6 +Bh8e5# +Bh8e5+ +Bh8f6# +Bh8f6+ +Bh8g7# +Bh8g7+ +Bh8xe5 +Bh8xf6 +Bh8xg7 +Bhxb1# +Bhxb1+ +Bhxb2# +Bhxb2+ +Bhxb7# +Bhxb7+ +Bhxb8# +Bhxb8+ +Bhxc1# +Bhxc1+ +Bhxc2# +Bhxc2+ +Bhxc3# +Bhxc3+ +Bhxc6# +Bhxc6+ +Bhxc7# +Bhxc7+ +Bhxc8# +Bhxc8+ +Bhxd1# +Bhxd1+ +Bhxd2# +Bhxd2+ +Bhxd3# +Bhxd3+ +Bhxd4# +Bhxd4+ +Bhxd5# +Bhxd5+ +Bhxd6# +Bhxd6+ +Bhxd7# +Bhxd7+ +Bhxd8# +Bhxd8+ +Bhxe1# +Bhxe1+ +Bhxe2# +Bhxe2+ +Bhxe3# +Bhxe3+ +Bhxe4# +Bhxe4+ +Bhxe5# +Bhxe5+ +Bhxe6# +Bhxe6+ +Bhxe7# +Bhxe7+ +Bhxe8# +Bhxe8+ +Bhxf1# +Bhxf1+ +Bhxf2# +Bhxf2+ +Bhxf3# +Bhxf3+ +Bhxf4# +Bhxf4+ +Bhxf5# +Bhxf5+ +Bhxf6# +Bhxf6+ +Bhxf7# +Bhxf7+ +Bhxf8# +Bhxf8+ +Bhxg1# +Bhxg1+ +Bhxg2# +Bhxg2+ +Bhxg3# +Bhxg3+ +Bhxg4# +Bhxg4+ +Bhxg5# +Bhxg5+ +Bhxg6# +Bhxg6+ +Bhxg7# +Bhxg7+ +Bhxg8# +Bhxg8+ +N1xa2# +N1xa2+ +N1xa3# +N1xa3+ +N1xb2# +N1xb2+ +N1xb3# +N1xb3+ +N1xc2# +N1xc2+ +N1xc3# +N1xc3+ +N1xd2# +N1xd2+ +N1xd3# +N1xd3+ +N1xe2# +N1xe2+ +N1xe3# +N1xe3+ +N1xf2# +N1xf2+ +N1xf3# +N1xf3+ +N1xg2# +N1xg2+ +N1xg3# +N1xg3+ +N1xh2# +N1xh2+ +N1xh3# +N1xh3+ +N2xa3# +N2xa3+ +N2xa4# +N2xa4+ +N2xb3# +N2xb3+ +N2xb4# +N2xb4+ +N2xc3# +N2xc3+ +N2xc4# +N2xc4+ +N2xd3# +N2xd3+ +N2xd4# +N2xd4+ +N2xe3# +N2xe3+ +N2xe4# +N2xe4+ +N2xf3# +N2xf3+ +N2xf4# +N2xf4+ +N2xg3# +N2xg3+ +N2xg4# +N2xg4+ +N2xh3# +N2xh3+ +N2xh4# +N2xh4+ +N3xa2# +N3xa2+ +N3xa4# +N3xa4+ +N3xa5# +N3xa5+ +N3xb2# +N3xb2+ +N3xb4# +N3xb4+ +N3xb5# +N3xb5+ +N3xc2# +N3xc2+ +N3xc4# +N3xc4+ +N3xc5# +N3xc5+ +N3xd2# +N3xd2+ +N3xd4# +N3xd4+ +N3xd5# +N3xd5+ +N3xe2# +N3xe2+ +N3xe4# +N3xe4+ +N3xe5# +N3xe5+ +N3xf2# +N3xf2+ +N3xf4# +N3xf4+ +N3xf5# +N3xf5+ +N3xg2# +N3xg2+ +N3xg4# +N3xg4+ +N3xg5# +N3xg5+ +N3xh2# +N3xh2+ +N3xh4# +N3xh4+ +N3xh5# +N3xh5+ +N4xa3# +N4xa3+ +N4xa5# +N4xa5+ +N4xa6# +N4xa6+ +N4xb3# +N4xb3+ +N4xb5# +N4xb5+ +N4xb6# +N4xb6+ +N4xc3# +N4xc3+ +N4xc5# +N4xc5+ +N4xc6# +N4xc6+ +N4xd3# +N4xd3+ +N4xd5# +N4xd5+ +N4xd6# +N4xd6+ +N4xe3# +N4xe3+ +N4xe5# +N4xe5+ +N4xe6# +N4xe6+ +N4xf3# +N4xf3+ +N4xf5# +N4xf5+ +N4xf6# +N4xf6+ +N4xg3# +N4xg3+ +N4xg5# +N4xg5+ +N4xg6# +N4xg6+ +N4xh3# +N4xh3+ +N4xh5# +N4xh5+ +N4xh6# +N4xh6+ +N5xa3# +N5xa3+ +N5xa4# +N5xa4+ +N5xa6# +N5xa6+ +N5xb3# +N5xb3+ +N5xb4# +N5xb4+ +N5xb6# +N5xb6+ +N5xc3# +N5xc3+ +N5xc4# +N5xc4+ +N5xc6# +N5xc6+ +N5xd3# +N5xd3+ +N5xd4# +N5xd4+ +N5xd6# +N5xd6+ +N5xe3# +N5xe3+ +N5xe4# +N5xe4+ +N5xe6# +N5xe6+ +N5xf3# +N5xf3+ +N5xf4# +N5xf4+ +N5xf6# +N5xf6+ +N5xg3# +N5xg3+ +N5xg4# +N5xg4+ +N5xg6# +N5xg6+ +N5xh3# +N5xh3+ +N5xh4# +N5xh4+ +N5xh6# +N5xh6+ +N6xa4# +N6xa4+ +N6xa5# +N6xa5+ +N6xa7# +N6xa7+ +N6xb4# +N6xb4+ +N6xb5# +N6xb5+ +N6xb7# +N6xb7+ +N6xc4# +N6xc4+ +N6xc5# +N6xc5+ +N6xc7# +N6xc7+ +N6xd4# +N6xd4+ +N6xd5# +N6xd5+ +N6xd7# +N6xd7+ +N6xe4# +N6xe4+ +N6xe5# +N6xe5+ +N6xe7# +N6xe7+ +N6xf4# +N6xf4+ +N6xf5# +N6xf5+ +N6xf7# +N6xf7+ +N6xg4# +N6xg4+ +N6xg5# +N6xg5+ +N6xg7# +N6xg7+ +N6xh4# +N6xh4+ +N6xh5# +N6xh5+ +N6xh7# +N6xh7+ +N7xa5# +N7xa5+ +N7xa6# +N7xa6+ +N7xb5# +N7xb5+ +N7xb6# +N7xb6+ +N7xc5# +N7xc5+ +N7xc6# +N7xc6+ +N7xd5# +N7xd5+ +N7xd6# +N7xd6+ +N7xe5# +N7xe5+ +N7xe6# +N7xe6+ +N7xf5# +N7xf5+ +N7xf6# +N7xf6+ +N7xg5# +N7xg5+ +N7xg6# +N7xg6+ +N7xh5# +N7xh5+ +N7xh6# +N7xh6+ +N8xa6# +N8xa6+ +N8xa7# +N8xa7+ +N8xb6# +N8xb6+ +N8xb7# +N8xb7+ +N8xc6# +N8xc6+ +N8xc7# +N8xc7+ +N8xd6# +N8xd6+ +N8xd7# +N8xd7+ +N8xe6# +N8xe6+ +N8xe7# +N8xe7+ +N8xf6# +N8xf6+ +N8xf7# +N8xf7+ +N8xg6# +N8xg6+ +N8xg7# +N8xg7+ +N8xh6# +N8xh6+ +N8xh7# +N8xh7+ +Na1b3# +Na1b3+ +Na1c2# +Na1c2+ +Na1xb3 +Na1xc2 +Na2b4# +Na2b4+ +Na2c3# +Na2c3+ +Na2xb4 +Na2xc3 +Na3b5# +Na3b5+ +Na3c2# +Na3c2+ +Na3c4# +Na3c4+ +Na3xb5 +Na3xc2 +Na3xc4 +Na4b6# +Na4b6+ +Na4c3# +Na4c3+ +Na4c5# +Na4c5+ +Na4xb6 +Na4xc3 +Na4xc5 +Na5b3# +Na5b3+ +Na5c4# +Na5c4+ +Na5c6# +Na5c6+ +Na5xb3 +Na5xc4 +Na5xc6 +Na6b4# +Na6b4+ +Na6c5# +Na6c5+ +Na6c7# +Na6c7+ +Na6xb4 +Na6xc5 +Na6xc7 +Na7b5# +Na7b5+ +Na7c6# +Na7c6+ +Na7xb5 +Na7xc6 +Na8b6# +Na8b6+ +Na8c7# +Na8c7+ +Na8xb6 +Na8xc7 +Naxb1# +Naxb1+ +Naxb2# +Naxb2+ +Naxb3# +Naxb3+ +Naxb4# +Naxb4+ +Naxb5# +Naxb5+ +Naxb6# +Naxb6+ +Naxb7# +Naxb7+ +Naxb8# +Naxb8+ +Naxc1# +Naxc1+ +Naxc2# +Naxc2+ +Naxc3# +Naxc3+ +Naxc4# +Naxc4+ +Naxc5# +Naxc5+ +Naxc6# +Naxc6+ +Naxc7# +Naxc7+ +Naxc8# +Naxc8+ +Nb1c3# +Nb1c3+ +Nb1d2# +Nb1d2+ +Nb1xc3 +Nb1xd2 +Nb2c4# +Nb2c4+ +Nb2d3# +Nb2d3+ +Nb2xc4 +Nb2xd3 +Nb3c5# +Nb3c5+ +Nb3d2# +Nb3d2+ +Nb3d4# +Nb3d4+ +Nb3xc5 +Nb3xd2 +Nb3xd4 +Nb4c6# +Nb4c6+ +Nb4d3# +Nb4d3+ +Nb4d5# +Nb4d5+ +Nb4xc6 +Nb4xd3 +Nb4xd5 +Nb5c3# +Nb5c3+ +Nb5d4# +Nb5d4+ +Nb5d6# +Nb5d6+ +Nb5xc3 +Nb5xd4 +Nb5xd6 +Nb6c4# +Nb6c4+ +Nb6d5# +Nb6d5+ +Nb6d7# +Nb6d7+ +Nb6xc4 +Nb6xd5 +Nb6xd7 +Nb7c5# +Nb7c5+ +Nb7d6# +Nb7d6+ +Nb7xc5 +Nb7xd6 +Nb8c6# +Nb8c6+ +Nb8d7# +Nb8d7+ +Nb8xc6 +Nb8xd7 +Nbxa1# +Nbxa1+ +Nbxa2# +Nbxa2+ +Nbxa3# +Nbxa3+ +Nbxa4# +Nbxa4+ +Nbxa5# +Nbxa5+ +Nbxa6# +Nbxa6+ +Nbxa7# +Nbxa7+ +Nbxa8# +Nbxa8+ +Nbxc1# +Nbxc1+ +Nbxc2# +Nbxc2+ +Nbxc3# +Nbxc3+ +Nbxc4# +Nbxc4+ +Nbxc5# +Nbxc5+ +Nbxc6# +Nbxc6+ +Nbxc7# +Nbxc7+ +Nbxc8# +Nbxc8+ +Nbxd1# +Nbxd1+ +Nbxd2# +Nbxd2+ +Nbxd3# +Nbxd3+ +Nbxd4# +Nbxd4+ +Nbxd5# +Nbxd5+ +Nbxd6# +Nbxd6+ +Nbxd7# +Nbxd7+ +Nbxd8# +Nbxd8+ +Nc1b3# +Nc1b3+ +Nc1d3# +Nc1d3+ +Nc1e2# +Nc1e2+ +Nc1xb3 +Nc1xd3 +Nc1xe2 +Nc2b4# +Nc2b4+ +Nc2d4# +Nc2d4+ +Nc2e3# +Nc2e3+ +Nc2xb4 +Nc2xd4 +Nc2xe3 +Nc3b5# +Nc3b5+ +Nc3d5# +Nc3d5+ +Nc3e2# +Nc3e2+ +Nc3e4# +Nc3e4+ +Nc3xb5 +Nc3xd5 +Nc3xe2 +Nc3xe4 +Nc4b6# +Nc4b6+ +Nc4d6# +Nc4d6+ +Nc4e3# +Nc4e3+ +Nc4e5# +Nc4e5+ +Nc4xb6 +Nc4xd6 +Nc4xe3 +Nc4xe5 +Nc5b3# +Nc5b3+ +Nc5d3# +Nc5d3+ +Nc5e4# +Nc5e4+ +Nc5e6# +Nc5e6+ +Nc5xb3 +Nc5xd3 +Nc5xe4 +Nc5xe6 +Nc6b4# +Nc6b4+ +Nc6d4# +Nc6d4+ +Nc6e5# +Nc6e5+ +Nc6e7# +Nc6e7+ +Nc6xb4 +Nc6xd4 +Nc6xe5 +Nc6xe7 +Nc7b5# +Nc7b5+ +Nc7d5# +Nc7d5+ +Nc7e6# +Nc7e6+ +Nc7xb5 +Nc7xd5 +Nc7xe6 +Nc8b6# +Nc8b6+ +Nc8d6# +Nc8d6+ +Nc8e7# +Nc8e7+ +Nc8xb6 +Nc8xd6 +Nc8xe7 +Ncxa1# +Ncxa1+ +Ncxa2# +Ncxa2+ +Ncxa3# +Ncxa3+ +Ncxa4# +Ncxa4+ +Ncxa5# +Ncxa5+ +Ncxa6# +Ncxa6+ +Ncxa7# +Ncxa7+ +Ncxa8# +Ncxa8+ +Ncxb1# +Ncxb1+ +Ncxb2# +Ncxb2+ +Ncxb3# +Ncxb3+ +Ncxb4# +Ncxb4+ +Ncxb5# +Ncxb5+ +Ncxb6# +Ncxb6+ +Ncxb7# +Ncxb7+ +Ncxb8# +Ncxb8+ +Ncxd1# +Ncxd1+ +Ncxd2# +Ncxd2+ +Ncxd3# +Ncxd3+ +Ncxd4# +Ncxd4+ +Ncxd5# +Ncxd5+ +Ncxd6# +Ncxd6+ +Ncxd7# +Ncxd7+ +Ncxd8# +Ncxd8+ +Ncxe1# +Ncxe1+ +Ncxe2# +Ncxe2+ +Ncxe3# +Ncxe3+ +Ncxe4# +Ncxe4+ +Ncxe5# +Ncxe5+ +Ncxe6# +Ncxe6+ +Ncxe7# +Ncxe7+ +Ncxe8# +Ncxe8+ +Nd1c3# +Nd1c3+ +Nd1e3# +Nd1e3+ +Nd1f2# +Nd1f2+ +Nd1xc3 +Nd1xe3 +Nd1xf2 +Nd2c4# +Nd2c4+ +Nd2e4# +Nd2e4+ +Nd2f3# +Nd2f3+ +Nd2xc4 +Nd2xe4 +Nd2xf3 +Nd3c5# +Nd3c5+ +Nd3e5# +Nd3e5+ +Nd3f2# +Nd3f2+ +Nd3f4# +Nd3f4+ +Nd3xc5 +Nd3xe5 +Nd3xf2 +Nd3xf4 +Nd4c6# +Nd4c6+ +Nd4e6# +Nd4e6+ +Nd4f3# +Nd4f3+ +Nd4f5# +Nd4f5+ +Nd4xc6 +Nd4xe6 +Nd4xf3 +Nd4xf5 +Nd5c3# +Nd5c3+ +Nd5e3# +Nd5e3+ +Nd5f4# +Nd5f4+ +Nd5f6# +Nd5f6+ +Nd5xc3 +Nd5xe3 +Nd5xf4 +Nd5xf6 +Nd6c4# +Nd6c4+ +Nd6e4# +Nd6e4+ +Nd6f5# +Nd6f5+ +Nd6f7# +Nd6f7+ +Nd6xc4 +Nd6xe4 +Nd6xf5 +Nd6xf7 +Nd7c5# +Nd7c5+ +Nd7e5# +Nd7e5+ +Nd7f6# +Nd7f6+ +Nd7xc5 +Nd7xe5 +Nd7xf6 +Nd8c6# +Nd8c6+ +Nd8e6# +Nd8e6+ +Nd8f7# +Nd8f7+ +Nd8xc6 +Nd8xe6 +Nd8xf7 +Ndxb1# +Ndxb1+ +Ndxb2# +Ndxb2+ +Ndxb3# +Ndxb3+ +Ndxb4# +Ndxb4+ +Ndxb5# +Ndxb5+ +Ndxb6# +Ndxb6+ +Ndxb7# +Ndxb7+ +Ndxb8# +Ndxb8+ +Ndxc1# +Ndxc1+ +Ndxc2# +Ndxc2+ +Ndxc3# +Ndxc3+ +Ndxc4# +Ndxc4+ +Ndxc5# +Ndxc5+ +Ndxc6# +Ndxc6+ +Ndxc7# +Ndxc7+ +Ndxc8# +Ndxc8+ +Ndxe1# +Ndxe1+ +Ndxe2# +Ndxe2+ +Ndxe3# +Ndxe3+ +Ndxe4# +Ndxe4+ +Ndxe5# +Ndxe5+ +Ndxe6# +Ndxe6+ +Ndxe7# +Ndxe7+ +Ndxe8# +Ndxe8+ +Ndxf1# +Ndxf1+ +Ndxf2# +Ndxf2+ +Ndxf3# +Ndxf3+ +Ndxf4# +Ndxf4+ +Ndxf5# +Ndxf5+ +Ndxf6# +Ndxf6+ +Ndxf7# +Ndxf7+ +Ndxf8# +Ndxf8+ +Ne1c2# +Ne1c2+ +Ne1d3# +Ne1d3+ +Ne1f3# +Ne1f3+ +Ne1xc2 +Ne1xd3 +Ne1xf3 +Ne2c3# +Ne2c3+ +Ne2d4# +Ne2d4+ +Ne2f4# +Ne2f4+ +Ne2xc3 +Ne2xd4 +Ne2xf4 +Ne3c2# +Ne3c2+ +Ne3c4# +Ne3c4+ +Ne3d5# +Ne3d5+ +Ne3f5# +Ne3f5+ +Ne3xc2 +Ne3xc4 +Ne3xd5 +Ne3xf5 +Ne4c3# +Ne4c3+ +Ne4c5# +Ne4c5+ +Ne4d6# +Ne4d6+ +Ne4f6# +Ne4f6+ +Ne4xc3 +Ne4xc5 +Ne4xd6 +Ne4xf6 +Ne5c4# +Ne5c4+ +Ne5c6# +Ne5c6+ +Ne5d3# +Ne5d3+ +Ne5f3# +Ne5f3+ +Ne5xc4 +Ne5xc6 +Ne5xd3 +Ne5xf3 +Ne6c5# +Ne6c5+ +Ne6c7# +Ne6c7+ +Ne6d4# +Ne6d4+ +Ne6f4# +Ne6f4+ +Ne6xc5 +Ne6xc7 +Ne6xd4 +Ne6xf4 +Ne7c6# +Ne7c6+ +Ne7d5# +Ne7d5+ +Ne7f5# +Ne7f5+ +Ne7xc6 +Ne7xd5 +Ne7xf5 +Ne8c7# +Ne8c7+ +Ne8d6# +Ne8d6+ +Ne8f6# +Ne8f6+ +Ne8xc7 +Ne8xd6 +Ne8xf6 +Nexc1# +Nexc1+ +Nexc2# +Nexc2+ +Nexc3# +Nexc3+ +Nexc4# +Nexc4+ +Nexc5# +Nexc5+ +Nexc6# +Nexc6+ +Nexc7# +Nexc7+ +Nexc8# +Nexc8+ +Nexd1# +Nexd1+ +Nexd2# +Nexd2+ +Nexd3# +Nexd3+ +Nexd4# +Nexd4+ +Nexd5# +Nexd5+ +Nexd6# +Nexd6+ +Nexd7# +Nexd7+ +Nexd8# +Nexd8+ +Nexf1# +Nexf1+ +Nexf2# +Nexf2+ +Nexf3# +Nexf3+ +Nexf4# +Nexf4+ +Nexf5# +Nexf5+ +Nexf6# +Nexf6+ +Nexf7# +Nexf7+ +Nexf8# +Nexf8+ +Nexg1# +Nexg1+ +Nexg2# +Nexg2+ +Nexg3# +Nexg3+ +Nexg4# +Nexg4+ +Nexg5# +Nexg5+ +Nexg6# +Nexg6+ +Nexg7# +Nexg7+ +Nexg8# +Nexg8+ +Nf1d2# +Nf1d2+ +Nf1e3# +Nf1e3+ +Nf1g3# +Nf1g3+ +Nf1xd2 +Nf1xe3 +Nf1xg3 +Nf2d3# +Nf2d3+ +Nf2e4# +Nf2e4+ +Nf2g4# +Nf2g4+ +Nf2xd3 +Nf2xe4 +Nf2xg4 +Nf3d2# +Nf3d2+ +Nf3d4# +Nf3d4+ +Nf3e5# +Nf3e5+ +Nf3g5# +Nf3g5+ +Nf3xd2 +Nf3xd4 +Nf3xe5 +Nf3xg5 +Nf4d3# +Nf4d3+ +Nf4d5# +Nf4d5+ +Nf4e6# +Nf4e6+ +Nf4g6# +Nf4g6+ +Nf4xd3 +Nf4xd5 +Nf4xe6 +Nf4xg6 +Nf5d4# +Nf5d4+ +Nf5d6# +Nf5d6+ +Nf5e3# +Nf5e3+ +Nf5g3# +Nf5g3+ +Nf5xd4 +Nf5xd6 +Nf5xe3 +Nf5xg3 +Nf6d5# +Nf6d5+ +Nf6d7# +Nf6d7+ +Nf6e4# +Nf6e4+ +Nf6g4# +Nf6g4+ +Nf6xd5 +Nf6xd7 +Nf6xe4 +Nf6xg4 +Nf7d6# +Nf7d6+ +Nf7e5# +Nf7e5+ +Nf7g5# +Nf7g5+ +Nf7xd6 +Nf7xe5 +Nf7xg5 +Nf8d7# +Nf8d7+ +Nf8e6# +Nf8e6+ +Nf8g6# +Nf8g6+ +Nf8xd7 +Nf8xe6 +Nf8xg6 +Nfxd1# +Nfxd1+ +Nfxd2# +Nfxd2+ +Nfxd3# +Nfxd3+ +Nfxd4# +Nfxd4+ +Nfxd5# +Nfxd5+ +Nfxd6# +Nfxd6+ +Nfxd7# +Nfxd7+ +Nfxd8# +Nfxd8+ +Nfxe1# +Nfxe1+ +Nfxe2# +Nfxe2+ +Nfxe3# +Nfxe3+ +Nfxe4# +Nfxe4+ +Nfxe5# +Nfxe5+ +Nfxe6# +Nfxe6+ +Nfxe7# +Nfxe7+ +Nfxe8# +Nfxe8+ +Nfxg1# +Nfxg1+ +Nfxg2# +Nfxg2+ +Nfxg3# +Nfxg3+ +Nfxg4# +Nfxg4+ +Nfxg5# +Nfxg5+ +Nfxg6# +Nfxg6+ +Nfxg7# +Nfxg7+ +Nfxg8# +Nfxg8+ +Nfxh1# +Nfxh1+ +Nfxh2# +Nfxh2+ +Nfxh3# +Nfxh3+ +Nfxh4# +Nfxh4+ +Nfxh5# +Nfxh5+ +Nfxh6# +Nfxh6+ +Nfxh7# +Nfxh7+ +Nfxh8# +Nfxh8+ +Ng1e2# +Ng1e2+ +Ng1f3# +Ng1f3+ +Ng1xe2 +Ng1xf3 +Ng2e3# +Ng2e3+ +Ng2f4# +Ng2f4+ +Ng2xe3 +Ng2xf4 +Ng3e2# +Ng3e2+ +Ng3e4# +Ng3e4+ +Ng3f5# +Ng3f5+ +Ng3xe2 +Ng3xe4 +Ng3xf5 +Ng4e3# +Ng4e3+ +Ng4e5# +Ng4e5+ +Ng4f6# +Ng4f6+ +Ng4xe3 +Ng4xe5 +Ng4xf6 +Ng5e4# +Ng5e4+ +Ng5e6# +Ng5e6+ +Ng5f3# +Ng5f3+ +Ng5xe4 +Ng5xe6 +Ng5xf3 +Ng6e5# +Ng6e5+ +Ng6e7# +Ng6e7+ +Ng6f4# +Ng6f4+ +Ng6xe5 +Ng6xe7 +Ng6xf4 +Ng7e6# +Ng7e6+ +Ng7f5# +Ng7f5+ +Ng7xe6 +Ng7xf5 +Ng8e7# +Ng8e7+ +Ng8f6# +Ng8f6+ +Ng8xe7 +Ng8xf6 +Ngxe1# +Ngxe1+ +Ngxe2# +Ngxe2+ +Ngxe3# +Ngxe3+ +Ngxe4# +Ngxe4+ +Ngxe5# +Ngxe5+ +Ngxe6# +Ngxe6+ +Ngxe7# +Ngxe7+ +Ngxe8# +Ngxe8+ +Ngxf1# +Ngxf1+ +Ngxf2# +Ngxf2+ +Ngxf3# +Ngxf3+ +Ngxf4# +Ngxf4+ +Ngxf5# +Ngxf5+ +Ngxf6# +Ngxf6+ +Ngxf7# +Ngxf7+ +Ngxf8# +Ngxf8+ +Ngxh1# +Ngxh1+ +Ngxh2# +Ngxh2+ +Ngxh3# +Ngxh3+ +Ngxh4# +Ngxh4+ +Ngxh5# +Ngxh5+ +Ngxh6# +Ngxh6+ +Ngxh7# +Ngxh7+ +Ngxh8# +Ngxh8+ +Nh1f2# +Nh1f2+ +Nh1g3# +Nh1g3+ +Nh1xf2 +Nh1xg3 +Nh2f3# +Nh2f3+ +Nh2g4# +Nh2g4+ +Nh2xf3 +Nh2xg4 +Nh3f2# +Nh3f2+ +Nh3f4# +Nh3f4+ +Nh3g5# +Nh3g5+ +Nh3xf2 +Nh3xf4 +Nh3xg5 +Nh4f3# +Nh4f3+ +Nh4f5# +Nh4f5+ +Nh4g6# +Nh4g6+ +Nh4xf3 +Nh4xf5 +Nh4xg6 +Nh5f4# +Nh5f4+ +Nh5f6# +Nh5f6+ +Nh5g3# +Nh5g3+ +Nh5xf4 +Nh5xf6 +Nh5xg3 +Nh6f5# +Nh6f5+ +Nh6f7# +Nh6f7+ +Nh6g4# +Nh6g4+ +Nh6xf5 +Nh6xf7 +Nh6xg4 +Nh7f6# +Nh7f6+ +Nh7g5# +Nh7g5+ +Nh7xf6 +Nh7xg5 +Nh8f7# +Nh8f7+ +Nh8g6# +Nh8g6+ +Nh8xf7 +Nh8xg6 +Nhxf1# +Nhxf1+ +Nhxf2# +Nhxf2+ +Nhxf3# +Nhxf3+ +Nhxf4# +Nhxf4+ +Nhxf5# +Nhxf5+ +Nhxf6# +Nhxf6+ +Nhxf7# +Nhxf7+ +Nhxf8# +Nhxf8+ +Nhxg1# +Nhxg1+ +Nhxg2# +Nhxg2+ +Nhxg3# +Nhxg3+ +Nhxg4# +Nhxg4+ +Nhxg5# +Nhxg5+ +Nhxg6# +Nhxg6+ +Nhxg7# +Nhxg7+ +Nhxg8# +Nhxg8+ +O-O-O# +O-O-O+ +Q1xa1# +Q1xa1+ +Q1xa2# +Q1xa2+ +Q1xa3# +Q1xa3+ +Q1xa4# +Q1xa4+ +Q1xa5# +Q1xa5+ +Q1xa6# +Q1xa6+ +Q1xa7# +Q1xa7+ +Q1xa8# +Q1xa8+ +Q1xb1# +Q1xb1+ +Q1xb2# +Q1xb2+ +Q1xb3# +Q1xb3+ +Q1xb4# +Q1xb4+ +Q1xb5# +Q1xb5+ +Q1xb6# +Q1xb6+ +Q1xb7# +Q1xb7+ +Q1xc1# +Q1xc1+ +Q1xc2# +Q1xc2+ +Q1xc3# +Q1xc3+ +Q1xc4# +Q1xc4+ +Q1xc5# +Q1xc5+ +Q1xc6# +Q1xc6+ +Q1xc7# +Q1xc7+ +Q1xd1# +Q1xd1+ +Q1xd2# +Q1xd2+ +Q1xd3# +Q1xd3+ +Q1xd4# +Q1xd4+ +Q1xd5# +Q1xd5+ +Q1xd6# +Q1xd6+ +Q1xd7# +Q1xd7+ +Q1xe1# +Q1xe1+ +Q1xe2# +Q1xe2+ +Q1xe3# +Q1xe3+ +Q1xe4# +Q1xe4+ +Q1xe5# +Q1xe5+ +Q1xe6# +Q1xe6+ +Q1xe7# +Q1xe7+ +Q1xf1# +Q1xf1+ +Q1xf2# +Q1xf2+ +Q1xf3# +Q1xf3+ +Q1xf4# +Q1xf4+ +Q1xf5# +Q1xf5+ +Q1xf6# +Q1xf6+ +Q1xf7# +Q1xf7+ +Q1xg1# +Q1xg1+ +Q1xg2# +Q1xg2+ +Q1xg3# +Q1xg3+ +Q1xg4# +Q1xg4+ +Q1xg5# +Q1xg5+ +Q1xg6# +Q1xg6+ +Q1xg7# +Q1xg7+ +Q1xh1# +Q1xh1+ +Q1xh2# +Q1xh2+ +Q1xh3# +Q1xh3+ +Q1xh4# +Q1xh4+ +Q1xh5# +Q1xh5+ +Q1xh6# +Q1xh6+ +Q1xh7# +Q1xh7+ +Q1xh8# +Q1xh8+ +Q2xa1# +Q2xa1+ +Q2xa2# +Q2xa2+ +Q2xa3# +Q2xa3+ +Q2xa4# +Q2xa4+ +Q2xa5# +Q2xa5+ +Q2xa6# +Q2xa6+ +Q2xa7# +Q2xa7+ +Q2xa8# +Q2xa8+ +Q2xb1# +Q2xb1+ +Q2xb2# +Q2xb2+ +Q2xb3# +Q2xb3+ +Q2xb4# +Q2xb4+ +Q2xb5# +Q2xb5+ +Q2xb6# +Q2xb6+ +Q2xb7# +Q2xb7+ +Q2xb8# +Q2xb8+ +Q2xc1# +Q2xc1+ +Q2xc2# +Q2xc2+ +Q2xc3# +Q2xc3+ +Q2xc4# +Q2xc4+ +Q2xc5# +Q2xc5+ +Q2xc6# +Q2xc6+ +Q2xc7# +Q2xc7+ +Q2xd1# +Q2xd1+ +Q2xd2# +Q2xd2+ +Q2xd3# +Q2xd3+ +Q2xd4# +Q2xd4+ +Q2xd5# +Q2xd5+ +Q2xd6# +Q2xd6+ +Q2xd7# +Q2xd7+ +Q2xe1# +Q2xe1+ +Q2xe2# +Q2xe2+ +Q2xe3# +Q2xe3+ +Q2xe4# +Q2xe4+ +Q2xe5# +Q2xe5+ +Q2xe6# +Q2xe6+ +Q2xe7# +Q2xe7+ +Q2xf1# +Q2xf1+ +Q2xf2# +Q2xf2+ +Q2xf3# +Q2xf3+ +Q2xf4# +Q2xf4+ +Q2xf5# +Q2xf5+ +Q2xf6# +Q2xf6+ +Q2xf7# +Q2xf7+ +Q2xg1# +Q2xg1+ +Q2xg2# +Q2xg2+ +Q2xg3# +Q2xg3+ +Q2xg4# +Q2xg4+ +Q2xg5# +Q2xg5+ +Q2xg6# +Q2xg6+ +Q2xg7# +Q2xg7+ +Q2xg8# +Q2xg8+ +Q2xh1# +Q2xh1+ +Q2xh2# +Q2xh2+ +Q2xh3# +Q2xh3+ +Q2xh4# +Q2xh4+ +Q2xh5# +Q2xh5+ +Q2xh6# +Q2xh6+ +Q2xh7# +Q2xh7+ +Q2xh8# +Q2xh8+ +Q3xa1# +Q3xa1+ +Q3xa2# +Q3xa2+ +Q3xa3# +Q3xa3+ +Q3xa4# +Q3xa4+ +Q3xa5# +Q3xa5+ +Q3xa6# +Q3xa6+ +Q3xa7# +Q3xa7+ +Q3xa8# +Q3xa8+ +Q3xb1# +Q3xb1+ +Q3xb2# +Q3xb2+ +Q3xb3# +Q3xb3+ +Q3xb4# +Q3xb4+ +Q3xb5# +Q3xb5+ +Q3xb6# +Q3xb6+ +Q3xb7# +Q3xb7+ +Q3xb8# +Q3xb8+ +Q3xc1# +Q3xc1+ +Q3xc2# +Q3xc2+ +Q3xc3# +Q3xc3+ +Q3xc4# +Q3xc4+ +Q3xc5# +Q3xc5+ +Q3xc6# +Q3xc6+ +Q3xc7# +Q3xc7+ +Q3xc8# +Q3xc8+ +Q3xd1# +Q3xd1+ +Q3xd2# +Q3xd2+ +Q3xd3# +Q3xd3+ +Q3xd4# +Q3xd4+ +Q3xd5# +Q3xd5+ +Q3xd6# +Q3xd6+ +Q3xd7# +Q3xd7+ +Q3xe1# +Q3xe1+ +Q3xe2# +Q3xe2+ +Q3xe3# +Q3xe3+ +Q3xe4# +Q3xe4+ +Q3xe5# +Q3xe5+ +Q3xe6# +Q3xe6+ +Q3xe7# +Q3xe7+ +Q3xf1# +Q3xf1+ +Q3xf2# +Q3xf2+ +Q3xf3# +Q3xf3+ +Q3xf4# +Q3xf4+ +Q3xf5# +Q3xf5+ +Q3xf6# +Q3xf6+ +Q3xf7# +Q3xf7+ +Q3xf8# +Q3xf8+ +Q3xg1# +Q3xg1+ +Q3xg2# +Q3xg2+ +Q3xg3# +Q3xg3+ +Q3xg4# +Q3xg4+ +Q3xg5# +Q3xg5+ +Q3xg6# +Q3xg6+ +Q3xg7# +Q3xg7+ +Q3xg8# +Q3xg8+ +Q3xh1# +Q3xh1+ +Q3xh2# +Q3xh2+ +Q3xh3# +Q3xh3+ +Q3xh4# +Q3xh4+ +Q3xh5# +Q3xh5+ +Q3xh6# +Q3xh6+ +Q3xh7# +Q3xh7+ +Q3xh8# +Q3xh8+ +Q4xa1# +Q4xa1+ +Q4xa2# +Q4xa2+ +Q4xa3# +Q4xa3+ +Q4xa4# +Q4xa4+ +Q4xa5# +Q4xa5+ +Q4xa6# +Q4xa6+ +Q4xa7# +Q4xa7+ +Q4xa8# +Q4xa8+ +Q4xb1# +Q4xb1+ +Q4xb2# +Q4xb2+ +Q4xb3# +Q4xb3+ +Q4xb4# +Q4xb4+ +Q4xb5# +Q4xb5+ +Q4xb6# +Q4xb6+ +Q4xb7# +Q4xb7+ +Q4xb8# +Q4xb8+ +Q4xc1# +Q4xc1+ +Q4xc2# +Q4xc2+ +Q4xc3# +Q4xc3+ +Q4xc4# +Q4xc4+ +Q4xc5# +Q4xc5+ +Q4xc6# +Q4xc6+ +Q4xc7# +Q4xc7+ +Q4xc8# +Q4xc8+ +Q4xd1# +Q4xd1+ +Q4xd2# +Q4xd2+ +Q4xd3# +Q4xd3+ +Q4xd4# +Q4xd4+ +Q4xd5# +Q4xd5+ +Q4xd6# +Q4xd6+ +Q4xd7# +Q4xd7+ +Q4xd8# +Q4xd8+ +Q4xe1# +Q4xe1+ +Q4xe2# +Q4xe2+ +Q4xe3# +Q4xe3+ +Q4xe4# +Q4xe4+ +Q4xe5# +Q4xe5+ +Q4xe6# +Q4xe6+ +Q4xe7# +Q4xe7+ +Q4xe8# +Q4xe8+ +Q4xf1# +Q4xf1+ +Q4xf2# +Q4xf2+ +Q4xf3# +Q4xf3+ +Q4xf4# +Q4xf4+ +Q4xf5# +Q4xf5+ +Q4xf6# +Q4xf6+ +Q4xf7# +Q4xf7+ +Q4xf8# +Q4xf8+ +Q4xg1# +Q4xg1+ +Q4xg2# +Q4xg2+ +Q4xg3# +Q4xg3+ +Q4xg4# +Q4xg4+ +Q4xg5# +Q4xg5+ +Q4xg6# +Q4xg6+ +Q4xg7# +Q4xg7+ +Q4xg8# +Q4xg8+ +Q4xh1# +Q4xh1+ +Q4xh2# +Q4xh2+ +Q4xh3# +Q4xh3+ +Q4xh4# +Q4xh4+ +Q4xh5# +Q4xh5+ +Q4xh6# +Q4xh6+ +Q4xh7# +Q4xh7+ +Q4xh8# +Q4xh8+ +Q5xa1# +Q5xa1+ +Q5xa2# +Q5xa2+ +Q5xa3# +Q5xa3+ +Q5xa4# +Q5xa4+ +Q5xa5# +Q5xa5+ +Q5xa6# +Q5xa6+ +Q5xa7# +Q5xa7+ +Q5xa8# +Q5xa8+ +Q5xb1# +Q5xb1+ +Q5xb2# +Q5xb2+ +Q5xb3# +Q5xb3+ +Q5xb4# +Q5xb4+ +Q5xb5# +Q5xb5+ +Q5xb6# +Q5xb6+ +Q5xb7# +Q5xb7+ +Q5xb8# +Q5xb8+ +Q5xc1# +Q5xc1+ +Q5xc2# +Q5xc2+ +Q5xc3# +Q5xc3+ +Q5xc4# +Q5xc4+ +Q5xc5# +Q5xc5+ +Q5xc6# +Q5xc6+ +Q5xc7# +Q5xc7+ +Q5xc8# +Q5xc8+ +Q5xd1# +Q5xd1+ +Q5xd2# +Q5xd2+ +Q5xd3# +Q5xd3+ +Q5xd4# +Q5xd4+ +Q5xd5# +Q5xd5+ +Q5xd6# +Q5xd6+ +Q5xd7# +Q5xd7+ +Q5xd8# +Q5xd8+ +Q5xe1# +Q5xe1+ +Q5xe2# +Q5xe2+ +Q5xe3# +Q5xe3+ +Q5xe4# +Q5xe4+ +Q5xe5# +Q5xe5+ +Q5xe6# +Q5xe6+ +Q5xe7# +Q5xe7+ +Q5xe8# +Q5xe8+ +Q5xf1# +Q5xf1+ +Q5xf2# +Q5xf2+ +Q5xf3# +Q5xf3+ +Q5xf4# +Q5xf4+ +Q5xf5# +Q5xf5+ +Q5xf6# +Q5xf6+ +Q5xf7# +Q5xf7+ +Q5xf8# +Q5xf8+ +Q5xg1# +Q5xg1+ +Q5xg2# +Q5xg2+ +Q5xg3# +Q5xg3+ +Q5xg4# +Q5xg4+ +Q5xg5# +Q5xg5+ +Q5xg6# +Q5xg6+ +Q5xg7# +Q5xg7+ +Q5xg8# +Q5xg8+ +Q5xh1# +Q5xh1+ +Q5xh2# +Q5xh2+ +Q5xh3# +Q5xh3+ +Q5xh4# +Q5xh4+ +Q5xh5# +Q5xh5+ +Q5xh6# +Q5xh6+ +Q5xh7# +Q5xh7+ +Q5xh8# +Q5xh8+ +Q6xa1# +Q6xa1+ +Q6xa2# +Q6xa2+ +Q6xa3# +Q6xa3+ +Q6xa4# +Q6xa4+ +Q6xa5# +Q6xa5+ +Q6xa6# +Q6xa6+ +Q6xa7# +Q6xa7+ +Q6xa8# +Q6xa8+ +Q6xb1# +Q6xb1+ +Q6xb2# +Q6xb2+ +Q6xb3# +Q6xb3+ +Q6xb4# +Q6xb4+ +Q6xb5# +Q6xb5+ +Q6xb6# +Q6xb6+ +Q6xb7# +Q6xb7+ +Q6xb8# +Q6xb8+ +Q6xc1# +Q6xc1+ +Q6xc2# +Q6xc2+ +Q6xc3# +Q6xc3+ +Q6xc4# +Q6xc4+ +Q6xc5# +Q6xc5+ +Q6xc6# +Q6xc6+ +Q6xc7# +Q6xc7+ +Q6xc8# +Q6xc8+ +Q6xd2# +Q6xd2+ +Q6xd3# +Q6xd3+ +Q6xd4# +Q6xd4+ +Q6xd5# +Q6xd5+ +Q6xd6# +Q6xd6+ +Q6xd7# +Q6xd7+ +Q6xd8# +Q6xd8+ +Q6xe2# +Q6xe2+ +Q6xe3# +Q6xe3+ +Q6xe4# +Q6xe4+ +Q6xe5# +Q6xe5+ +Q6xe6# +Q6xe6+ +Q6xe7# +Q6xe7+ +Q6xe8# +Q6xe8+ +Q6xf1# +Q6xf1+ +Q6xf2# +Q6xf2+ +Q6xf3# +Q6xf3+ +Q6xf4# +Q6xf4+ +Q6xf5# +Q6xf5+ +Q6xf6# +Q6xf6+ +Q6xf7# +Q6xf7+ +Q6xf8# +Q6xf8+ +Q6xg1# +Q6xg1+ +Q6xg2# +Q6xg2+ +Q6xg3# +Q6xg3+ +Q6xg4# +Q6xg4+ +Q6xg5# +Q6xg5+ +Q6xg6# +Q6xg6+ +Q6xg7# +Q6xg7+ +Q6xg8# +Q6xg8+ +Q6xh1# +Q6xh1+ +Q6xh2# +Q6xh2+ +Q6xh3# +Q6xh3+ +Q6xh4# +Q6xh4+ +Q6xh5# +Q6xh5+ +Q6xh6# +Q6xh6+ +Q6xh7# +Q6xh7+ +Q6xh8# +Q6xh8+ +Q7xa1# +Q7xa1+ +Q7xa2# +Q7xa2+ +Q7xa3# +Q7xa3+ +Q7xa4# +Q7xa4+ +Q7xa5# +Q7xa5+ +Q7xa6# +Q7xa6+ +Q7xa7# +Q7xa7+ +Q7xa8# +Q7xa8+ +Q7xb1# +Q7xb1+ +Q7xb2# +Q7xb2+ +Q7xb3# +Q7xb3+ +Q7xb4# +Q7xb4+ +Q7xb5# +Q7xb5+ +Q7xb6# +Q7xb6+ +Q7xb7# +Q7xb7+ +Q7xb8# +Q7xb8+ +Q7xc2# +Q7xc2+ +Q7xc3# +Q7xc3+ +Q7xc4# +Q7xc4+ +Q7xc5# +Q7xc5+ +Q7xc6# +Q7xc6+ +Q7xc7# +Q7xc7+ +Q7xc8# +Q7xc8+ +Q7xd2# +Q7xd2+ +Q7xd3# +Q7xd3+ +Q7xd4# +Q7xd4+ +Q7xd5# +Q7xd5+ +Q7xd6# +Q7xd6+ +Q7xd7# +Q7xd7+ +Q7xd8# +Q7xd8+ +Q7xe2# +Q7xe2+ +Q7xe3# +Q7xe3+ +Q7xe4# +Q7xe4+ +Q7xe5# +Q7xe5+ +Q7xe6# +Q7xe6+ +Q7xe7# +Q7xe7+ +Q7xe8# +Q7xe8+ +Q7xf2# +Q7xf2+ +Q7xf3# +Q7xf3+ +Q7xf4# +Q7xf4+ +Q7xf5# +Q7xf5+ +Q7xf6# +Q7xf6+ +Q7xf7# +Q7xf7+ +Q7xf8# +Q7xf8+ +Q7xg1# +Q7xg1+ +Q7xg2# +Q7xg2+ +Q7xg3# +Q7xg3+ +Q7xg4# +Q7xg4+ +Q7xg5# +Q7xg5+ +Q7xg6# +Q7xg6+ +Q7xg7# +Q7xg7+ +Q7xg8# +Q7xg8+ +Q7xh1# +Q7xh1+ +Q7xh2# +Q7xh2+ +Q7xh3# +Q7xh3+ +Q7xh4# +Q7xh4+ +Q7xh5# +Q7xh5+ +Q7xh6# +Q7xh6+ +Q7xh7# +Q7xh7+ +Q7xh8# +Q7xh8+ +Q8xa1# +Q8xa1+ +Q8xa2# +Q8xa2+ +Q8xa3# +Q8xa3+ +Q8xa4# +Q8xa4+ +Q8xa5# +Q8xa5+ +Q8xa6# +Q8xa6+ +Q8xa7# +Q8xa7+ +Q8xa8# +Q8xa8+ +Q8xb2# +Q8xb2+ +Q8xb3# +Q8xb3+ +Q8xb4# +Q8xb4+ +Q8xb5# +Q8xb5+ +Q8xb6# +Q8xb6+ +Q8xb7# +Q8xb7+ +Q8xb8# +Q8xb8+ +Q8xc2# +Q8xc2+ +Q8xc3# +Q8xc3+ +Q8xc4# +Q8xc4+ +Q8xc5# +Q8xc5+ +Q8xc6# +Q8xc6+ +Q8xc7# +Q8xc7+ +Q8xc8# +Q8xc8+ +Q8xd2# +Q8xd2+ +Q8xd3# +Q8xd3+ +Q8xd4# +Q8xd4+ +Q8xd5# +Q8xd5+ +Q8xd6# +Q8xd6+ +Q8xd7# +Q8xd7+ +Q8xd8# +Q8xd8+ +Q8xe2# +Q8xe2+ +Q8xe3# +Q8xe3+ +Q8xe4# +Q8xe4+ +Q8xe5# +Q8xe5+ +Q8xe6# +Q8xe6+ +Q8xe7# +Q8xe7+ +Q8xe8# +Q8xe8+ +Q8xf2# +Q8xf2+ +Q8xf3# +Q8xf3+ +Q8xf4# +Q8xf4+ +Q8xf5# +Q8xf5+ +Q8xf6# +Q8xf6+ +Q8xf7# +Q8xf7+ +Q8xf8# +Q8xf8+ +Q8xg2# +Q8xg2+ +Q8xg3# +Q8xg3+ +Q8xg4# +Q8xg4+ +Q8xg5# +Q8xg5+ +Q8xg6# +Q8xg6+ +Q8xg7# +Q8xg7+ +Q8xg8# +Q8xg8+ +Q8xh1# +Q8xh1+ +Q8xh2# +Q8xh2+ +Q8xh3# +Q8xh3+ +Q8xh4# +Q8xh4+ +Q8xh5# +Q8xh5+ +Q8xh6# +Q8xh6+ +Q8xh7# +Q8xh7+ +Q8xh8# +Q8xh8+ +Qa1a2# +Qa1a2+ +Qa1a3# +Qa1a3+ +Qa1a4# +Qa1a4+ +Qa1a5# +Qa1a5+ +Qa1a6# +Qa1a6+ +Qa1a7# +Qa1a7+ +Qa1b1# +Qa1b1+ +Qa1b2# +Qa1b2+ +Qa1c1# +Qa1c1+ +Qa1c3# +Qa1c3+ +Qa1d1# +Qa1d1+ +Qa1d4# +Qa1d4+ +Qa1e1# +Qa1e1+ +Qa1e5# +Qa1e5+ +Qa1f1# +Qa1f1+ +Qa1f6# +Qa1f6+ +Qa1g1# +Qa1g1+ +Qa1g7# +Qa1g7+ +Qa1h8# +Qa1h8+ +Qa1xa2 +Qa1xa3 +Qa1xa4 +Qa1xa5 +Qa1xa6 +Qa1xa7 +Qa1xb1 +Qa1xb2 +Qa1xc1 +Qa1xc3 +Qa1xd1 +Qa1xd4 +Qa1xe1 +Qa1xe5 +Qa1xf1 +Qa1xf6 +Qa1xg1 +Qa1xg7 +Qa1xh8 +Qa2a3# +Qa2a3+ +Qa2a4# +Qa2a4+ +Qa2a5# +Qa2a5+ +Qa2a6# +Qa2a6+ +Qa2a7# +Qa2a7+ +Qa2b1# +Qa2b1+ +Qa2b2# +Qa2b2+ +Qa2b3# +Qa2b3+ +Qa2c2# +Qa2c2+ +Qa2c4# +Qa2c4+ +Qa2d2# +Qa2d2+ +Qa2d5# +Qa2d5+ +Qa2e2# +Qa2e2+ +Qa2e6# +Qa2e6+ +Qa2f2# +Qa2f2+ +Qa2f7# +Qa2f7+ +Qa2g2# +Qa2g2+ +Qa2g8# +Qa2g8+ +Qa2xa3 +Qa2xa4 +Qa2xa5 +Qa2xa6 +Qa2xa7 +Qa2xb1 +Qa2xb2 +Qa2xb3 +Qa2xc2 +Qa2xc4 +Qa2xd2 +Qa2xd5 +Qa2xe2 +Qa2xe6 +Qa2xf2 +Qa2xf7 +Qa2xg2 +Qa2xg8 +Qa3a2# +Qa3a2+ +Qa3a4# +Qa3a4+ +Qa3a5# +Qa3a5+ +Qa3a6# +Qa3a6+ +Qa3a7# +Qa3a7+ +Qa3b2# +Qa3b2+ +Qa3b3# +Qa3b3+ +Qa3b4# +Qa3b4+ +Qa3c1# +Qa3c1+ +Qa3c3# +Qa3c3+ +Qa3c5# +Qa3c5+ +Qa3d3# +Qa3d3+ +Qa3d6# +Qa3d6+ +Qa3e3# +Qa3e3+ +Qa3e7# +Qa3e7+ +Qa3f3# +Qa3f3+ +Qa3f8# +Qa3f8+ +Qa3xa2 +Qa3xa4 +Qa3xa5 +Qa3xa6 +Qa3xa7 +Qa3xb2 +Qa3xb3 +Qa3xb4 +Qa3xc1 +Qa3xc3 +Qa3xc5 +Qa3xd3 +Qa3xd6 +Qa3xe3 +Qa3xe7 +Qa3xf3 +Qa3xf8 +Qa4a2# +Qa4a2+ +Qa4a3# +Qa4a3+ +Qa4a5# +Qa4a5+ +Qa4a6# +Qa4a6+ +Qa4a7# +Qa4a7+ +Qa4b3# +Qa4b3+ +Qa4b4# +Qa4b4+ +Qa4b5# +Qa4b5+ +Qa4c2# +Qa4c2+ +Qa4c4# +Qa4c4+ +Qa4c6# +Qa4c6+ +Qa4d1# +Qa4d1+ +Qa4d4# +Qa4d4+ +Qa4d7# +Qa4d7+ +Qa4e4# +Qa4e4+ +Qa4e8# +Qa4e8+ +Qa4xa2 +Qa4xa3 +Qa4xa5 +Qa4xa6 +Qa4xa7 +Qa4xb3 +Qa4xb4 +Qa4xb5 +Qa4xc2 +Qa4xc4 +Qa4xc6 +Qa4xd1 +Qa4xd4 +Qa4xd7 +Qa4xe4 +Qa4xe8 +Qa5a2# +Qa5a2+ +Qa5a3# +Qa5a3+ +Qa5a4# +Qa5a4+ +Qa5a6# +Qa5a6+ +Qa5a7# +Qa5a7+ +Qa5b4# +Qa5b4+ +Qa5b5# +Qa5b5+ +Qa5b6# +Qa5b6+ +Qa5c3# +Qa5c3+ +Qa5c5# +Qa5c5+ +Qa5c7# +Qa5c7+ +Qa5d2# +Qa5d2+ +Qa5d5# +Qa5d5+ +Qa5d8# +Qa5d8+ +Qa5e1# +Qa5e1+ +Qa5e5# +Qa5e5+ +Qa5xa2 +Qa5xa3 +Qa5xa4 +Qa5xa6 +Qa5xa7 +Qa5xb4 +Qa5xb5 +Qa5xb6 +Qa5xc3 +Qa5xc5 +Qa5xc7 +Qa5xd2 +Qa5xd5 +Qa5xd8 +Qa5xe1 +Qa5xe5 +Qa6a2# +Qa6a2+ +Qa6a3# +Qa6a3+ +Qa6a4# +Qa6a4+ +Qa6a5# +Qa6a5+ +Qa6a7# +Qa6a7+ +Qa6b5# +Qa6b5+ +Qa6b6# +Qa6b6+ +Qa6b7# +Qa6b7+ +Qa6c4# +Qa6c4+ +Qa6c6# +Qa6c6+ +Qa6c8# +Qa6c8+ +Qa6d3# +Qa6d3+ +Qa6d6# +Qa6d6+ +Qa6e2# +Qa6e2+ +Qa6e6# +Qa6e6+ +Qa6f1# +Qa6f1+ +Qa6f6# +Qa6f6+ +Qa6xa2 +Qa6xa3 +Qa6xa4 +Qa6xa5 +Qa6xa7 +Qa6xb5 +Qa6xb6 +Qa6xb7 +Qa6xc4 +Qa6xc6 +Qa6xc8 +Qa6xd3 +Qa6xd6 +Qa6xe2 +Qa6xe6 +Qa6xf1 +Qa6xf6 +Qa7a2# +Qa7a2+ +Qa7a3# +Qa7a3+ +Qa7a4# +Qa7a4+ +Qa7a5# +Qa7a5+ +Qa7a6# +Qa7a6+ +Qa7b6# +Qa7b6+ +Qa7b7# +Qa7b7+ +Qa7b8# +Qa7b8+ +Qa7c5# +Qa7c5+ +Qa7c7# +Qa7c7+ +Qa7d4# +Qa7d4+ +Qa7d7# +Qa7d7+ +Qa7e3# +Qa7e3+ +Qa7e7# +Qa7e7+ +Qa7f2# +Qa7f2+ +Qa7f7# +Qa7f7+ +Qa7g1# +Qa7g1+ +Qa7g7# +Qa7g7+ +Qa7xa2 +Qa7xa3 +Qa7xa4 +Qa7xa5 +Qa7xa6 +Qa7xb6 +Qa7xb7 +Qa7xb8 +Qa7xc5 +Qa7xc7 +Qa7xd4 +Qa7xd7 +Qa7xe3 +Qa7xe7 +Qa7xf2 +Qa7xf7 +Qa7xg1 +Qa7xg7 +Qa8a2# +Qa8a2+ +Qa8a3# +Qa8a3+ +Qa8a4# +Qa8a4+ +Qa8a5# +Qa8a5+ +Qa8a6# +Qa8a6+ +Qa8a7# +Qa8a7+ +Qa8b7# +Qa8b7+ +Qa8b8# +Qa8b8+ +Qa8c6# +Qa8c6+ +Qa8c8# +Qa8c8+ +Qa8d5# +Qa8d5+ +Qa8d8# +Qa8d8+ +Qa8e4# +Qa8e4+ +Qa8e8# +Qa8e8+ +Qa8f3# +Qa8f3+ +Qa8f8# +Qa8f8+ +Qa8g2# +Qa8g2+ +Qa8g8# +Qa8g8+ +Qa8h1# +Qa8h1+ +Qa8xa2 +Qa8xa3 +Qa8xa4 +Qa8xa5 +Qa8xa6 +Qa8xa7 +Qa8xb7 +Qa8xb8 +Qa8xc6 +Qa8xc8 +Qa8xd5 +Qa8xd8 +Qa8xe4 +Qa8xe8 +Qa8xf3 +Qa8xf8 +Qa8xg2 +Qa8xg8 +Qa8xh1 +Qaxa1# +Qaxa1+ +Qaxa2# +Qaxa2+ +Qaxa3# +Qaxa3+ +Qaxa4# +Qaxa4+ +Qaxa5# +Qaxa5+ +Qaxa6# +Qaxa6+ +Qaxa7# +Qaxa7+ +Qaxa8# +Qaxa8+ +Qaxb1# +Qaxb1+ +Qaxb2# +Qaxb2+ +Qaxb3# +Qaxb3+ +Qaxb4# +Qaxb4+ +Qaxb5# +Qaxb5+ +Qaxb6# +Qaxb6+ +Qaxb7# +Qaxb7+ +Qaxb8# +Qaxb8+ +Qaxc1# +Qaxc1+ +Qaxc2# +Qaxc2+ +Qaxc3# +Qaxc3+ +Qaxc4# +Qaxc4+ +Qaxc5# +Qaxc5+ +Qaxc6# +Qaxc6+ +Qaxc7# +Qaxc7+ +Qaxc8# +Qaxc8+ +Qaxd1# +Qaxd1+ +Qaxd2# +Qaxd2+ +Qaxd3# +Qaxd3+ +Qaxd4# +Qaxd4+ +Qaxd5# +Qaxd5+ +Qaxd6# +Qaxd6+ +Qaxd7# +Qaxd7+ +Qaxd8# +Qaxd8+ +Qaxe1# +Qaxe1+ +Qaxe2# +Qaxe2+ +Qaxe3# +Qaxe3+ +Qaxe4# +Qaxe4+ +Qaxe5# +Qaxe5+ +Qaxe6# +Qaxe6+ +Qaxe7# +Qaxe7+ +Qaxe8# +Qaxe8+ +Qaxf1# +Qaxf1+ +Qaxf2# +Qaxf2+ +Qaxf3# +Qaxf3+ +Qaxf4# +Qaxf4+ +Qaxf5# +Qaxf5+ +Qaxf6# +Qaxf6+ +Qaxf7# +Qaxf7+ +Qaxf8# +Qaxf8+ +Qaxg1# +Qaxg1+ +Qaxg2# +Qaxg2+ +Qaxg3# +Qaxg3+ +Qaxg4# +Qaxg4+ +Qaxg5# +Qaxg5+ +Qaxg6# +Qaxg6+ +Qaxg7# +Qaxg7+ +Qaxg8# +Qaxg8+ +Qaxh1# +Qaxh1+ +Qaxh2# +Qaxh2+ +Qaxh3# +Qaxh3+ +Qaxh4# +Qaxh4+ +Qaxh5# +Qaxh5+ +Qaxh6# +Qaxh6+ +Qaxh7# +Qaxh7+ +Qaxh8# +Qaxh8+ +Qb1a2# +Qb1a2+ +Qb1b2# +Qb1b2+ +Qb1b3# +Qb1b3+ +Qb1b4# +Qb1b4+ +Qb1b5# +Qb1b5+ +Qb1b6# +Qb1b6+ +Qb1b7# +Qb1b7+ +Qb1c1# +Qb1c1+ +Qb1c2# +Qb1c2+ +Qb1d1# +Qb1d1+ +Qb1d3# +Qb1d3+ +Qb1e1# +Qb1e1+ +Qb1e4# +Qb1e4+ +Qb1f1# +Qb1f1+ +Qb1f5# +Qb1f5+ +Qb1g1# +Qb1g1+ +Qb1g6# +Qb1g6+ +Qb1h7# +Qb1h7+ +Qb1xa2 +Qb1xb2 +Qb1xb3 +Qb1xb4 +Qb1xb5 +Qb1xb6 +Qb1xb7 +Qb1xc1 +Qb1xc2 +Qb1xd1 +Qb1xd3 +Qb1xe1 +Qb1xe4 +Qb1xf1 +Qb1xf5 +Qb1xg1 +Qb1xg6 +Qb1xh7 +Qb2a1# +Qb2a1+ +Qb2a3# +Qb2a3+ +Qb2b3# +Qb2b3+ +Qb2b4# +Qb2b4+ +Qb2b5# +Qb2b5+ +Qb2b6# +Qb2b6+ +Qb2b7# +Qb2b7+ +Qb2c1# +Qb2c1+ +Qb2c2# +Qb2c2+ +Qb2c3# +Qb2c3+ +Qb2d2# +Qb2d2+ +Qb2d4# +Qb2d4+ +Qb2e2# +Qb2e2+ +Qb2e5# +Qb2e5+ +Qb2f2# +Qb2f2+ +Qb2f6# +Qb2f6+ +Qb2g2# +Qb2g2+ +Qb2g7# +Qb2g7+ +Qb2h8# +Qb2h8+ +Qb2xa1 +Qb2xa3 +Qb2xb3 +Qb2xb4 +Qb2xb5 +Qb2xb6 +Qb2xb7 +Qb2xc1 +Qb2xc2 +Qb2xc3 +Qb2xd2 +Qb2xd4 +Qb2xe2 +Qb2xe5 +Qb2xf2 +Qb2xf6 +Qb2xg2 +Qb2xg7 +Qb2xh8 +Qb3a2# +Qb3a2+ +Qb3a4# +Qb3a4+ +Qb3b2# +Qb3b2+ +Qb3b4# +Qb3b4+ +Qb3b5# +Qb3b5+ +Qb3b6# +Qb3b6+ +Qb3b7# +Qb3b7+ +Qb3c2# +Qb3c2+ +Qb3c3# +Qb3c3+ +Qb3c4# +Qb3c4+ +Qb3d1# +Qb3d1+ +Qb3d3# +Qb3d3+ +Qb3d5# +Qb3d5+ +Qb3e3# +Qb3e3+ +Qb3e6# +Qb3e6+ +Qb3f3# +Qb3f3+ +Qb3f7# +Qb3f7+ +Qb3g3# +Qb3g3+ +Qb3g8# +Qb3g8+ +Qb3xa2 +Qb3xa4 +Qb3xb2 +Qb3xb4 +Qb3xb5 +Qb3xb6 +Qb3xb7 +Qb3xc2 +Qb3xc3 +Qb3xc4 +Qb3xd1 +Qb3xd3 +Qb3xd5 +Qb3xe3 +Qb3xe6 +Qb3xf3 +Qb3xf7 +Qb3xg3 +Qb3xg8 +Qb4a3# +Qb4a3+ +Qb4a5# +Qb4a5+ +Qb4b2# +Qb4b2+ +Qb4b3# +Qb4b3+ +Qb4b5# +Qb4b5+ +Qb4b6# +Qb4b6+ +Qb4b7# +Qb4b7+ +Qb4c3# +Qb4c3+ +Qb4c4# +Qb4c4+ +Qb4c5# +Qb4c5+ +Qb4d2# +Qb4d2+ +Qb4d4# +Qb4d4+ +Qb4d6# +Qb4d6+ +Qb4e1# +Qb4e1+ +Qb4e4# +Qb4e4+ +Qb4e7# +Qb4e7+ +Qb4f4# +Qb4f4+ +Qb4f8# +Qb4f8+ +Qb4xa3 +Qb4xa5 +Qb4xb2 +Qb4xb3 +Qb4xb5 +Qb4xb6 +Qb4xb7 +Qb4xc3 +Qb4xc4 +Qb4xc5 +Qb4xd2 +Qb4xd4 +Qb4xd6 +Qb4xe1 +Qb4xe4 +Qb4xe7 +Qb4xf4 +Qb4xf8 +Qb5a4# +Qb5a4+ +Qb5a6# +Qb5a6+ +Qb5b2# +Qb5b2+ +Qb5b3# +Qb5b3+ +Qb5b4# +Qb5b4+ +Qb5b6# +Qb5b6+ +Qb5b7# +Qb5b7+ +Qb5c4# +Qb5c4+ +Qb5c5# +Qb5c5+ +Qb5c6# +Qb5c6+ +Qb5d3# +Qb5d3+ +Qb5d5# +Qb5d5+ +Qb5d7# +Qb5d7+ +Qb5e2# +Qb5e2+ +Qb5e5# +Qb5e5+ +Qb5e8# +Qb5e8+ +Qb5f1# +Qb5f1+ +Qb5f5# +Qb5f5+ +Qb5xa4 +Qb5xa6 +Qb5xb2 +Qb5xb3 +Qb5xb4 +Qb5xb6 +Qb5xb7 +Qb5xc4 +Qb5xc5 +Qb5xc6 +Qb5xd3 +Qb5xd5 +Qb5xd7 +Qb5xe2 +Qb5xe5 +Qb5xe8 +Qb5xf1 +Qb5xf5 +Qb6a5# +Qb6a5+ +Qb6a7# +Qb6a7+ +Qb6b2# +Qb6b2+ +Qb6b3# +Qb6b3+ +Qb6b4# +Qb6b4+ +Qb6b5# +Qb6b5+ +Qb6b7# +Qb6b7+ +Qb6c5# +Qb6c5+ +Qb6c6# +Qb6c6+ +Qb6c7# +Qb6c7+ +Qb6d4# +Qb6d4+ +Qb6d6# +Qb6d6+ +Qb6d8# +Qb6d8+ +Qb6e3# +Qb6e3+ +Qb6e6# +Qb6e6+ +Qb6f2# +Qb6f2+ +Qb6f6# +Qb6f6+ +Qb6g1# +Qb6g1+ +Qb6g6# +Qb6g6+ +Qb6xa5 +Qb6xa7 +Qb6xb2 +Qb6xb3 +Qb6xb4 +Qb6xb5 +Qb6xb7 +Qb6xc5 +Qb6xc6 +Qb6xc7 +Qb6xd4 +Qb6xd6 +Qb6xd8 +Qb6xe3 +Qb6xe6 +Qb6xf2 +Qb6xf6 +Qb6xg1 +Qb6xg6 +Qb7a6# +Qb7a6+ +Qb7a8# +Qb7a8+ +Qb7b2# +Qb7b2+ +Qb7b3# +Qb7b3+ +Qb7b4# +Qb7b4+ +Qb7b5# +Qb7b5+ +Qb7b6# +Qb7b6+ +Qb7c6# +Qb7c6+ +Qb7c7# +Qb7c7+ +Qb7c8# +Qb7c8+ +Qb7d5# +Qb7d5+ +Qb7d7# +Qb7d7+ +Qb7e4# +Qb7e4+ +Qb7e7# +Qb7e7+ +Qb7f3# +Qb7f3+ +Qb7f7# +Qb7f7+ +Qb7g2# +Qb7g2+ +Qb7g7# +Qb7g7+ +Qb7h1# +Qb7h1+ +Qb7xa6 +Qb7xa8 +Qb7xb2 +Qb7xb3 +Qb7xb4 +Qb7xb5 +Qb7xb6 +Qb7xc6 +Qb7xc7 +Qb7xc8 +Qb7xd5 +Qb7xd7 +Qb7xe4 +Qb7xe7 +Qb7xf3 +Qb7xf7 +Qb7xg2 +Qb7xg7 +Qb7xh1 +Qb8a7# +Qb8a7+ +Qb8b2# +Qb8b2+ +Qb8b3# +Qb8b3+ +Qb8b4# +Qb8b4+ +Qb8b5# +Qb8b5+ +Qb8b6# +Qb8b6+ +Qb8b7# +Qb8b7+ +Qb8c7# +Qb8c7+ +Qb8c8# +Qb8c8+ +Qb8d6# +Qb8d6+ +Qb8d8# +Qb8d8+ +Qb8e5# +Qb8e5+ +Qb8e8# +Qb8e8+ +Qb8f4# +Qb8f4+ +Qb8f8# +Qb8f8+ +Qb8g3# +Qb8g3+ +Qb8g8# +Qb8g8+ +Qb8h2# +Qb8h2+ +Qb8xa7 +Qb8xb2 +Qb8xb3 +Qb8xb4 +Qb8xb5 +Qb8xb6 +Qb8xb7 +Qb8xc7 +Qb8xc8 +Qb8xd6 +Qb8xd8 +Qb8xe5 +Qb8xe8 +Qb8xf4 +Qb8xf8 +Qb8xg3 +Qb8xg8 +Qb8xh2 +Qbxa1# +Qbxa1+ +Qbxa2# +Qbxa2+ +Qbxa3# +Qbxa3+ +Qbxa4# +Qbxa4+ +Qbxa5# +Qbxa5+ +Qbxa6# +Qbxa6+ +Qbxa7# +Qbxa7+ +Qbxa8# +Qbxa8+ +Qbxb1# +Qbxb1+ +Qbxb2# +Qbxb2+ +Qbxb3# +Qbxb3+ +Qbxb4# +Qbxb4+ +Qbxb5# +Qbxb5+ +Qbxb6# +Qbxb6+ +Qbxb7# +Qbxb7+ +Qbxb8# +Qbxb8+ +Qbxc1# +Qbxc1+ +Qbxc2# +Qbxc2+ +Qbxc3# +Qbxc3+ +Qbxc4# +Qbxc4+ +Qbxc5# +Qbxc5+ +Qbxc6# +Qbxc6+ +Qbxc7# +Qbxc7+ +Qbxc8# +Qbxc8+ +Qbxd1# +Qbxd1+ +Qbxd2# +Qbxd2+ +Qbxd3# +Qbxd3+ +Qbxd4# +Qbxd4+ +Qbxd5# +Qbxd5+ +Qbxd6# +Qbxd6+ +Qbxd7# +Qbxd7+ +Qbxd8# +Qbxd8+ +Qbxe1# +Qbxe1+ +Qbxe2# +Qbxe2+ +Qbxe3# +Qbxe3+ +Qbxe4# +Qbxe4+ +Qbxe5# +Qbxe5+ +Qbxe6# +Qbxe6+ +Qbxe7# +Qbxe7+ +Qbxe8# +Qbxe8+ +Qbxf1# +Qbxf1+ +Qbxf2# +Qbxf2+ +Qbxf3# +Qbxf3+ +Qbxf4# +Qbxf4+ +Qbxf5# +Qbxf5+ +Qbxf6# +Qbxf6+ +Qbxf7# +Qbxf7+ +Qbxf8# +Qbxf8+ +Qbxg1# +Qbxg1+ +Qbxg2# +Qbxg2+ +Qbxg3# +Qbxg3+ +Qbxg4# +Qbxg4+ +Qbxg5# +Qbxg5+ +Qbxg6# +Qbxg6+ +Qbxg7# +Qbxg7+ +Qbxg8# +Qbxg8+ +Qbxh1# +Qbxh1+ +Qbxh2# +Qbxh2+ +Qbxh3# +Qbxh3+ +Qbxh4# +Qbxh4+ +Qbxh5# +Qbxh5+ +Qbxh6# +Qbxh6+ +Qbxh7# +Qbxh7+ +Qbxh8# +Qbxh8+ +Qc1a3# +Qc1a3+ +Qc1b1# +Qc1b1+ +Qc1b2# +Qc1b2+ +Qc1c2# +Qc1c2+ +Qc1c3# +Qc1c3+ +Qc1c4# +Qc1c4+ +Qc1c5# +Qc1c5+ +Qc1c6# +Qc1c6+ +Qc1d1# +Qc1d1+ +Qc1d2# +Qc1d2+ +Qc1e1# +Qc1e1+ +Qc1e3# +Qc1e3+ +Qc1f1# +Qc1f1+ +Qc1f4# +Qc1f4+ +Qc1g1# +Qc1g1+ +Qc1g5# +Qc1g5+ +Qc1h6# +Qc1h6+ +Qc1xa3 +Qc1xb1 +Qc1xb2 +Qc1xc2 +Qc1xc3 +Qc1xc4 +Qc1xc5 +Qc1xc6 +Qc1xd1 +Qc1xd2 +Qc1xe1 +Qc1xe3 +Qc1xf1 +Qc1xf4 +Qc1xg1 +Qc1xg5 +Qc1xh6 +Qc2a4# +Qc2a4+ +Qc2b1# +Qc2b1+ +Qc2b2# +Qc2b2+ +Qc2b3# +Qc2b3+ +Qc2c3# +Qc2c3+ +Qc2c4# +Qc2c4+ +Qc2c5# +Qc2c5+ +Qc2c6# +Qc2c6+ +Qc2c7# +Qc2c7+ +Qc2d1# +Qc2d1+ +Qc2d2# +Qc2d2+ +Qc2d3# +Qc2d3+ +Qc2e2# +Qc2e2+ +Qc2e4# +Qc2e4+ +Qc2f2# +Qc2f2+ +Qc2f5# +Qc2f5+ +Qc2g2# +Qc2g2+ +Qc2g6# +Qc2g6+ +Qc2h7# +Qc2h7+ +Qc2xa4 +Qc2xb1 +Qc2xb2 +Qc2xb3 +Qc2xc3 +Qc2xc4 +Qc2xc5 +Qc2xc6 +Qc2xc7 +Qc2xd1 +Qc2xd2 +Qc2xd3 +Qc2xe2 +Qc2xe4 +Qc2xf2 +Qc2xf5 +Qc2xg2 +Qc2xg6 +Qc2xh7 +Qc3a1# +Qc3a1+ +Qc3a5# +Qc3a5+ +Qc3b2# +Qc3b2+ +Qc3b3# +Qc3b3+ +Qc3b4# +Qc3b4+ +Qc3c2# +Qc3c2+ +Qc3c4# +Qc3c4+ +Qc3c5# +Qc3c5+ +Qc3c6# +Qc3c6+ +Qc3c7# +Qc3c7+ +Qc3d2# +Qc3d2+ +Qc3d3# +Qc3d3+ +Qc3d4# +Qc3d4+ +Qc3e1# +Qc3e1+ +Qc3e3# +Qc3e3+ +Qc3e5# +Qc3e5+ +Qc3f3# +Qc3f3+ +Qc3f6# +Qc3f6+ +Qc3g3# +Qc3g3+ +Qc3g7# +Qc3g7+ +Qc3h8# +Qc3h8+ +Qc3xa1 +Qc3xa5 +Qc3xb2 +Qc3xb3 +Qc3xb4 +Qc3xc2 +Qc3xc4 +Qc3xc5 +Qc3xc6 +Qc3xc7 +Qc3xd2 +Qc3xd3 +Qc3xd4 +Qc3xe1 +Qc3xe3 +Qc3xe5 +Qc3xf3 +Qc3xf6 +Qc3xg3 +Qc3xg7 +Qc3xh8 +Qc4a2# +Qc4a2+ +Qc4a6# +Qc4a6+ +Qc4b3# +Qc4b3+ +Qc4b4# +Qc4b4+ +Qc4b5# +Qc4b5+ +Qc4c2# +Qc4c2+ +Qc4c3# +Qc4c3+ +Qc4c5# +Qc4c5+ +Qc4c6# +Qc4c6+ +Qc4c7# +Qc4c7+ +Qc4d3# +Qc4d3+ +Qc4d4# +Qc4d4+ +Qc4d5# +Qc4d5+ +Qc4e2# +Qc4e2+ +Qc4e4# +Qc4e4+ +Qc4e6# +Qc4e6+ +Qc4f1# +Qc4f1+ +Qc4f4# +Qc4f4+ +Qc4f7# +Qc4f7+ +Qc4g4# +Qc4g4+ +Qc4g8# +Qc4g8+ +Qc4xa2 +Qc4xa6 +Qc4xb3 +Qc4xb4 +Qc4xb5 +Qc4xc2 +Qc4xc3 +Qc4xc5 +Qc4xc6 +Qc4xc7 +Qc4xd3 +Qc4xd4 +Qc4xd5 +Qc4xe2 +Qc4xe4 +Qc4xe6 +Qc4xf1 +Qc4xf4 +Qc4xf7 +Qc4xg4 +Qc4xg8 +Qc5a3# +Qc5a3+ +Qc5a7# +Qc5a7+ +Qc5b4# +Qc5b4+ +Qc5b5# +Qc5b5+ +Qc5b6# +Qc5b6+ +Qc5c2# +Qc5c2+ +Qc5c3# +Qc5c3+ +Qc5c4# +Qc5c4+ +Qc5c6# +Qc5c6+ +Qc5c7# +Qc5c7+ +Qc5d4# +Qc5d4+ +Qc5d5# +Qc5d5+ +Qc5d6# +Qc5d6+ +Qc5e3# +Qc5e3+ +Qc5e5# +Qc5e5+ +Qc5e7# +Qc5e7+ +Qc5f2# +Qc5f2+ +Qc5f5# +Qc5f5+ +Qc5f8# +Qc5f8+ +Qc5g1# +Qc5g1+ +Qc5g5# +Qc5g5+ +Qc5xa3 +Qc5xa7 +Qc5xb4 +Qc5xb5 +Qc5xb6 +Qc5xc2 +Qc5xc3 +Qc5xc4 +Qc5xc6 +Qc5xc7 +Qc5xd4 +Qc5xd5 +Qc5xd6 +Qc5xe3 +Qc5xe5 +Qc5xe7 +Qc5xf2 +Qc5xf5 +Qc5xf8 +Qc5xg1 +Qc5xg5 +Qc6a4# +Qc6a4+ +Qc6a8# +Qc6a8+ +Qc6b5# +Qc6b5+ +Qc6b6# +Qc6b6+ +Qc6b7# +Qc6b7+ +Qc6c2# +Qc6c2+ +Qc6c3# +Qc6c3+ +Qc6c4# +Qc6c4+ +Qc6c5# +Qc6c5+ +Qc6c7# +Qc6c7+ +Qc6d5# +Qc6d5+ +Qc6d6# +Qc6d6+ +Qc6d7# +Qc6d7+ +Qc6e4# +Qc6e4+ +Qc6e6# +Qc6e6+ +Qc6e8# +Qc6e8+ +Qc6f3# +Qc6f3+ +Qc6f6# +Qc6f6+ +Qc6g2# +Qc6g2+ +Qc6g6# +Qc6g6+ +Qc6h1# +Qc6h1+ +Qc6xa4 +Qc6xa8 +Qc6xb5 +Qc6xb6 +Qc6xb7 +Qc6xc2 +Qc6xc3 +Qc6xc4 +Qc6xc5 +Qc6xc7 +Qc6xd5 +Qc6xd6 +Qc6xd7 +Qc6xe4 +Qc6xe6 +Qc6xe8 +Qc6xf3 +Qc6xf6 +Qc6xg2 +Qc6xg6 +Qc6xh1 +Qc7a5# +Qc7a5+ +Qc7b6# +Qc7b6+ +Qc7b7# +Qc7b7+ +Qc7b8# +Qc7b8+ +Qc7c2# +Qc7c2+ +Qc7c3# +Qc7c3+ +Qc7c4# +Qc7c4+ +Qc7c5# +Qc7c5+ +Qc7c6# +Qc7c6+ +Qc7d6# +Qc7d6+ +Qc7d7# +Qc7d7+ +Qc7d8# +Qc7d8+ +Qc7e5# +Qc7e5+ +Qc7e7# +Qc7e7+ +Qc7f4# +Qc7f4+ +Qc7f7# +Qc7f7+ +Qc7g3# +Qc7g3+ +Qc7g7# +Qc7g7+ +Qc7h2# +Qc7h2+ +Qc7xa5 +Qc7xb6 +Qc7xb7 +Qc7xb8 +Qc7xc2 +Qc7xc3 +Qc7xc4 +Qc7xc5 +Qc7xc6 +Qc7xd6 +Qc7xd7 +Qc7xd8 +Qc7xe5 +Qc7xe7 +Qc7xf4 +Qc7xf7 +Qc7xg3 +Qc7xg7 +Qc7xh2 +Qc8a6# +Qc8a6+ +Qc8b7# +Qc8b7+ +Qc8b8# +Qc8b8+ +Qc8c3# +Qc8c3+ +Qc8c4# +Qc8c4+ +Qc8c5# +Qc8c5+ +Qc8c6# +Qc8c6+ +Qc8c7# +Qc8c7+ +Qc8d7# +Qc8d7+ +Qc8d8# +Qc8d8+ +Qc8e6# +Qc8e6+ +Qc8e8# +Qc8e8+ +Qc8f5# +Qc8f5+ +Qc8f8# +Qc8f8+ +Qc8g4# +Qc8g4+ +Qc8g8# +Qc8g8+ +Qc8h3# +Qc8h3+ +Qc8xa6 +Qc8xb7 +Qc8xb8 +Qc8xc3 +Qc8xc4 +Qc8xc5 +Qc8xc6 +Qc8xc7 +Qc8xd7 +Qc8xd8 +Qc8xe6 +Qc8xe8 +Qc8xf5 +Qc8xf8 +Qc8xg4 +Qc8xg8 +Qc8xh3 +Qcxa1# +Qcxa1+ +Qcxa2# +Qcxa2+ +Qcxa3# +Qcxa3+ +Qcxa4# +Qcxa4+ +Qcxa5# +Qcxa5+ +Qcxa6# +Qcxa6+ +Qcxa7# +Qcxa7+ +Qcxa8# +Qcxa8+ +Qcxb1# +Qcxb1+ +Qcxb2# +Qcxb2+ +Qcxb3# +Qcxb3+ +Qcxb4# +Qcxb4+ +Qcxb5# +Qcxb5+ +Qcxb6# +Qcxb6+ +Qcxb7# +Qcxb7+ +Qcxb8# +Qcxb8+ +Qcxc1# +Qcxc1+ +Qcxc2# +Qcxc2+ +Qcxc3# +Qcxc3+ +Qcxc4# +Qcxc4+ +Qcxc5# +Qcxc5+ +Qcxc6# +Qcxc6+ +Qcxc7# +Qcxc7+ +Qcxc8# +Qcxc8+ +Qcxd1# +Qcxd1+ +Qcxd2# +Qcxd2+ +Qcxd3# +Qcxd3+ +Qcxd4# +Qcxd4+ +Qcxd5# +Qcxd5+ +Qcxd6# +Qcxd6+ +Qcxd7# +Qcxd7+ +Qcxd8# +Qcxd8+ +Qcxe1# +Qcxe1+ +Qcxe2# +Qcxe2+ +Qcxe3# +Qcxe3+ +Qcxe4# +Qcxe4+ +Qcxe5# +Qcxe5+ +Qcxe6# +Qcxe6+ +Qcxe7# +Qcxe7+ +Qcxe8# +Qcxe8+ +Qcxf1# +Qcxf1+ +Qcxf2# +Qcxf2+ +Qcxf3# +Qcxf3+ +Qcxf4# +Qcxf4+ +Qcxf5# +Qcxf5+ +Qcxf6# +Qcxf6+ +Qcxf7# +Qcxf7+ +Qcxf8# +Qcxf8+ +Qcxg1# +Qcxg1+ +Qcxg2# +Qcxg2+ +Qcxg3# +Qcxg3+ +Qcxg4# +Qcxg4+ +Qcxg5# +Qcxg5+ +Qcxg6# +Qcxg6+ +Qcxg7# +Qcxg7+ +Qcxg8# +Qcxg8+ +Qcxh1# +Qcxh1+ +Qcxh2# +Qcxh2+ +Qcxh3# +Qcxh3+ +Qcxh4# +Qcxh4+ +Qcxh5# +Qcxh5+ +Qcxh6# +Qcxh6+ +Qcxh7# +Qcxh7+ +Qcxh8# +Qcxh8+ +Qd1a4# +Qd1a4+ +Qd1b1# +Qd1b1+ +Qd1b3# +Qd1b3+ +Qd1c1# +Qd1c1+ +Qd1c2# +Qd1c2+ +Qd1d2# +Qd1d2+ +Qd1d3# +Qd1d3+ +Qd1d4# +Qd1d4+ +Qd1d5# +Qd1d5+ +Qd1e1# +Qd1e1+ +Qd1e2# +Qd1e2+ +Qd1f1# +Qd1f1+ +Qd1f3# +Qd1f3+ +Qd1g1# +Qd1g1+ +Qd1g4# +Qd1g4+ +Qd1h5# +Qd1h5+ +Qd1xa4 +Qd1xb1 +Qd1xb3 +Qd1xc1 +Qd1xc2 +Qd1xd2 +Qd1xd3 +Qd1xd4 +Qd1xd5 +Qd1xe1 +Qd1xe2 +Qd1xf1 +Qd1xf3 +Qd1xg1 +Qd1xg4 +Qd1xh5 +Qd2a5# +Qd2a5+ +Qd2b2# +Qd2b2+ +Qd2b4# +Qd2b4+ +Qd2c1# +Qd2c1+ +Qd2c2# +Qd2c2+ +Qd2c3# +Qd2c3+ +Qd2d3# +Qd2d3+ +Qd2d4# +Qd2d4+ +Qd2d5# +Qd2d5+ +Qd2d6# +Qd2d6+ +Qd2e1# +Qd2e1+ +Qd2e2# +Qd2e2+ +Qd2e3# +Qd2e3+ +Qd2f2# +Qd2f2+ +Qd2f4# +Qd2f4+ +Qd2g2# +Qd2g2+ +Qd2g5# +Qd2g5+ +Qd2h6# +Qd2h6+ +Qd2xa5 +Qd2xb2 +Qd2xb4 +Qd2xc1 +Qd2xc2 +Qd2xc3 +Qd2xd3 +Qd2xd4 +Qd2xd5 +Qd2xd6 +Qd2xe1 +Qd2xe2 +Qd2xe3 +Qd2xf2 +Qd2xf4 +Qd2xg2 +Qd2xg5 +Qd2xh6 +Qd3a6# +Qd3a6+ +Qd3b1# +Qd3b1+ +Qd3b3# +Qd3b3+ +Qd3b5# +Qd3b5+ +Qd3c2# +Qd3c2+ +Qd3c3# +Qd3c3+ +Qd3c4# +Qd3c4+ +Qd3d2# +Qd3d2+ +Qd3d4# +Qd3d4+ +Qd3d5# +Qd3d5+ +Qd3d6# +Qd3d6+ +Qd3d7# +Qd3d7+ +Qd3e2# +Qd3e2+ +Qd3e3# +Qd3e3+ +Qd3e4# +Qd3e4+ +Qd3f1# +Qd3f1+ +Qd3f3# +Qd3f3+ +Qd3f5# +Qd3f5+ +Qd3g3# +Qd3g3+ +Qd3g6# +Qd3g6+ +Qd3h7# +Qd3h7+ +Qd3xa6 +Qd3xb1 +Qd3xb3 +Qd3xb5 +Qd3xc2 +Qd3xc3 +Qd3xc4 +Qd3xd2 +Qd3xd4 +Qd3xd5 +Qd3xd6 +Qd3xd7 +Qd3xe2 +Qd3xe3 +Qd3xe4 +Qd3xf1 +Qd3xf3 +Qd3xf5 +Qd3xg3 +Qd3xg6 +Qd3xh7 +Qd4a1# +Qd4a1+ +Qd4a7# +Qd4a7+ +Qd4b2# +Qd4b2+ +Qd4b4# +Qd4b4+ +Qd4b6# +Qd4b6+ +Qd4c3# +Qd4c3+ +Qd4c4# +Qd4c4+ +Qd4c5# +Qd4c5+ +Qd4d2# +Qd4d2+ +Qd4d3# +Qd4d3+ +Qd4d5# +Qd4d5+ +Qd4d6# +Qd4d6+ +Qd4d7# +Qd4d7+ +Qd4e3# +Qd4e3+ +Qd4e4# +Qd4e4+ +Qd4e5# +Qd4e5+ +Qd4f2# +Qd4f2+ +Qd4f4# +Qd4f4+ +Qd4f6# +Qd4f6+ +Qd4g1# +Qd4g1+ +Qd4g4# +Qd4g4+ +Qd4g7# +Qd4g7+ +Qd4h8# +Qd4h8+ +Qd4xa1 +Qd4xa7 +Qd4xb2 +Qd4xb4 +Qd4xb6 +Qd4xc3 +Qd4xc4 +Qd4xc5 +Qd4xd2 +Qd4xd3 +Qd4xd5 +Qd4xd6 +Qd4xd7 +Qd4xe3 +Qd4xe4 +Qd4xe5 +Qd4xf2 +Qd4xf4 +Qd4xf6 +Qd4xg1 +Qd4xg4 +Qd4xg7 +Qd4xh8 +Qd5a2# +Qd5a2+ +Qd5a8# +Qd5a8+ +Qd5b3# +Qd5b3+ +Qd5b5# +Qd5b5+ +Qd5b7# +Qd5b7+ +Qd5c4# +Qd5c4+ +Qd5c5# +Qd5c5+ +Qd5c6# +Qd5c6+ +Qd5d2# +Qd5d2+ +Qd5d3# +Qd5d3+ +Qd5d4# +Qd5d4+ +Qd5d6# +Qd5d6+ +Qd5d7# +Qd5d7+ +Qd5e4# +Qd5e4+ +Qd5e5# +Qd5e5+ +Qd5e6# +Qd5e6+ +Qd5f3# +Qd5f3+ +Qd5f5# +Qd5f5+ +Qd5f7# +Qd5f7+ +Qd5g2# +Qd5g2+ +Qd5g5# +Qd5g5+ +Qd5g8# +Qd5g8+ +Qd5h1# +Qd5h1+ +Qd5xa2 +Qd5xa8 +Qd5xb3 +Qd5xb5 +Qd5xb7 +Qd5xc4 +Qd5xc5 +Qd5xc6 +Qd5xd2 +Qd5xd3 +Qd5xd4 +Qd5xd6 +Qd5xd7 +Qd5xe4 +Qd5xe5 +Qd5xe6 +Qd5xf3 +Qd5xf5 +Qd5xf7 +Qd5xg2 +Qd5xg5 +Qd5xg8 +Qd5xh1 +Qd6a3# +Qd6a3+ +Qd6b4# +Qd6b4+ +Qd6b6# +Qd6b6+ +Qd6b8# +Qd6b8+ +Qd6c5# +Qd6c5+ +Qd6c6# +Qd6c6+ +Qd6c7# +Qd6c7+ +Qd6d2# +Qd6d2+ +Qd6d3# +Qd6d3+ +Qd6d4# +Qd6d4+ +Qd6d5# +Qd6d5+ +Qd6d7# +Qd6d7+ +Qd6e5# +Qd6e5+ +Qd6e6# +Qd6e6+ +Qd6e7# +Qd6e7+ +Qd6f4# +Qd6f4+ +Qd6f6# +Qd6f6+ +Qd6f8# +Qd6f8+ +Qd6g3# +Qd6g3+ +Qd6g6# +Qd6g6+ +Qd6h2# +Qd6h2+ +Qd6xa3 +Qd6xb4 +Qd6xb6 +Qd6xb8 +Qd6xc5 +Qd6xc6 +Qd6xc7 +Qd6xd2 +Qd6xd3 +Qd6xd4 +Qd6xd5 +Qd6xd7 +Qd6xe5 +Qd6xe6 +Qd6xe7 +Qd6xf4 +Qd6xf6 +Qd6xf8 +Qd6xg3 +Qd6xg6 +Qd6xh2 +Qd7a4# +Qd7a4+ +Qd7b5# +Qd7b5+ +Qd7b7# +Qd7b7+ +Qd7c6# +Qd7c6+ +Qd7c7# +Qd7c7+ +Qd7c8# +Qd7c8+ +Qd7d3# +Qd7d3+ +Qd7d4# +Qd7d4+ +Qd7d5# +Qd7d5+ +Qd7d6# +Qd7d6+ +Qd7e6# +Qd7e6+ +Qd7e7# +Qd7e7+ +Qd7e8# +Qd7e8+ +Qd7f5# +Qd7f5+ +Qd7f7# +Qd7f7+ +Qd7g4# +Qd7g4+ +Qd7g7# +Qd7g7+ +Qd7h3# +Qd7h3+ +Qd7xa4 +Qd7xb5 +Qd7xb7 +Qd7xc6 +Qd7xc7 +Qd7xc8 +Qd7xd3 +Qd7xd4 +Qd7xd5 +Qd7xd6 +Qd7xe6 +Qd7xe7 +Qd7xe8 +Qd7xf5 +Qd7xf7 +Qd7xg4 +Qd7xg7 +Qd7xh3 +Qd8a5# +Qd8a5+ +Qd8b6# +Qd8b6+ +Qd8b8# +Qd8b8+ +Qd8c7# +Qd8c7+ +Qd8c8# +Qd8c8+ +Qd8d4# +Qd8d4+ +Qd8d5# +Qd8d5+ +Qd8d6# +Qd8d6+ +Qd8d7# +Qd8d7+ +Qd8e7# +Qd8e7+ +Qd8e8# +Qd8e8+ +Qd8f6# +Qd8f6+ +Qd8f8# +Qd8f8+ +Qd8g5# +Qd8g5+ +Qd8g8# +Qd8g8+ +Qd8h4# +Qd8h4+ +Qd8xa5 +Qd8xb6 +Qd8xb8 +Qd8xc7 +Qd8xc8 +Qd8xd4 +Qd8xd5 +Qd8xd6 +Qd8xd7 +Qd8xe7 +Qd8xe8 +Qd8xf6 +Qd8xf8 +Qd8xg5 +Qd8xg8 +Qd8xh4 +Qdxa1# +Qdxa1+ +Qdxa2# +Qdxa2+ +Qdxa3# +Qdxa3+ +Qdxa4# +Qdxa4+ +Qdxa5# +Qdxa5+ +Qdxa6# +Qdxa6+ +Qdxa7# +Qdxa7+ +Qdxa8# +Qdxa8+ +Qdxb1# +Qdxb1+ +Qdxb2# +Qdxb2+ +Qdxb3# +Qdxb3+ +Qdxb4# +Qdxb4+ +Qdxb5# +Qdxb5+ +Qdxb6# +Qdxb6+ +Qdxb7# +Qdxb7+ +Qdxb8# +Qdxb8+ +Qdxc1# +Qdxc1+ +Qdxc2# +Qdxc2+ +Qdxc3# +Qdxc3+ +Qdxc4# +Qdxc4+ +Qdxc5# +Qdxc5+ +Qdxc6# +Qdxc6+ +Qdxc7# +Qdxc7+ +Qdxc8# +Qdxc8+ +Qdxd1# +Qdxd1+ +Qdxd2# +Qdxd2+ +Qdxd3# +Qdxd3+ +Qdxd4# +Qdxd4+ +Qdxd5# +Qdxd5+ +Qdxd6# +Qdxd6+ +Qdxd7# +Qdxd7+ +Qdxd8# +Qdxd8+ +Qdxe1# +Qdxe1+ +Qdxe2# +Qdxe2+ +Qdxe3# +Qdxe3+ +Qdxe4# +Qdxe4+ +Qdxe5# +Qdxe5+ +Qdxe6# +Qdxe6+ +Qdxe7# +Qdxe7+ +Qdxe8# +Qdxe8+ +Qdxf1# +Qdxf1+ +Qdxf2# +Qdxf2+ +Qdxf3# +Qdxf3+ +Qdxf4# +Qdxf4+ +Qdxf5# +Qdxf5+ +Qdxf6# +Qdxf6+ +Qdxf7# +Qdxf7+ +Qdxf8# +Qdxf8+ +Qdxg1# +Qdxg1+ +Qdxg2# +Qdxg2+ +Qdxg3# +Qdxg3+ +Qdxg4# +Qdxg4+ +Qdxg5# +Qdxg5+ +Qdxg6# +Qdxg6+ +Qdxg7# +Qdxg7+ +Qdxg8# +Qdxg8+ +Qdxh1# +Qdxh1+ +Qdxh2# +Qdxh2+ +Qdxh3# +Qdxh3+ +Qdxh4# +Qdxh4+ +Qdxh5# +Qdxh5+ +Qdxh6# +Qdxh6+ +Qdxh7# +Qdxh7+ +Qdxh8# +Qdxh8+ +Qe1a5# +Qe1a5+ +Qe1b1# +Qe1b1+ +Qe1b4# +Qe1b4+ +Qe1c1# +Qe1c1+ +Qe1c3# +Qe1c3+ +Qe1d1# +Qe1d1+ +Qe1d2# +Qe1d2+ +Qe1e2# +Qe1e2+ +Qe1e3# +Qe1e3+ +Qe1e4# +Qe1e4+ +Qe1e5# +Qe1e5+ +Qe1f1# +Qe1f1+ +Qe1f2# +Qe1f2+ +Qe1g1# +Qe1g1+ +Qe1g3# +Qe1g3+ +Qe1h4# +Qe1h4+ +Qe1xa5 +Qe1xb1 +Qe1xb4 +Qe1xc1 +Qe1xc3 +Qe1xd1 +Qe1xd2 +Qe1xe2 +Qe1xe3 +Qe1xe4 +Qe1xe5 +Qe1xf1 +Qe1xf2 +Qe1xg1 +Qe1xg3 +Qe1xh4 +Qe2a6# +Qe2a6+ +Qe2b2# +Qe2b2+ +Qe2b5# +Qe2b5+ +Qe2c2# +Qe2c2+ +Qe2c4# +Qe2c4+ +Qe2d1# +Qe2d1+ +Qe2d2# +Qe2d2+ +Qe2d3# +Qe2d3+ +Qe2e3# +Qe2e3+ +Qe2e4# +Qe2e4+ +Qe2e5# +Qe2e5+ +Qe2e6# +Qe2e6+ +Qe2f1# +Qe2f1+ +Qe2f2# +Qe2f2+ +Qe2f3# +Qe2f3+ +Qe2g2# +Qe2g2+ +Qe2g4# +Qe2g4+ +Qe2h5# +Qe2h5+ +Qe2xa6 +Qe2xb2 +Qe2xb5 +Qe2xc2 +Qe2xc4 +Qe2xd1 +Qe2xd2 +Qe2xd3 +Qe2xe3 +Qe2xe4 +Qe2xe5 +Qe2xe6 +Qe2xf1 +Qe2xf2 +Qe2xf3 +Qe2xg2 +Qe2xg4 +Qe2xh5 +Qe3a7# +Qe3a7+ +Qe3b3# +Qe3b3+ +Qe3b6# +Qe3b6+ +Qe3c1# +Qe3c1+ +Qe3c3# +Qe3c3+ +Qe3c5# +Qe3c5+ +Qe3d2# +Qe3d2+ +Qe3d3# +Qe3d3+ +Qe3d4# +Qe3d4+ +Qe3e2# +Qe3e2+ +Qe3e4# +Qe3e4+ +Qe3e5# +Qe3e5+ +Qe3e6# +Qe3e6+ +Qe3e7# +Qe3e7+ +Qe3f2# +Qe3f2+ +Qe3f3# +Qe3f3+ +Qe3f4# +Qe3f4+ +Qe3g1# +Qe3g1+ +Qe3g3# +Qe3g3+ +Qe3g5# +Qe3g5+ +Qe3h6# +Qe3h6+ +Qe3xa7 +Qe3xb3 +Qe3xb6 +Qe3xc1 +Qe3xc3 +Qe3xc5 +Qe3xd2 +Qe3xd3 +Qe3xd4 +Qe3xe2 +Qe3xe4 +Qe3xe5 +Qe3xe6 +Qe3xe7 +Qe3xf2 +Qe3xf3 +Qe3xf4 +Qe3xg1 +Qe3xg3 +Qe3xg5 +Qe3xh6 +Qe4a8# +Qe4a8+ +Qe4b1# +Qe4b1+ +Qe4b4# +Qe4b4+ +Qe4b7# +Qe4b7+ +Qe4c2# +Qe4c2+ +Qe4c4# +Qe4c4+ +Qe4c6# +Qe4c6+ +Qe4d3# +Qe4d3+ +Qe4d4# +Qe4d4+ +Qe4d5# +Qe4d5+ +Qe4e2# +Qe4e2+ +Qe4e3# +Qe4e3+ +Qe4e5# +Qe4e5+ +Qe4e6# +Qe4e6+ +Qe4e7# +Qe4e7+ +Qe4f3# +Qe4f3+ +Qe4f4# +Qe4f4+ +Qe4f5# +Qe4f5+ +Qe4g2# +Qe4g2+ +Qe4g4# +Qe4g4+ +Qe4g6# +Qe4g6+ +Qe4h1# +Qe4h1+ +Qe4h7# +Qe4h7+ +Qe4xa8 +Qe4xb1 +Qe4xb4 +Qe4xb7 +Qe4xc2 +Qe4xc4 +Qe4xc6 +Qe4xd3 +Qe4xd4 +Qe4xd5 +Qe4xe2 +Qe4xe3 +Qe4xe5 +Qe4xe6 +Qe4xe7 +Qe4xf3 +Qe4xf4 +Qe4xf5 +Qe4xg2 +Qe4xg4 +Qe4xg6 +Qe4xh1 +Qe4xh7 +Qe5a1# +Qe5a1+ +Qe5b2# +Qe5b2+ +Qe5b5# +Qe5b5+ +Qe5b8# +Qe5b8+ +Qe5c3# +Qe5c3+ +Qe5c5# +Qe5c5+ +Qe5c7# +Qe5c7+ +Qe5d4# +Qe5d4+ +Qe5d5# +Qe5d5+ +Qe5d6# +Qe5d6+ +Qe5e2# +Qe5e2+ +Qe5e3# +Qe5e3+ +Qe5e4# +Qe5e4+ +Qe5e6# +Qe5e6+ +Qe5e7# +Qe5e7+ +Qe5f4# +Qe5f4+ +Qe5f5# +Qe5f5+ +Qe5f6# +Qe5f6+ +Qe5g3# +Qe5g3+ +Qe5g5# +Qe5g5+ +Qe5g7# +Qe5g7+ +Qe5h2# +Qe5h2+ +Qe5h8# +Qe5h8+ +Qe5xa1 +Qe5xb2 +Qe5xb5 +Qe5xb8 +Qe5xc3 +Qe5xc5 +Qe5xc7 +Qe5xd4 +Qe5xd5 +Qe5xd6 +Qe5xe2 +Qe5xe3 +Qe5xe4 +Qe5xe6 +Qe5xe7 +Qe5xf4 +Qe5xf5 +Qe5xf6 +Qe5xg3 +Qe5xg5 +Qe5xg7 +Qe5xh2 +Qe5xh8 +Qe6a2# +Qe6a2+ +Qe6b3# +Qe6b3+ +Qe6b6# +Qe6b6+ +Qe6c4# +Qe6c4+ +Qe6c6# +Qe6c6+ +Qe6c8# +Qe6c8+ +Qe6d5# +Qe6d5+ +Qe6d6# +Qe6d6+ +Qe6d7# +Qe6d7+ +Qe6e2# +Qe6e2+ +Qe6e3# +Qe6e3+ +Qe6e4# +Qe6e4+ +Qe6e5# +Qe6e5+ +Qe6e7# +Qe6e7+ +Qe6f5# +Qe6f5+ +Qe6f6# +Qe6f6+ +Qe6f7# +Qe6f7+ +Qe6g4# +Qe6g4+ +Qe6g6# +Qe6g6+ +Qe6g8# +Qe6g8+ +Qe6h3# +Qe6h3+ +Qe6xa2 +Qe6xb3 +Qe6xb6 +Qe6xc4 +Qe6xc6 +Qe6xc8 +Qe6xd5 +Qe6xd6 +Qe6xd7 +Qe6xe2 +Qe6xe3 +Qe6xe4 +Qe6xe5 +Qe6xe7 +Qe6xf5 +Qe6xf6 +Qe6xf7 +Qe6xg4 +Qe6xg6 +Qe6xg8 +Qe6xh3 +Qe7a3# +Qe7a3+ +Qe7b4# +Qe7b4+ +Qe7b7# +Qe7b7+ +Qe7c5# +Qe7c5+ +Qe7c7# +Qe7c7+ +Qe7d6# +Qe7d6+ +Qe7d7# +Qe7d7+ +Qe7d8# +Qe7d8+ +Qe7e3# +Qe7e3+ +Qe7e4# +Qe7e4+ +Qe7e5# +Qe7e5+ +Qe7e6# +Qe7e6+ +Qe7f6# +Qe7f6+ +Qe7f7# +Qe7f7+ +Qe7f8# +Qe7f8+ +Qe7g5# +Qe7g5+ +Qe7g7# +Qe7g7+ +Qe7h4# +Qe7h4+ +Qe7xa3 +Qe7xb4 +Qe7xb7 +Qe7xc5 +Qe7xc7 +Qe7xd6 +Qe7xd7 +Qe7xd8 +Qe7xe3 +Qe7xe4 +Qe7xe5 +Qe7xe6 +Qe7xf6 +Qe7xf7 +Qe7xf8 +Qe7xg5 +Qe7xg7 +Qe7xh4 +Qe8a4# +Qe8a4+ +Qe8b5# +Qe8b5+ +Qe8b8# +Qe8b8+ +Qe8c6# +Qe8c6+ +Qe8c8# +Qe8c8+ +Qe8d7# +Qe8d7+ +Qe8d8# +Qe8d8+ +Qe8e4# +Qe8e4+ +Qe8e5# +Qe8e5+ +Qe8e6# +Qe8e6+ +Qe8e7# +Qe8e7+ +Qe8f7# +Qe8f7+ +Qe8f8# +Qe8f8+ +Qe8g6# +Qe8g6+ +Qe8g8# +Qe8g8+ +Qe8h5# +Qe8h5+ +Qe8xa4 +Qe8xb5 +Qe8xb8 +Qe8xc6 +Qe8xc8 +Qe8xd7 +Qe8xd8 +Qe8xe4 +Qe8xe5 +Qe8xe6 +Qe8xe7 +Qe8xf7 +Qe8xf8 +Qe8xg6 +Qe8xg8 +Qe8xh5 +Qexa1# +Qexa1+ +Qexa2# +Qexa2+ +Qexa3# +Qexa3+ +Qexa4# +Qexa4+ +Qexa5# +Qexa5+ +Qexa6# +Qexa6+ +Qexa7# +Qexa7+ +Qexa8# +Qexa8+ +Qexb1# +Qexb1+ +Qexb2# +Qexb2+ +Qexb3# +Qexb3+ +Qexb4# +Qexb4+ +Qexb5# +Qexb5+ +Qexb6# +Qexb6+ +Qexb7# +Qexb7+ +Qexb8# +Qexb8+ +Qexc1# +Qexc1+ +Qexc2# +Qexc2+ +Qexc3# +Qexc3+ +Qexc4# +Qexc4+ +Qexc5# +Qexc5+ +Qexc6# +Qexc6+ +Qexc7# +Qexc7+ +Qexc8# +Qexc8+ +Qexd1# +Qexd1+ +Qexd2# +Qexd2+ +Qexd3# +Qexd3+ +Qexd4# +Qexd4+ +Qexd5# +Qexd5+ +Qexd6# +Qexd6+ +Qexd7# +Qexd7+ +Qexd8# +Qexd8+ +Qexe1# +Qexe1+ +Qexe2# +Qexe2+ +Qexe3# +Qexe3+ +Qexe4# +Qexe4+ +Qexe5# +Qexe5+ +Qexe6# +Qexe6+ +Qexe7# +Qexe7+ +Qexe8# +Qexe8+ +Qexf1# +Qexf1+ +Qexf2# +Qexf2+ +Qexf3# +Qexf3+ +Qexf4# +Qexf4+ +Qexf5# +Qexf5+ +Qexf6# +Qexf6+ +Qexf7# +Qexf7+ +Qexf8# +Qexf8+ +Qexg1# +Qexg1+ +Qexg2# +Qexg2+ +Qexg3# +Qexg3+ +Qexg4# +Qexg4+ +Qexg5# +Qexg5+ +Qexg6# +Qexg6+ +Qexg7# +Qexg7+ +Qexg8# +Qexg8+ +Qexh1# +Qexh1+ +Qexh2# +Qexh2+ +Qexh3# +Qexh3+ +Qexh4# +Qexh4+ +Qexh5# +Qexh5+ +Qexh6# +Qexh6+ +Qexh7# +Qexh7+ +Qexh8# +Qexh8+ +Qf1a6# +Qf1a6+ +Qf1b1# +Qf1b1+ +Qf1b5# +Qf1b5+ +Qf1c1# +Qf1c1+ +Qf1c4# +Qf1c4+ +Qf1d1# +Qf1d1+ +Qf1d3# +Qf1d3+ +Qf1e1# +Qf1e1+ +Qf1e2# +Qf1e2+ +Qf1f2# +Qf1f2+ +Qf1f3# +Qf1f3+ +Qf1f4# +Qf1f4+ +Qf1f5# +Qf1f5+ +Qf1f6# +Qf1f6+ +Qf1g1# +Qf1g1+ +Qf1g2# +Qf1g2+ +Qf1h3# +Qf1h3+ +Qf1xa6 +Qf1xb1 +Qf1xb5 +Qf1xc1 +Qf1xc4 +Qf1xd1 +Qf1xd3 +Qf1xe1 +Qf1xe2 +Qf1xf2 +Qf1xf3 +Qf1xf4 +Qf1xf5 +Qf1xf6 +Qf1xg1 +Qf1xg2 +Qf1xh3 +Qf2a7# +Qf2a7+ +Qf2b2# +Qf2b2+ +Qf2b6# +Qf2b6+ +Qf2c2# +Qf2c2+ +Qf2c5# +Qf2c5+ +Qf2d2# +Qf2d2+ +Qf2d4# +Qf2d4+ +Qf2e1# +Qf2e1+ +Qf2e2# +Qf2e2+ +Qf2e3# +Qf2e3+ +Qf2f3# +Qf2f3+ +Qf2f4# +Qf2f4+ +Qf2f5# +Qf2f5+ +Qf2f6# +Qf2f6+ +Qf2f7# +Qf2f7+ +Qf2g1# +Qf2g1+ +Qf2g2# +Qf2g2+ +Qf2g3# +Qf2g3+ +Qf2h4# +Qf2h4+ +Qf2xa7 +Qf2xb2 +Qf2xb6 +Qf2xc2 +Qf2xc5 +Qf2xd2 +Qf2xd4 +Qf2xe1 +Qf2xe2 +Qf2xe3 +Qf2xf3 +Qf2xf4 +Qf2xf5 +Qf2xf6 +Qf2xf7 +Qf2xg1 +Qf2xg2 +Qf2xg3 +Qf2xh4 +Qf3a8# +Qf3a8+ +Qf3b3# +Qf3b3+ +Qf3b7# +Qf3b7+ +Qf3c3# +Qf3c3+ +Qf3c6# +Qf3c6+ +Qf3d1# +Qf3d1+ +Qf3d3# +Qf3d3+ +Qf3d5# +Qf3d5+ +Qf3e2# +Qf3e2+ +Qf3e3# +Qf3e3+ +Qf3e4# +Qf3e4+ +Qf3f2# +Qf3f2+ +Qf3f4# +Qf3f4+ +Qf3f5# +Qf3f5+ +Qf3f6# +Qf3f6+ +Qf3f7# +Qf3f7+ +Qf3g2# +Qf3g2+ +Qf3g3# +Qf3g3+ +Qf3g4# +Qf3g4+ +Qf3h1# +Qf3h1+ +Qf3h5# +Qf3h5+ +Qf3xa8 +Qf3xb3 +Qf3xb7 +Qf3xc3 +Qf3xc6 +Qf3xd1 +Qf3xd3 +Qf3xd5 +Qf3xe2 +Qf3xe3 +Qf3xe4 +Qf3xf2 +Qf3xf4 +Qf3xf5 +Qf3xf6 +Qf3xf7 +Qf3xg2 +Qf3xg3 +Qf3xg4 +Qf3xh1 +Qf3xh5 +Qf4b4# +Qf4b4+ +Qf4b8# +Qf4b8+ +Qf4c1# +Qf4c1+ +Qf4c4# +Qf4c4+ +Qf4c7# +Qf4c7+ +Qf4d2# +Qf4d2+ +Qf4d4# +Qf4d4+ +Qf4d6# +Qf4d6+ +Qf4e3# +Qf4e3+ +Qf4e4# +Qf4e4+ +Qf4e5# +Qf4e5+ +Qf4f2# +Qf4f2+ +Qf4f3# +Qf4f3+ +Qf4f5# +Qf4f5+ +Qf4f6# +Qf4f6+ +Qf4f7# +Qf4f7+ +Qf4g3# +Qf4g3+ +Qf4g4# +Qf4g4+ +Qf4g5# +Qf4g5+ +Qf4h2# +Qf4h2+ +Qf4h6# +Qf4h6+ +Qf4xb4 +Qf4xb8 +Qf4xc1 +Qf4xc4 +Qf4xc7 +Qf4xd2 +Qf4xd4 +Qf4xd6 +Qf4xe3 +Qf4xe4 +Qf4xe5 +Qf4xf2 +Qf4xf3 +Qf4xf5 +Qf4xf6 +Qf4xf7 +Qf4xg3 +Qf4xg4 +Qf4xg5 +Qf4xh2 +Qf4xh6 +Qf5b1# +Qf5b1+ +Qf5b5# +Qf5b5+ +Qf5c2# +Qf5c2+ +Qf5c5# +Qf5c5+ +Qf5c8# +Qf5c8+ +Qf5d3# +Qf5d3+ +Qf5d5# +Qf5d5+ +Qf5d7# +Qf5d7+ +Qf5e4# +Qf5e4+ +Qf5e5# +Qf5e5+ +Qf5e6# +Qf5e6+ +Qf5f2# +Qf5f2+ +Qf5f3# +Qf5f3+ +Qf5f4# +Qf5f4+ +Qf5f6# +Qf5f6+ +Qf5f7# +Qf5f7+ +Qf5g4# +Qf5g4+ +Qf5g5# +Qf5g5+ +Qf5g6# +Qf5g6+ +Qf5h3# +Qf5h3+ +Qf5h7# +Qf5h7+ +Qf5xb1 +Qf5xb5 +Qf5xc2 +Qf5xc5 +Qf5xc8 +Qf5xd3 +Qf5xd5 +Qf5xd7 +Qf5xe4 +Qf5xe5 +Qf5xe6 +Qf5xf2 +Qf5xf3 +Qf5xf4 +Qf5xf6 +Qf5xf7 +Qf5xg4 +Qf5xg5 +Qf5xg6 +Qf5xh3 +Qf5xh7 +Qf6a1# +Qf6a1+ +Qf6b2# +Qf6b2+ +Qf6b6# +Qf6b6+ +Qf6c3# +Qf6c3+ +Qf6c6# +Qf6c6+ +Qf6d4# +Qf6d4+ +Qf6d6# +Qf6d6+ +Qf6d8# +Qf6d8+ +Qf6e5# +Qf6e5+ +Qf6e6# +Qf6e6+ +Qf6e7# +Qf6e7+ +Qf6f2# +Qf6f2+ +Qf6f3# +Qf6f3+ +Qf6f4# +Qf6f4+ +Qf6f5# +Qf6f5+ +Qf6f7# +Qf6f7+ +Qf6g5# +Qf6g5+ +Qf6g6# +Qf6g6+ +Qf6g7# +Qf6g7+ +Qf6h4# +Qf6h4+ +Qf6h8# +Qf6h8+ +Qf6xa1 +Qf6xb2 +Qf6xb6 +Qf6xc3 +Qf6xc6 +Qf6xd4 +Qf6xd6 +Qf6xd8 +Qf6xe5 +Qf6xe6 +Qf6xe7 +Qf6xf2 +Qf6xf3 +Qf6xf4 +Qf6xf5 +Qf6xf7 +Qf6xg5 +Qf6xg6 +Qf6xg7 +Qf6xh4 +Qf6xh8 +Qf7a2# +Qf7a2+ +Qf7b3# +Qf7b3+ +Qf7b7# +Qf7b7+ +Qf7c4# +Qf7c4+ +Qf7c7# +Qf7c7+ +Qf7d5# +Qf7d5+ +Qf7d7# +Qf7d7+ +Qf7e6# +Qf7e6+ +Qf7e7# +Qf7e7+ +Qf7e8# +Qf7e8+ +Qf7f2# +Qf7f2+ +Qf7f3# +Qf7f3+ +Qf7f4# +Qf7f4+ +Qf7f5# +Qf7f5+ +Qf7f6# +Qf7f6+ +Qf7g6# +Qf7g6+ +Qf7g7# +Qf7g7+ +Qf7g8# +Qf7g8+ +Qf7h5# +Qf7h5+ +Qf7xa2 +Qf7xb3 +Qf7xb7 +Qf7xc4 +Qf7xc7 +Qf7xd5 +Qf7xd7 +Qf7xe6 +Qf7xe7 +Qf7xe8 +Qf7xf2 +Qf7xf3 +Qf7xf4 +Qf7xf5 +Qf7xf6 +Qf7xg6 +Qf7xg7 +Qf7xg8 +Qf7xh5 +Qf8a3# +Qf8a3+ +Qf8b4# +Qf8b4+ +Qf8b8# +Qf8b8+ +Qf8c5# +Qf8c5+ +Qf8c8# +Qf8c8+ +Qf8d6# +Qf8d6+ +Qf8d8# +Qf8d8+ +Qf8e7# +Qf8e7+ +Qf8e8# +Qf8e8+ +Qf8f3# +Qf8f3+ +Qf8f4# +Qf8f4+ +Qf8f5# +Qf8f5+ +Qf8f6# +Qf8f6+ +Qf8f7# +Qf8f7+ +Qf8g7# +Qf8g7+ +Qf8g8# +Qf8g8+ +Qf8h6# +Qf8h6+ +Qf8xa3 +Qf8xb4 +Qf8xb8 +Qf8xc5 +Qf8xc8 +Qf8xd6 +Qf8xd8 +Qf8xe7 +Qf8xe8 +Qf8xf3 +Qf8xf4 +Qf8xf5 +Qf8xf6 +Qf8xf7 +Qf8xg7 +Qf8xg8 +Qf8xh6 +Qfxa1# +Qfxa1+ +Qfxa2# +Qfxa2+ +Qfxa3# +Qfxa3+ +Qfxa4# +Qfxa4+ +Qfxa5# +Qfxa5+ +Qfxa6# +Qfxa6+ +Qfxa7# +Qfxa7+ +Qfxa8# +Qfxa8+ +Qfxb1# +Qfxb1+ +Qfxb2# +Qfxb2+ +Qfxb3# +Qfxb3+ +Qfxb4# +Qfxb4+ +Qfxb5# +Qfxb5+ +Qfxb6# +Qfxb6+ +Qfxb7# +Qfxb7+ +Qfxb8# +Qfxb8+ +Qfxc1# +Qfxc1+ +Qfxc2# +Qfxc2+ +Qfxc3# +Qfxc3+ +Qfxc4# +Qfxc4+ +Qfxc5# +Qfxc5+ +Qfxc6# +Qfxc6+ +Qfxc7# +Qfxc7+ +Qfxc8# +Qfxc8+ +Qfxd1# +Qfxd1+ +Qfxd2# +Qfxd2+ +Qfxd3# +Qfxd3+ +Qfxd4# +Qfxd4+ +Qfxd5# +Qfxd5+ +Qfxd6# +Qfxd6+ +Qfxd7# +Qfxd7+ +Qfxd8# +Qfxd8+ +Qfxe1# +Qfxe1+ +Qfxe2# +Qfxe2+ +Qfxe3# +Qfxe3+ +Qfxe4# +Qfxe4+ +Qfxe5# +Qfxe5+ +Qfxe6# +Qfxe6+ +Qfxe7# +Qfxe7+ +Qfxe8# +Qfxe8+ +Qfxf1# +Qfxf1+ +Qfxf2# +Qfxf2+ +Qfxf3# +Qfxf3+ +Qfxf4# +Qfxf4+ +Qfxf5# +Qfxf5+ +Qfxf6# +Qfxf6+ +Qfxf7# +Qfxf7+ +Qfxf8# +Qfxf8+ +Qfxg1# +Qfxg1+ +Qfxg2# +Qfxg2+ +Qfxg3# +Qfxg3+ +Qfxg4# +Qfxg4+ +Qfxg5# +Qfxg5+ +Qfxg6# +Qfxg6+ +Qfxg7# +Qfxg7+ +Qfxg8# +Qfxg8+ +Qfxh1# +Qfxh1+ +Qfxh2# +Qfxh2+ +Qfxh3# +Qfxh3+ +Qfxh4# +Qfxh4+ +Qfxh5# +Qfxh5+ +Qfxh6# +Qfxh6+ +Qfxh7# +Qfxh7+ +Qfxh8# +Qfxh8+ +Qg1a7# +Qg1a7+ +Qg1b1# +Qg1b1+ +Qg1b6# +Qg1b6+ +Qg1c1# +Qg1c1+ +Qg1c5# +Qg1c5+ +Qg1d1# +Qg1d1+ +Qg1d4# +Qg1d4+ +Qg1e1# +Qg1e1+ +Qg1e3# +Qg1e3+ +Qg1f1# +Qg1f1+ +Qg1f2# +Qg1f2+ +Qg1g2# +Qg1g2+ +Qg1g3# +Qg1g3+ +Qg1g4# +Qg1g4+ +Qg1g5# +Qg1g5+ +Qg1g6# +Qg1g6+ +Qg1g7# +Qg1g7+ +Qg1h2# +Qg1h2+ +Qg1xa7 +Qg1xb1 +Qg1xb6 +Qg1xc1 +Qg1xc5 +Qg1xd1 +Qg1xd4 +Qg1xe1 +Qg1xe3 +Qg1xf1 +Qg1xf2 +Qg1xg2 +Qg1xg3 +Qg1xg4 +Qg1xg5 +Qg1xg6 +Qg1xg7 +Qg1xh2 +Qg2a8# +Qg2a8+ +Qg2b2# +Qg2b2+ +Qg2b7# +Qg2b7+ +Qg2c2# +Qg2c2+ +Qg2c6# +Qg2c6+ +Qg2d2# +Qg2d2+ +Qg2d5# +Qg2d5+ +Qg2e2# +Qg2e2+ +Qg2e4# +Qg2e4+ +Qg2f1# +Qg2f1+ +Qg2f2# +Qg2f2+ +Qg2f3# +Qg2f3+ +Qg2g3# +Qg2g3+ +Qg2g4# +Qg2g4+ +Qg2g5# +Qg2g5+ +Qg2g6# +Qg2g6+ +Qg2g7# +Qg2g7+ +Qg2h1# +Qg2h1+ +Qg2h3# +Qg2h3+ +Qg2xa8 +Qg2xb2 +Qg2xb7 +Qg2xc2 +Qg2xc6 +Qg2xd2 +Qg2xd5 +Qg2xe2 +Qg2xe4 +Qg2xf1 +Qg2xf2 +Qg2xf3 +Qg2xg3 +Qg2xg4 +Qg2xg5 +Qg2xg6 +Qg2xg7 +Qg2xh1 +Qg2xh3 +Qg3b3# +Qg3b3+ +Qg3b8# +Qg3b8+ +Qg3c3# +Qg3c3+ +Qg3c7# +Qg3c7+ +Qg3d3# +Qg3d3+ +Qg3d6# +Qg3d6+ +Qg3e1# +Qg3e1+ +Qg3e3# +Qg3e3+ +Qg3e5# +Qg3e5+ +Qg3f2# +Qg3f2+ +Qg3f3# +Qg3f3+ +Qg3f4# +Qg3f4+ +Qg3g2# +Qg3g2+ +Qg3g4# +Qg3g4+ +Qg3g5# +Qg3g5+ +Qg3g6# +Qg3g6+ +Qg3g7# +Qg3g7+ +Qg3h2# +Qg3h2+ +Qg3h4# +Qg3h4+ +Qg3xb3 +Qg3xb8 +Qg3xc3 +Qg3xc7 +Qg3xd3 +Qg3xd6 +Qg3xe1 +Qg3xe3 +Qg3xe5 +Qg3xf2 +Qg3xf3 +Qg3xf4 +Qg3xg2 +Qg3xg4 +Qg3xg5 +Qg3xg6 +Qg3xg7 +Qg3xh2 +Qg3xh4 +Qg4c4# +Qg4c4+ +Qg4c8# +Qg4c8+ +Qg4d1# +Qg4d1+ +Qg4d4# +Qg4d4+ +Qg4d7# +Qg4d7+ +Qg4e2# +Qg4e2+ +Qg4e4# +Qg4e4+ +Qg4e6# +Qg4e6+ +Qg4f3# +Qg4f3+ +Qg4f4# +Qg4f4+ +Qg4f5# +Qg4f5+ +Qg4g2# +Qg4g2+ +Qg4g3# +Qg4g3+ +Qg4g5# +Qg4g5+ +Qg4g6# +Qg4g6+ +Qg4g7# +Qg4g7+ +Qg4h3# +Qg4h3+ +Qg4h5# +Qg4h5+ +Qg4xc4 +Qg4xc8 +Qg4xd1 +Qg4xd4 +Qg4xd7 +Qg4xe2 +Qg4xe4 +Qg4xe6 +Qg4xf3 +Qg4xf4 +Qg4xf5 +Qg4xg2 +Qg4xg3 +Qg4xg5 +Qg4xg6 +Qg4xg7 +Qg4xh3 +Qg4xh5 +Qg5c1# +Qg5c1+ +Qg5c5# +Qg5c5+ +Qg5d2# +Qg5d2+ +Qg5d5# +Qg5d5+ +Qg5d8# +Qg5d8+ +Qg5e3# +Qg5e3+ +Qg5e5# +Qg5e5+ +Qg5e7# +Qg5e7+ +Qg5f4# +Qg5f4+ +Qg5f5# +Qg5f5+ +Qg5f6# +Qg5f6+ +Qg5g2# +Qg5g2+ +Qg5g3# +Qg5g3+ +Qg5g4# +Qg5g4+ +Qg5g6# +Qg5g6+ +Qg5g7# +Qg5g7+ +Qg5h4# +Qg5h4+ +Qg5h6# +Qg5h6+ +Qg5xc1 +Qg5xc5 +Qg5xd2 +Qg5xd5 +Qg5xd8 +Qg5xe3 +Qg5xe5 +Qg5xe7 +Qg5xf4 +Qg5xf5 +Qg5xf6 +Qg5xg2 +Qg5xg3 +Qg5xg4 +Qg5xg6 +Qg5xg7 +Qg5xh4 +Qg5xh6 +Qg6b1# +Qg6b1+ +Qg6b6# +Qg6b6+ +Qg6c2# +Qg6c2+ +Qg6c6# +Qg6c6+ +Qg6d3# +Qg6d3+ +Qg6d6# +Qg6d6+ +Qg6e4# +Qg6e4+ +Qg6e6# +Qg6e6+ +Qg6e8# +Qg6e8+ +Qg6f5# +Qg6f5+ +Qg6f6# +Qg6f6+ +Qg6f7# +Qg6f7+ +Qg6g2# +Qg6g2+ +Qg6g3# +Qg6g3+ +Qg6g4# +Qg6g4+ +Qg6g5# +Qg6g5+ +Qg6g7# +Qg6g7+ +Qg6h5# +Qg6h5+ +Qg6h7# +Qg6h7+ +Qg6xb1 +Qg6xb6 +Qg6xc2 +Qg6xc6 +Qg6xd3 +Qg6xd6 +Qg6xe4 +Qg6xe6 +Qg6xe8 +Qg6xf5 +Qg6xf6 +Qg6xf7 +Qg6xg2 +Qg6xg3 +Qg6xg4 +Qg6xg5 +Qg6xg7 +Qg6xh5 +Qg6xh7 +Qg7a1# +Qg7a1+ +Qg7b2# +Qg7b2+ +Qg7b7# +Qg7b7+ +Qg7c3# +Qg7c3+ +Qg7c7# +Qg7c7+ +Qg7d4# +Qg7d4+ +Qg7d7# +Qg7d7+ +Qg7e5# +Qg7e5+ +Qg7e7# +Qg7e7+ +Qg7f6# +Qg7f6+ +Qg7f7# +Qg7f7+ +Qg7f8# +Qg7f8+ +Qg7g2# +Qg7g2+ +Qg7g3# +Qg7g3+ +Qg7g4# +Qg7g4+ +Qg7g5# +Qg7g5+ +Qg7g6# +Qg7g6+ +Qg7h6# +Qg7h6+ +Qg7h8# +Qg7h8+ +Qg7xa1 +Qg7xb2 +Qg7xb7 +Qg7xc3 +Qg7xc7 +Qg7xd4 +Qg7xd7 +Qg7xe5 +Qg7xe7 +Qg7xf6 +Qg7xf7 +Qg7xf8 +Qg7xg2 +Qg7xg3 +Qg7xg4 +Qg7xg5 +Qg7xg6 +Qg7xh6 +Qg7xh8 +Qg8a2# +Qg8a2+ +Qg8b3# +Qg8b3+ +Qg8b8# +Qg8b8+ +Qg8c4# +Qg8c4+ +Qg8c8# +Qg8c8+ +Qg8d5# +Qg8d5+ +Qg8d8# +Qg8d8+ +Qg8e6# +Qg8e6+ +Qg8e8# +Qg8e8+ +Qg8f7# +Qg8f7+ +Qg8f8# +Qg8f8+ +Qg8g2# +Qg8g2+ +Qg8g3# +Qg8g3+ +Qg8g4# +Qg8g4+ +Qg8g5# +Qg8g5+ +Qg8g6# +Qg8g6+ +Qg8g7# +Qg8g7+ +Qg8h7# +Qg8h7+ +Qg8xa2 +Qg8xb3 +Qg8xb8 +Qg8xc4 +Qg8xc8 +Qg8xd5 +Qg8xd8 +Qg8xe6 +Qg8xe8 +Qg8xf7 +Qg8xf8 +Qg8xg2 +Qg8xg3 +Qg8xg4 +Qg8xg5 +Qg8xg6 +Qg8xg7 +Qg8xh7 +Qgxa1# +Qgxa1+ +Qgxa2# +Qgxa2+ +Qgxa3# +Qgxa3+ +Qgxa4# +Qgxa4+ +Qgxa5# +Qgxa5+ +Qgxa6# +Qgxa6+ +Qgxa7# +Qgxa7+ +Qgxa8# +Qgxa8+ +Qgxb1# +Qgxb1+ +Qgxb2# +Qgxb2+ +Qgxb3# +Qgxb3+ +Qgxb4# +Qgxb4+ +Qgxb5# +Qgxb5+ +Qgxb6# +Qgxb6+ +Qgxb7# +Qgxb7+ +Qgxb8# +Qgxb8+ +Qgxc1# +Qgxc1+ +Qgxc2# +Qgxc2+ +Qgxc3# +Qgxc3+ +Qgxc4# +Qgxc4+ +Qgxc5# +Qgxc5+ +Qgxc6# +Qgxc6+ +Qgxc7# +Qgxc7+ +Qgxc8# +Qgxc8+ +Qgxd1# +Qgxd1+ +Qgxd2# +Qgxd2+ +Qgxd3# +Qgxd3+ +Qgxd4# +Qgxd4+ +Qgxd5# +Qgxd5+ +Qgxd6# +Qgxd6+ +Qgxd7# +Qgxd7+ +Qgxd8# +Qgxd8+ +Qgxe1# +Qgxe1+ +Qgxe2# +Qgxe2+ +Qgxe3# +Qgxe3+ +Qgxe4# +Qgxe4+ +Qgxe5# +Qgxe5+ +Qgxe6# +Qgxe6+ +Qgxe7# +Qgxe7+ +Qgxe8# +Qgxe8+ +Qgxf1# +Qgxf1+ +Qgxf2# +Qgxf2+ +Qgxf3# +Qgxf3+ +Qgxf4# +Qgxf4+ +Qgxf5# +Qgxf5+ +Qgxf6# +Qgxf6+ +Qgxf7# +Qgxf7+ +Qgxf8# +Qgxf8+ +Qgxg1# +Qgxg1+ +Qgxg2# +Qgxg2+ +Qgxg3# +Qgxg3+ +Qgxg4# +Qgxg4+ +Qgxg5# +Qgxg5+ +Qgxg6# +Qgxg6+ +Qgxg7# +Qgxg7+ +Qgxg8# +Qgxg8+ +Qgxh1# +Qgxh1+ +Qgxh2# +Qgxh2+ +Qgxh3# +Qgxh3+ +Qgxh4# +Qgxh4+ +Qgxh5# +Qgxh5+ +Qgxh6# +Qgxh6+ +Qgxh7# +Qgxh7+ +Qgxh8# +Qgxh8+ +Qh1a8# +Qh1a8+ +Qh1b1# +Qh1b1+ +Qh1b7# +Qh1b7+ +Qh1c1# +Qh1c1+ +Qh1c6# +Qh1c6+ +Qh1d1# +Qh1d1+ +Qh1d5# +Qh1d5+ +Qh1e1# +Qh1e1+ +Qh1e4# +Qh1e4+ +Qh1f1# +Qh1f1+ +Qh1f3# +Qh1f3+ +Qh1g1# +Qh1g1+ +Qh1g2# +Qh1g2+ +Qh1h2# +Qh1h2+ +Qh1h3# +Qh1h3+ +Qh1h4# +Qh1h4+ +Qh1h5# +Qh1h5+ +Qh1h6# +Qh1h6+ +Qh1h7# +Qh1h7+ +Qh1xa8 +Qh1xb1 +Qh1xb7 +Qh1xc1 +Qh1xc6 +Qh1xd1 +Qh1xd5 +Qh1xe1 +Qh1xe4 +Qh1xf1 +Qh1xf3 +Qh1xg1 +Qh1xg2 +Qh1xh2 +Qh1xh3 +Qh1xh4 +Qh1xh5 +Qh1xh6 +Qh1xh7 +Qh2b2# +Qh2b2+ +Qh2b8# +Qh2b8+ +Qh2c2# +Qh2c2+ +Qh2c7# +Qh2c7+ +Qh2d2# +Qh2d2+ +Qh2d6# +Qh2d6+ +Qh2e2# +Qh2e2+ +Qh2e5# +Qh2e5+ +Qh2f2# +Qh2f2+ +Qh2f4# +Qh2f4+ +Qh2g1# +Qh2g1+ +Qh2g2# +Qh2g2+ +Qh2g3# +Qh2g3+ +Qh2h3# +Qh2h3+ +Qh2h4# +Qh2h4+ +Qh2h5# +Qh2h5+ +Qh2h6# +Qh2h6+ +Qh2h7# +Qh2h7+ +Qh2xb2 +Qh2xb8 +Qh2xc2 +Qh2xc7 +Qh2xd2 +Qh2xd6 +Qh2xe2 +Qh2xe5 +Qh2xf2 +Qh2xf4 +Qh2xg1 +Qh2xg2 +Qh2xg3 +Qh2xh3 +Qh2xh4 +Qh2xh5 +Qh2xh6 +Qh2xh7 +Qh3c3# +Qh3c3+ +Qh3c8# +Qh3c8+ +Qh3d3# +Qh3d3+ +Qh3d7# +Qh3d7+ +Qh3e3# +Qh3e3+ +Qh3e6# +Qh3e6+ +Qh3f1# +Qh3f1+ +Qh3f3# +Qh3f3+ +Qh3f5# +Qh3f5+ +Qh3g2# +Qh3g2+ +Qh3g3# +Qh3g3+ +Qh3g4# +Qh3g4+ +Qh3h2# +Qh3h2+ +Qh3h4# +Qh3h4+ +Qh3h5# +Qh3h5+ +Qh3h6# +Qh3h6+ +Qh3h7# +Qh3h7+ +Qh3xc3 +Qh3xc8 +Qh3xd3 +Qh3xd7 +Qh3xe3 +Qh3xe6 +Qh3xf1 +Qh3xf3 +Qh3xf5 +Qh3xg2 +Qh3xg3 +Qh3xg4 +Qh3xh2 +Qh3xh4 +Qh3xh5 +Qh3xh6 +Qh3xh7 +Qh4d4# +Qh4d4+ +Qh4d8# +Qh4d8+ +Qh4e1# +Qh4e1+ +Qh4e4# +Qh4e4+ +Qh4e7# +Qh4e7+ +Qh4f2# +Qh4f2+ +Qh4f4# +Qh4f4+ +Qh4f6# +Qh4f6+ +Qh4g3# +Qh4g3+ +Qh4g4# +Qh4g4+ +Qh4g5# +Qh4g5+ +Qh4h2# +Qh4h2+ +Qh4h3# +Qh4h3+ +Qh4h5# +Qh4h5+ +Qh4h6# +Qh4h6+ +Qh4h7# +Qh4h7+ +Qh4xd4 +Qh4xd8 +Qh4xe1 +Qh4xe4 +Qh4xe7 +Qh4xf2 +Qh4xf4 +Qh4xf6 +Qh4xg3 +Qh4xg4 +Qh4xg5 +Qh4xh2 +Qh4xh3 +Qh4xh5 +Qh4xh6 +Qh4xh7 +Qh5d1# +Qh5d1+ +Qh5d5# +Qh5d5+ +Qh5e2# +Qh5e2+ +Qh5e5# +Qh5e5+ +Qh5e8# +Qh5e8+ +Qh5f3# +Qh5f3+ +Qh5f5# +Qh5f5+ +Qh5f7# +Qh5f7+ +Qh5g4# +Qh5g4+ +Qh5g5# +Qh5g5+ +Qh5g6# +Qh5g6+ +Qh5h2# +Qh5h2+ +Qh5h3# +Qh5h3+ +Qh5h4# +Qh5h4+ +Qh5h6# +Qh5h6+ +Qh5h7# +Qh5h7+ +Qh5xd1 +Qh5xd5 +Qh5xe2 +Qh5xe5 +Qh5xe8 +Qh5xf3 +Qh5xf5 +Qh5xf7 +Qh5xg4 +Qh5xg5 +Qh5xg6 +Qh5xh2 +Qh5xh3 +Qh5xh4 +Qh5xh6 +Qh5xh7 +Qh6c1# +Qh6c1+ +Qh6c6# +Qh6c6+ +Qh6d2# +Qh6d2+ +Qh6d6# +Qh6d6+ +Qh6e3# +Qh6e3+ +Qh6e6# +Qh6e6+ +Qh6f4# +Qh6f4+ +Qh6f6# +Qh6f6+ +Qh6f8# +Qh6f8+ +Qh6g5# +Qh6g5+ +Qh6g6# +Qh6g6+ +Qh6g7# +Qh6g7+ +Qh6h2# +Qh6h2+ +Qh6h3# +Qh6h3+ +Qh6h4# +Qh6h4+ +Qh6h5# +Qh6h5+ +Qh6h7# +Qh6h7+ +Qh6xc1 +Qh6xc6 +Qh6xd2 +Qh6xd6 +Qh6xe3 +Qh6xe6 +Qh6xf4 +Qh6xf6 +Qh6xf8 +Qh6xg5 +Qh6xg6 +Qh6xg7 +Qh6xh2 +Qh6xh3 +Qh6xh4 +Qh6xh5 +Qh6xh7 +Qh7b1# +Qh7b1+ +Qh7b7# +Qh7b7+ +Qh7c2# +Qh7c2+ +Qh7c7# +Qh7c7+ +Qh7d3# +Qh7d3+ +Qh7d7# +Qh7d7+ +Qh7e4# +Qh7e4+ +Qh7e7# +Qh7e7+ +Qh7f5# +Qh7f5+ +Qh7f7# +Qh7f7+ +Qh7g6# +Qh7g6+ +Qh7g7# +Qh7g7+ +Qh7g8# +Qh7g8+ +Qh7h2# +Qh7h2+ +Qh7h3# +Qh7h3+ +Qh7h4# +Qh7h4+ +Qh7h5# +Qh7h5+ +Qh7h6# +Qh7h6+ +Qh7xb1 +Qh7xb7 +Qh7xc2 +Qh7xc7 +Qh7xd3 +Qh7xd7 +Qh7xe4 +Qh7xe7 +Qh7xf5 +Qh7xf7 +Qh7xg6 +Qh7xg7 +Qh7xg8 +Qh7xh2 +Qh7xh3 +Qh7xh4 +Qh7xh5 +Qh7xh6 +Qh8a1# +Qh8a1+ +Qh8b2# +Qh8b2+ +Qh8b8# +Qh8b8+ +Qh8c3# +Qh8c3+ +Qh8c8# +Qh8c8+ +Qh8d4# +Qh8d4+ +Qh8d8# +Qh8d8+ +Qh8e5# +Qh8e5+ +Qh8e8# +Qh8e8+ +Qh8f6# +Qh8f6+ +Qh8f8# +Qh8f8+ +Qh8g7# +Qh8g7+ +Qh8g8# +Qh8g8+ +Qh8h2# +Qh8h2+ +Qh8h3# +Qh8h3+ +Qh8h4# +Qh8h4+ +Qh8h5# +Qh8h5+ +Qh8h6# +Qh8h6+ +Qh8h7# +Qh8h7+ +Qh8xa1 +Qh8xb2 +Qh8xb8 +Qh8xc3 +Qh8xc8 +Qh8xd4 +Qh8xd8 +Qh8xe5 +Qh8xe8 +Qh8xf6 +Qh8xf8 +Qh8xg7 +Qh8xg8 +Qh8xh2 +Qh8xh3 +Qh8xh4 +Qh8xh5 +Qh8xh6 +Qh8xh7 +Qhxa1# +Qhxa1+ +Qhxa2# +Qhxa2+ +Qhxa3# +Qhxa3+ +Qhxa4# +Qhxa4+ +Qhxa5# +Qhxa5+ +Qhxa6# +Qhxa6+ +Qhxa7# +Qhxa7+ +Qhxa8# +Qhxa8+ +Qhxb1# +Qhxb1+ +Qhxb2# +Qhxb2+ +Qhxb3# +Qhxb3+ +Qhxb4# +Qhxb4+ +Qhxb5# +Qhxb5+ +Qhxb6# +Qhxb6+ +Qhxb7# +Qhxb7+ +Qhxb8# +Qhxb8+ +Qhxc1# +Qhxc1+ +Qhxc2# +Qhxc2+ +Qhxc3# +Qhxc3+ +Qhxc4# +Qhxc4+ +Qhxc5# +Qhxc5+ +Qhxc6# +Qhxc6+ +Qhxc7# +Qhxc7+ +Qhxc8# +Qhxc8+ +Qhxd1# +Qhxd1+ +Qhxd2# +Qhxd2+ +Qhxd3# +Qhxd3+ +Qhxd4# +Qhxd4+ +Qhxd5# +Qhxd5+ +Qhxd6# +Qhxd6+ +Qhxd7# +Qhxd7+ +Qhxd8# +Qhxd8+ +Qhxe1# +Qhxe1+ +Qhxe2# +Qhxe2+ +Qhxe3# +Qhxe3+ +Qhxe4# +Qhxe4+ +Qhxe5# +Qhxe5+ +Qhxe6# +Qhxe6+ +Qhxe7# +Qhxe7+ +Qhxe8# +Qhxe8+ +Qhxf1# +Qhxf1+ +Qhxf2# +Qhxf2+ +Qhxf3# +Qhxf3+ +Qhxf4# +Qhxf4+ +Qhxf5# +Qhxf5+ +Qhxf6# +Qhxf6+ +Qhxf7# +Qhxf7+ +Qhxf8# +Qhxf8+ +Qhxg1# +Qhxg1+ +Qhxg2# +Qhxg2+ +Qhxg3# +Qhxg3+ +Qhxg4# +Qhxg4+ +Qhxg5# +Qhxg5+ +Qhxg6# +Qhxg6+ +Qhxg7# +Qhxg7+ +Qhxg8# +Qhxg8+ +Qhxh1# +Qhxh1+ +Qhxh2# +Qhxh2+ +Qhxh3# +Qhxh3+ +Qhxh4# +Qhxh4+ +Qhxh5# +Qhxh5+ +Qhxh6# +Qhxh6+ +Qhxh7# +Qhxh7+ +Qhxh8# +Qhxh8+ +R1xa2# +R1xa2+ +R1xa3# +R1xa3+ +R1xa4# +R1xa4+ +R1xa5# +R1xa5+ +R1xa6# +R1xa6+ +R1xa7# +R1xa7+ +R1xb2# +R1xb2+ +R1xb3# +R1xb3+ +R1xb4# +R1xb4+ +R1xb5# +R1xb5+ +R1xb6# +R1xb6+ +R1xb7# +R1xb7+ +R1xc2# +R1xc2+ +R1xc3# +R1xc3+ +R1xc4# +R1xc4+ +R1xc5# +R1xc5+ +R1xc6# +R1xc6+ +R1xc7# +R1xc7+ +R1xd2# +R1xd2+ +R1xd3# +R1xd3+ +R1xd4# +R1xd4+ +R1xd5# +R1xd5+ +R1xd6# +R1xd6+ +R1xd7# +R1xd7+ +R1xe2# +R1xe2+ +R1xe3# +R1xe3+ +R1xe4# +R1xe4+ +R1xe5# +R1xe5+ +R1xe6# +R1xe6+ +R1xe7# +R1xe7+ +R1xf2# +R1xf2+ +R1xf3# +R1xf3+ +R1xf4# +R1xf4+ +R1xf5# +R1xf5+ +R1xf6# +R1xf6+ +R1xf7# +R1xf7+ +R1xg2# +R1xg2+ +R1xg3# +R1xg3+ +R1xg4# +R1xg4+ +R1xg5# +R1xg5+ +R1xg6# +R1xg6+ +R1xg7# +R1xg7+ +R1xh2# +R1xh2+ +R1xh3# +R1xh3+ +R1xh4# +R1xh4+ +R1xh5# +R1xh5+ +R1xh6# +R1xh6+ +R1xh7# +R1xh7+ +R2xa3# +R2xa3+ +R2xa4# +R2xa4+ +R2xa5# +R2xa5+ +R2xa6# +R2xa6+ +R2xa7# +R2xa7+ +R2xb3# +R2xb3+ +R2xb4# +R2xb4+ +R2xb5# +R2xb5+ +R2xb6# +R2xb6+ +R2xb7# +R2xb7+ +R2xc3# +R2xc3+ +R2xc4# +R2xc4+ +R2xc5# +R2xc5+ +R2xc6# +R2xc6+ +R2xc7# +R2xc7+ +R2xd3# +R2xd3+ +R2xd4# +R2xd4+ +R2xd5# +R2xd5+ +R2xd6# +R2xd6+ +R2xd7# +R2xd7+ +R2xe3# +R2xe3+ +R2xe4# +R2xe4+ +R2xe5# +R2xe5+ +R2xe6# +R2xe6+ +R2xe7# +R2xe7+ +R2xf3# +R2xf3+ +R2xf4# +R2xf4+ +R2xf5# +R2xf5+ +R2xf6# +R2xf6+ +R2xf7# +R2xf7+ +R2xg3# +R2xg3+ +R2xg4# +R2xg4+ +R2xg5# +R2xg5+ +R2xg6# +R2xg6+ +R2xg7# +R2xg7+ +R2xh3# +R2xh3+ +R2xh4# +R2xh4+ +R2xh5# +R2xh5+ +R2xh6# +R2xh6+ +R2xh7# +R2xh7+ +R3xa2# +R3xa2+ +R3xa4# +R3xa4+ +R3xa5# +R3xa5+ +R3xa6# +R3xa6+ +R3xa7# +R3xa7+ +R3xb2# +R3xb2+ +R3xb4# +R3xb4+ +R3xb5# +R3xb5+ +R3xb6# +R3xb6+ +R3xb7# +R3xb7+ +R3xc2# +R3xc2+ +R3xc4# +R3xc4+ +R3xc5# +R3xc5+ +R3xc6# +R3xc6+ +R3xc7# +R3xc7+ +R3xd2# +R3xd2+ +R3xd4# +R3xd4+ +R3xd5# +R3xd5+ +R3xd6# +R3xd6+ +R3xd7# +R3xd7+ +R3xe2# +R3xe2+ +R3xe4# +R3xe4+ +R3xe5# +R3xe5+ +R3xe6# +R3xe6+ +R3xe7# +R3xe7+ +R3xf2# +R3xf2+ +R3xf4# +R3xf4+ +R3xf5# +R3xf5+ +R3xf6# +R3xf6+ +R3xf7# +R3xf7+ +R3xg2# +R3xg2+ +R3xg4# +R3xg4+ +R3xg5# +R3xg5+ +R3xg6# +R3xg6+ +R3xg7# +R3xg7+ +R3xh2# +R3xh2+ +R3xh4# +R3xh4+ +R3xh5# +R3xh5+ +R3xh6# +R3xh6+ +R3xh7# +R3xh7+ +R4xa2# +R4xa2+ +R4xa3# +R4xa3+ +R4xa5# +R4xa5+ +R4xa6# +R4xa6+ +R4xa7# +R4xa7+ +R4xb2# +R4xb2+ +R4xb3# +R4xb3+ +R4xb5# +R4xb5+ +R4xb6# +R4xb6+ +R4xb7# +R4xb7+ +R4xc2# +R4xc2+ +R4xc3# +R4xc3+ +R4xc5# +R4xc5+ +R4xc6# +R4xc6+ +R4xc7# +R4xc7+ +R4xd2# +R4xd2+ +R4xd3# +R4xd3+ +R4xd5# +R4xd5+ +R4xd6# +R4xd6+ +R4xd7# +R4xd7+ +R4xe2# +R4xe2+ +R4xe3# +R4xe3+ +R4xe5# +R4xe5+ +R4xe6# +R4xe6+ +R4xe7# +R4xe7+ +R4xf2# +R4xf2+ +R4xf3# +R4xf3+ +R4xf5# +R4xf5+ +R4xf6# +R4xf6+ +R4xf7# +R4xf7+ +R4xg2# +R4xg2+ +R4xg3# +R4xg3+ +R4xg5# +R4xg5+ +R4xg6# +R4xg6+ +R4xg7# +R4xg7+ +R4xh2# +R4xh2+ +R4xh3# +R4xh3+ +R4xh5# +R4xh5+ +R4xh6# +R4xh6+ +R4xh7# +R4xh7+ +R5xa2# +R5xa2+ +R5xa3# +R5xa3+ +R5xa4# +R5xa4+ +R5xa6# +R5xa6+ +R5xa7# +R5xa7+ +R5xb2# +R5xb2+ +R5xb3# +R5xb3+ +R5xb4# +R5xb4+ +R5xb6# +R5xb6+ +R5xb7# +R5xb7+ +R5xc2# +R5xc2+ +R5xc3# +R5xc3+ +R5xc4# +R5xc4+ +R5xc6# +R5xc6+ +R5xc7# +R5xc7+ +R5xd2# +R5xd2+ +R5xd3# +R5xd3+ +R5xd4# +R5xd4+ +R5xd6# +R5xd6+ +R5xd7# +R5xd7+ +R5xe2# +R5xe2+ +R5xe3# +R5xe3+ +R5xe4# +R5xe4+ +R5xe6# +R5xe6+ +R5xe7# +R5xe7+ +R5xf2# +R5xf2+ +R5xf3# +R5xf3+ +R5xf4# +R5xf4+ +R5xf6# +R5xf6+ +R5xf7# +R5xf7+ +R5xg2# +R5xg2+ +R5xg3# +R5xg3+ +R5xg4# +R5xg4+ +R5xg6# +R5xg6+ +R5xg7# +R5xg7+ +R5xh2# +R5xh2+ +R5xh3# +R5xh3+ +R5xh4# +R5xh4+ +R5xh6# +R5xh6+ +R5xh7# +R5xh7+ +R6xa2# +R6xa2+ +R6xa3# +R6xa3+ +R6xa4# +R6xa4+ +R6xa5# +R6xa5+ +R6xa7# +R6xa7+ +R6xb2# +R6xb2+ +R6xb3# +R6xb3+ +R6xb4# +R6xb4+ +R6xb5# +R6xb5+ +R6xb7# +R6xb7+ +R6xc2# +R6xc2+ +R6xc3# +R6xc3+ +R6xc4# +R6xc4+ +R6xc5# +R6xc5+ +R6xc7# +R6xc7+ +R6xd2# +R6xd2+ +R6xd3# +R6xd3+ +R6xd4# +R6xd4+ +R6xd5# +R6xd5+ +R6xd7# +R6xd7+ +R6xe2# +R6xe2+ +R6xe3# +R6xe3+ +R6xe4# +R6xe4+ +R6xe5# +R6xe5+ +R6xe7# +R6xe7+ +R6xf2# +R6xf2+ +R6xf3# +R6xf3+ +R6xf4# +R6xf4+ +R6xf5# +R6xf5+ +R6xf7# +R6xf7+ +R6xg2# +R6xg2+ +R6xg3# +R6xg3+ +R6xg4# +R6xg4+ +R6xg5# +R6xg5+ +R6xg7# +R6xg7+ +R6xh2# +R6xh2+ +R6xh3# +R6xh3+ +R6xh4# +R6xh4+ +R6xh5# +R6xh5+ +R6xh7# +R6xh7+ +R7xa2# +R7xa2+ +R7xa3# +R7xa3+ +R7xa4# +R7xa4+ +R7xa5# +R7xa5+ +R7xa6# +R7xa6+ +R7xb2# +R7xb2+ +R7xb3# +R7xb3+ +R7xb4# +R7xb4+ +R7xb5# +R7xb5+ +R7xb6# +R7xb6+ +R7xc2# +R7xc2+ +R7xc3# +R7xc3+ +R7xc4# +R7xc4+ +R7xc5# +R7xc5+ +R7xc6# +R7xc6+ +R7xd2# +R7xd2+ +R7xd3# +R7xd3+ +R7xd4# +R7xd4+ +R7xd5# +R7xd5+ +R7xd6# +R7xd6+ +R7xe2# +R7xe2+ +R7xe3# +R7xe3+ +R7xe4# +R7xe4+ +R7xe5# +R7xe5+ +R7xe6# +R7xe6+ +R7xf2# +R7xf2+ +R7xf3# +R7xf3+ +R7xf4# +R7xf4+ +R7xf5# +R7xf5+ +R7xf6# +R7xf6+ +R7xg2# +R7xg2+ +R7xg3# +R7xg3+ +R7xg4# +R7xg4+ +R7xg5# +R7xg5+ +R7xg6# +R7xg6+ +R7xh2# +R7xh2+ +R7xh3# +R7xh3+ +R7xh4# +R7xh4+ +R7xh5# +R7xh5+ +R7xh6# +R7xh6+ +R8xa2# +R8xa2+ +R8xa3# +R8xa3+ +R8xa4# +R8xa4+ +R8xa5# +R8xa5+ +R8xa6# +R8xa6+ +R8xa7# +R8xa7+ +R8xb2# +R8xb2+ +R8xb3# +R8xb3+ +R8xb4# +R8xb4+ +R8xb5# +R8xb5+ +R8xb6# +R8xb6+ +R8xb7# +R8xb7+ +R8xc2# +R8xc2+ +R8xc3# +R8xc3+ +R8xc4# +R8xc4+ +R8xc5# +R8xc5+ +R8xc6# +R8xc6+ +R8xc7# +R8xc7+ +R8xd2# +R8xd2+ +R8xd3# +R8xd3+ +R8xd4# +R8xd4+ +R8xd5# +R8xd5+ +R8xd6# +R8xd6+ +R8xd7# +R8xd7+ +R8xe2# +R8xe2+ +R8xe3# +R8xe3+ +R8xe4# +R8xe4+ +R8xe5# +R8xe5+ +R8xe6# +R8xe6+ +R8xe7# +R8xe7+ +R8xf2# +R8xf2+ +R8xf3# +R8xf3+ +R8xf4# +R8xf4+ +R8xf5# +R8xf5+ +R8xf6# +R8xf6+ +R8xf7# +R8xf7+ +R8xg2# +R8xg2+ +R8xg3# +R8xg3+ +R8xg4# +R8xg4+ +R8xg5# +R8xg5+ +R8xg6# +R8xg6+ +R8xg7# +R8xg7+ +R8xh2# +R8xh2+ +R8xh3# +R8xh3+ +R8xh4# +R8xh4+ +R8xh5# +R8xh5+ +R8xh6# +R8xh6+ +R8xh7# +R8xh7+ +Raxa1# +Raxa1+ +Raxa2# +Raxa2+ +Raxa3# +Raxa3+ +Raxa4# +Raxa4+ +Raxa5# +Raxa5+ +Raxa6# +Raxa6+ +Raxa7# +Raxa7+ +Raxa8# +Raxa8+ +Raxb1# +Raxb1+ +Raxb2# +Raxb2+ +Raxb3# +Raxb3+ +Raxb4# +Raxb4+ +Raxb5# +Raxb5+ +Raxb6# +Raxb6+ +Raxb7# +Raxb7+ +Raxb8# +Raxb8+ +Raxc1# +Raxc1+ +Raxc2# +Raxc2+ +Raxc3# +Raxc3+ +Raxc4# +Raxc4+ +Raxc5# +Raxc5+ +Raxc6# +Raxc6+ +Raxc7# +Raxc7+ +Raxc8# +Raxc8+ +Raxd1# +Raxd1+ +Raxd2# +Raxd2+ +Raxd3# +Raxd3+ +Raxd4# +Raxd4+ +Raxd5# +Raxd5+ +Raxd6# +Raxd6+ +Raxd7# +Raxd7+ +Raxd8# +Raxd8+ +Raxe1# +Raxe1+ +Raxe2# +Raxe2+ +Raxe3# +Raxe3+ +Raxe4# +Raxe4+ +Raxe5# +Raxe5+ +Raxe6# +Raxe6+ +Raxe7# +Raxe7+ +Raxe8# +Raxe8+ +Raxf1# +Raxf1+ +Raxf2# +Raxf2+ +Raxf3# +Raxf3+ +Raxf4# +Raxf4+ +Raxf5# +Raxf5+ +Raxf6# +Raxf6+ +Raxf7# +Raxf7+ +Raxf8# +Raxf8+ +Raxg1# +Raxg1+ +Raxg2# +Raxg2+ +Raxg3# +Raxg3+ +Raxg4# +Raxg4+ +Raxg5# +Raxg5+ +Raxg6# +Raxg6+ +Raxg7# +Raxg7+ +Raxg8# +Raxg8+ +Raxh1# +Raxh1+ +Raxh2# +Raxh2+ +Raxh3# +Raxh3+ +Raxh4# +Raxh4+ +Raxh5# +Raxh5+ +Raxh6# +Raxh6+ +Raxh7# +Raxh7+ +Raxh8# +Raxh8+ +Rbxa1# +Rbxa1+ +Rbxa2# +Rbxa2+ +Rbxa3# +Rbxa3+ +Rbxa4# +Rbxa4+ +Rbxa5# +Rbxa5+ +Rbxa6# +Rbxa6+ +Rbxa7# +Rbxa7+ +Rbxa8# +Rbxa8+ +Rbxb1# +Rbxb1+ +Rbxb2# +Rbxb2+ +Rbxb3# +Rbxb3+ +Rbxb4# +Rbxb4+ +Rbxb5# +Rbxb5+ +Rbxb6# +Rbxb6+ +Rbxb7# +Rbxb7+ +Rbxb8# +Rbxb8+ +Rbxc1# +Rbxc1+ +Rbxc2# +Rbxc2+ +Rbxc3# +Rbxc3+ +Rbxc4# +Rbxc4+ +Rbxc5# +Rbxc5+ +Rbxc6# +Rbxc6+ +Rbxc7# +Rbxc7+ +Rbxc8# +Rbxc8+ +Rbxd1# +Rbxd1+ +Rbxd2# +Rbxd2+ +Rbxd3# +Rbxd3+ +Rbxd4# +Rbxd4+ +Rbxd5# +Rbxd5+ +Rbxd6# +Rbxd6+ +Rbxd7# +Rbxd7+ +Rbxd8# +Rbxd8+ +Rbxe1# +Rbxe1+ +Rbxe2# +Rbxe2+ +Rbxe3# +Rbxe3+ +Rbxe4# +Rbxe4+ +Rbxe5# +Rbxe5+ +Rbxe6# +Rbxe6+ +Rbxe7# +Rbxe7+ +Rbxe8# +Rbxe8+ +Rbxf1# +Rbxf1+ +Rbxf2# +Rbxf2+ +Rbxf3# +Rbxf3+ +Rbxf4# +Rbxf4+ +Rbxf5# +Rbxf5+ +Rbxf6# +Rbxf6+ +Rbxf7# +Rbxf7+ +Rbxf8# +Rbxf8+ +Rbxg1# +Rbxg1+ +Rbxg2# +Rbxg2+ +Rbxg3# +Rbxg3+ +Rbxg4# +Rbxg4+ +Rbxg5# +Rbxg5+ +Rbxg6# +Rbxg6+ +Rbxg7# +Rbxg7+ +Rbxg8# +Rbxg8+ +Rbxh1# +Rbxh1+ +Rbxh2# +Rbxh2+ +Rbxh3# +Rbxh3+ +Rbxh4# +Rbxh4+ +Rbxh5# +Rbxh5+ +Rbxh6# +Rbxh6+ +Rbxh7# +Rbxh7+ +Rbxh8# +Rbxh8+ +Rcxa1# +Rcxa1+ +Rcxa2# +Rcxa2+ +Rcxa3# +Rcxa3+ +Rcxa4# +Rcxa4+ +Rcxa5# +Rcxa5+ +Rcxa6# +Rcxa6+ +Rcxa7# +Rcxa7+ +Rcxa8# +Rcxa8+ +Rcxb1# +Rcxb1+ +Rcxb2# +Rcxb2+ +Rcxb3# +Rcxb3+ +Rcxb4# +Rcxb4+ +Rcxb5# +Rcxb5+ +Rcxb6# +Rcxb6+ +Rcxb7# +Rcxb7+ +Rcxb8# +Rcxb8+ +Rcxc1# +Rcxc1+ +Rcxc2# +Rcxc2+ +Rcxc3# +Rcxc3+ +Rcxc4# +Rcxc4+ +Rcxc5# +Rcxc5+ +Rcxc6# +Rcxc6+ +Rcxc7# +Rcxc7+ +Rcxc8# +Rcxc8+ +Rcxd1# +Rcxd1+ +Rcxd2# +Rcxd2+ +Rcxd3# +Rcxd3+ +Rcxd4# +Rcxd4+ +Rcxd5# +Rcxd5+ +Rcxd6# +Rcxd6+ +Rcxd7# +Rcxd7+ +Rcxd8# +Rcxd8+ +Rcxe1# +Rcxe1+ +Rcxe2# +Rcxe2+ +Rcxe3# +Rcxe3+ +Rcxe4# +Rcxe4+ +Rcxe5# +Rcxe5+ +Rcxe6# +Rcxe6+ +Rcxe7# +Rcxe7+ +Rcxe8# +Rcxe8+ +Rcxf1# +Rcxf1+ +Rcxf2# +Rcxf2+ +Rcxf3# +Rcxf3+ +Rcxf4# +Rcxf4+ +Rcxf5# +Rcxf5+ +Rcxf6# +Rcxf6+ +Rcxf7# +Rcxf7+ +Rcxf8# +Rcxf8+ +Rcxg1# +Rcxg1+ +Rcxg2# +Rcxg2+ +Rcxg3# +Rcxg3+ +Rcxg4# +Rcxg4+ +Rcxg5# +Rcxg5+ +Rcxg6# +Rcxg6+ +Rcxg7# +Rcxg7+ +Rcxg8# +Rcxg8+ +Rcxh1# +Rcxh1+ +Rcxh2# +Rcxh2+ +Rcxh3# +Rcxh3+ +Rcxh4# +Rcxh4+ +Rcxh5# +Rcxh5+ +Rcxh6# +Rcxh6+ +Rcxh7# +Rcxh7+ +Rcxh8# +Rcxh8+ +Rdxa1# +Rdxa1+ +Rdxa2# +Rdxa2+ +Rdxa3# +Rdxa3+ +Rdxa4# +Rdxa4+ +Rdxa5# +Rdxa5+ +Rdxa6# +Rdxa6+ +Rdxa7# +Rdxa7+ +Rdxa8# +Rdxa8+ +Rdxb1# +Rdxb1+ +Rdxb2# +Rdxb2+ +Rdxb3# +Rdxb3+ +Rdxb4# +Rdxb4+ +Rdxb5# +Rdxb5+ +Rdxb6# +Rdxb6+ +Rdxb7# +Rdxb7+ +Rdxb8# +Rdxb8+ +Rdxc1# +Rdxc1+ +Rdxc2# +Rdxc2+ +Rdxc3# +Rdxc3+ +Rdxc4# +Rdxc4+ +Rdxc5# +Rdxc5+ +Rdxc6# +Rdxc6+ +Rdxc7# +Rdxc7+ +Rdxc8# +Rdxc8+ +Rdxd1# +Rdxd1+ +Rdxd2# +Rdxd2+ +Rdxd3# +Rdxd3+ +Rdxd4# +Rdxd4+ +Rdxd5# +Rdxd5+ +Rdxd6# +Rdxd6+ +Rdxd7# +Rdxd7+ +Rdxd8# +Rdxd8+ +Rdxe1# +Rdxe1+ +Rdxe2# +Rdxe2+ +Rdxe3# +Rdxe3+ +Rdxe4# +Rdxe4+ +Rdxe5# +Rdxe5+ +Rdxe6# +Rdxe6+ +Rdxe7# +Rdxe7+ +Rdxe8# +Rdxe8+ +Rdxf1# +Rdxf1+ +Rdxf2# +Rdxf2+ +Rdxf3# +Rdxf3+ +Rdxf4# +Rdxf4+ +Rdxf5# +Rdxf5+ +Rdxf6# +Rdxf6+ +Rdxf7# +Rdxf7+ +Rdxf8# +Rdxf8+ +Rdxg1# +Rdxg1+ +Rdxg2# +Rdxg2+ +Rdxg3# +Rdxg3+ +Rdxg4# +Rdxg4+ +Rdxg5# +Rdxg5+ +Rdxg6# +Rdxg6+ +Rdxg7# +Rdxg7+ +Rdxg8# +Rdxg8+ +Rdxh1# +Rdxh1+ +Rdxh2# +Rdxh2+ +Rdxh3# +Rdxh3+ +Rdxh4# +Rdxh4+ +Rdxh5# +Rdxh5+ +Rdxh6# +Rdxh6+ +Rdxh7# +Rdxh7+ +Rdxh8# +Rdxh8+ +Rexa1# +Rexa1+ +Rexa2# +Rexa2+ +Rexa3# +Rexa3+ +Rexa4# +Rexa4+ +Rexa5# +Rexa5+ +Rexa6# +Rexa6+ +Rexa7# +Rexa7+ +Rexa8# +Rexa8+ +Rexb1# +Rexb1+ +Rexb2# +Rexb2+ +Rexb3# +Rexb3+ +Rexb4# +Rexb4+ +Rexb5# +Rexb5+ +Rexb6# +Rexb6+ +Rexb7# +Rexb7+ +Rexb8# +Rexb8+ +Rexc1# +Rexc1+ +Rexc2# +Rexc2+ +Rexc3# +Rexc3+ +Rexc4# +Rexc4+ +Rexc5# +Rexc5+ +Rexc6# +Rexc6+ +Rexc7# +Rexc7+ +Rexc8# +Rexc8+ +Rexd1# +Rexd1+ +Rexd2# +Rexd2+ +Rexd3# +Rexd3+ +Rexd4# +Rexd4+ +Rexd5# +Rexd5+ +Rexd6# +Rexd6+ +Rexd7# +Rexd7+ +Rexd8# +Rexd8+ +Rexe1# +Rexe1+ +Rexe2# +Rexe2+ +Rexe3# +Rexe3+ +Rexe4# +Rexe4+ +Rexe5# +Rexe5+ +Rexe6# +Rexe6+ +Rexe7# +Rexe7+ +Rexe8# +Rexe8+ +Rexf1# +Rexf1+ +Rexf2# +Rexf2+ +Rexf3# +Rexf3+ +Rexf4# +Rexf4+ +Rexf5# +Rexf5+ +Rexf6# +Rexf6+ +Rexf7# +Rexf7+ +Rexf8# +Rexf8+ +Rexg1# +Rexg1+ +Rexg2# +Rexg2+ +Rexg3# +Rexg3+ +Rexg4# +Rexg4+ +Rexg5# +Rexg5+ +Rexg6# +Rexg6+ +Rexg7# +Rexg7+ +Rexg8# +Rexg8+ +Rexh1# +Rexh1+ +Rexh2# +Rexh2+ +Rexh3# +Rexh3+ +Rexh4# +Rexh4+ +Rexh5# +Rexh5+ +Rexh6# +Rexh6+ +Rexh7# +Rexh7+ +Rexh8# +Rexh8+ +Rfxa1# +Rfxa1+ +Rfxa2# +Rfxa2+ +Rfxa3# +Rfxa3+ +Rfxa4# +Rfxa4+ +Rfxa5# +Rfxa5+ +Rfxa6# +Rfxa6+ +Rfxa7# +Rfxa7+ +Rfxa8# +Rfxa8+ +Rfxb1# +Rfxb1+ +Rfxb2# +Rfxb2+ +Rfxb3# +Rfxb3+ +Rfxb4# +Rfxb4+ +Rfxb5# +Rfxb5+ +Rfxb6# +Rfxb6+ +Rfxb7# +Rfxb7+ +Rfxb8# +Rfxb8+ +Rfxc1# +Rfxc1+ +Rfxc2# +Rfxc2+ +Rfxc3# +Rfxc3+ +Rfxc4# +Rfxc4+ +Rfxc5# +Rfxc5+ +Rfxc6# +Rfxc6+ +Rfxc7# +Rfxc7+ +Rfxc8# +Rfxc8+ +Rfxd1# +Rfxd1+ +Rfxd2# +Rfxd2+ +Rfxd3# +Rfxd3+ +Rfxd4# +Rfxd4+ +Rfxd5# +Rfxd5+ +Rfxd6# +Rfxd6+ +Rfxd7# +Rfxd7+ +Rfxd8# +Rfxd8+ +Rfxe1# +Rfxe1+ +Rfxe2# +Rfxe2+ +Rfxe3# +Rfxe3+ +Rfxe4# +Rfxe4+ +Rfxe5# +Rfxe5+ +Rfxe6# +Rfxe6+ +Rfxe7# +Rfxe7+ +Rfxe8# +Rfxe8+ +Rfxf1# +Rfxf1+ +Rfxf2# +Rfxf2+ +Rfxf3# +Rfxf3+ +Rfxf4# +Rfxf4+ +Rfxf5# +Rfxf5+ +Rfxf6# +Rfxf6+ +Rfxf7# +Rfxf7+ +Rfxf8# +Rfxf8+ +Rfxg1# +Rfxg1+ +Rfxg2# +Rfxg2+ +Rfxg3# +Rfxg3+ +Rfxg4# +Rfxg4+ +Rfxg5# +Rfxg5+ +Rfxg6# +Rfxg6+ +Rfxg7# +Rfxg7+ +Rfxg8# +Rfxg8+ +Rfxh1# +Rfxh1+ +Rfxh2# +Rfxh2+ +Rfxh3# +Rfxh3+ +Rfxh4# +Rfxh4+ +Rfxh5# +Rfxh5+ +Rfxh6# +Rfxh6+ +Rfxh7# +Rfxh7+ +Rfxh8# +Rfxh8+ +Rgxa1# +Rgxa1+ +Rgxa2# +Rgxa2+ +Rgxa3# +Rgxa3+ +Rgxa4# +Rgxa4+ +Rgxa5# +Rgxa5+ +Rgxa6# +Rgxa6+ +Rgxa7# +Rgxa7+ +Rgxa8# +Rgxa8+ +Rgxb1# +Rgxb1+ +Rgxb2# +Rgxb2+ +Rgxb3# +Rgxb3+ +Rgxb4# +Rgxb4+ +Rgxb5# +Rgxb5+ +Rgxb6# +Rgxb6+ +Rgxb7# +Rgxb7+ +Rgxb8# +Rgxb8+ +Rgxc1# +Rgxc1+ +Rgxc2# +Rgxc2+ +Rgxc3# +Rgxc3+ +Rgxc4# +Rgxc4+ +Rgxc5# +Rgxc5+ +Rgxc6# +Rgxc6+ +Rgxc7# +Rgxc7+ +Rgxc8# +Rgxc8+ +Rgxd1# +Rgxd1+ +Rgxd2# +Rgxd2+ +Rgxd3# +Rgxd3+ +Rgxd4# +Rgxd4+ +Rgxd5# +Rgxd5+ +Rgxd6# +Rgxd6+ +Rgxd7# +Rgxd7+ +Rgxd8# +Rgxd8+ +Rgxe1# +Rgxe1+ +Rgxe2# +Rgxe2+ +Rgxe3# +Rgxe3+ +Rgxe4# +Rgxe4+ +Rgxe5# +Rgxe5+ +Rgxe6# +Rgxe6+ +Rgxe7# +Rgxe7+ +Rgxe8# +Rgxe8+ +Rgxf1# +Rgxf1+ +Rgxf2# +Rgxf2+ +Rgxf3# +Rgxf3+ +Rgxf4# +Rgxf4+ +Rgxf5# +Rgxf5+ +Rgxf6# +Rgxf6+ +Rgxf7# +Rgxf7+ +Rgxf8# +Rgxf8+ +Rgxg1# +Rgxg1+ +Rgxg2# +Rgxg2+ +Rgxg3# +Rgxg3+ +Rgxg4# +Rgxg4+ +Rgxg5# +Rgxg5+ +Rgxg6# +Rgxg6+ +Rgxg7# +Rgxg7+ +Rgxg8# +Rgxg8+ +Rgxh1# +Rgxh1+ +Rgxh2# +Rgxh2+ +Rgxh3# +Rgxh3+ +Rgxh4# +Rgxh4+ +Rgxh5# +Rgxh5+ +Rgxh6# +Rgxh6+ +Rgxh7# +Rgxh7+ +Rgxh8# +Rgxh8+ +Rhxa1# +Rhxa1+ +Rhxa2# +Rhxa2+ +Rhxa3# +Rhxa3+ +Rhxa4# +Rhxa4+ +Rhxa5# +Rhxa5+ +Rhxa6# +Rhxa6+ +Rhxa7# +Rhxa7+ +Rhxa8# +Rhxa8+ +Rhxb1# +Rhxb1+ +Rhxb2# +Rhxb2+ +Rhxb3# +Rhxb3+ +Rhxb4# +Rhxb4+ +Rhxb5# +Rhxb5+ +Rhxb6# +Rhxb6+ +Rhxb7# +Rhxb7+ +Rhxb8# +Rhxb8+ +Rhxc1# +Rhxc1+ +Rhxc2# +Rhxc2+ +Rhxc3# +Rhxc3+ +Rhxc4# +Rhxc4+ +Rhxc5# +Rhxc5+ +Rhxc6# +Rhxc6+ +Rhxc7# +Rhxc7+ +Rhxc8# +Rhxc8+ +Rhxd1# +Rhxd1+ +Rhxd2# +Rhxd2+ +Rhxd3# +Rhxd3+ +Rhxd4# +Rhxd4+ +Rhxd5# +Rhxd5+ +Rhxd6# +Rhxd6+ +Rhxd7# +Rhxd7+ +Rhxd8# +Rhxd8+ +Rhxe1# +Rhxe1+ +Rhxe2# +Rhxe2+ +Rhxe3# +Rhxe3+ +Rhxe4# +Rhxe4+ +Rhxe5# +Rhxe5+ +Rhxe6# +Rhxe6+ +Rhxe7# +Rhxe7+ +Rhxe8# +Rhxe8+ +Rhxf1# +Rhxf1+ +Rhxf2# +Rhxf2+ +Rhxf3# +Rhxf3+ +Rhxf4# +Rhxf4+ +Rhxf5# +Rhxf5+ +Rhxf6# +Rhxf6+ +Rhxf7# +Rhxf7+ +Rhxf8# +Rhxf8+ +Rhxg1# +Rhxg1+ +Rhxg2# +Rhxg2+ +Rhxg3# +Rhxg3+ +Rhxg4# +Rhxg4+ +Rhxg5# +Rhxg5+ +Rhxg6# +Rhxg6+ +Rhxg7# +Rhxg7+ +Rhxg8# +Rhxg8+ +Rhxh1# +Rhxh1+ +Rhxh2# +Rhxh2+ +Rhxh3# +Rhxh3+ +Rhxh4# +Rhxh4+ +Rhxh5# +Rhxh5+ +Rhxh6# +Rhxh6+ +Rhxh7# +Rhxh7+ +Rhxh8# +Rhxh8+ +axb1=B +axb1=N +axb1=Q +axb1=R +axb8=B +axb8=N +axb8=Q +axb8=R +bxa1=B +bxa1=N +bxa1=Q +bxa1=R +bxa8=B +bxa8=N +bxa8=Q +bxa8=R +bxc1=B +bxc1=N +bxc1=Q +bxc1=R +bxc8=B +bxc8=N +bxc8=Q +bxc8=R +cxb1=B +cxb1=N +cxb1=Q +cxb1=R +cxb8=B +cxb8=N +cxb8=Q +cxb8=R +cxd1=B +cxd1=N +cxd1=Q +cxd1=R +cxd8=B +cxd8=N +cxd8=Q +cxd8=R +dxc1=B +dxc1=N +dxc1=Q +dxc1=R +dxc8=B +dxc8=N +dxc8=Q +dxc8=R +dxe1=B +dxe1=N +dxe1=Q +dxe1=R +dxe8=B +dxe8=N +dxe8=Q +dxe8=R +exd1=B +exd1=N +exd1=Q +exd1=R +exd8=B +exd8=N +exd8=Q +exd8=R +exf1=B +exf1=N +exf1=Q +exf1=R +exf8=B +exf8=N +exf8=Q +exf8=R +fxe1=B +fxe1=N +fxe1=Q +fxe1=R +fxe8=B +fxe8=N +fxe8=Q +fxe8=R +fxg1=B +fxg1=N +fxg1=Q +fxg1=R +fxg8=B +fxg8=N +fxg8=Q +fxg8=R +gxf1=B +gxf1=N +gxf1=Q +gxf1=R +gxf8=B +gxf8=N +gxf8=Q +gxf8=R +gxh1=B +gxh1=N +gxh1=Q +gxh1=R +gxh8=B +gxh8=N +gxh8=Q +gxh8=R +hxg1=B +hxg1=N +hxg1=Q +hxg1=R +hxg8=B +hxg8=N +hxg8=Q +hxg8=R +Ba1xb2# +Ba1xb2+ +Ba1xc3# +Ba1xc3+ +Ba1xd4# +Ba1xd4+ +Ba2xb3# +Ba2xb3+ +Ba2xc4# +Ba2xc4+ +Ba2xd5# +Ba2xd5+ +Ba3xb2# +Ba3xb2+ +Ba3xb4# +Ba3xb4+ +Ba3xc5# +Ba3xc5+ +Ba4xb3# +Ba4xb3+ +Ba4xb5# +Ba4xb5+ +Ba4xc6# +Ba4xc6+ +Ba5xb4# +Ba5xb4+ +Ba5xb6# +Ba5xb6+ +Ba5xc3# +Ba5xc3+ +Ba6xb5# +Ba6xb5+ +Ba6xb7# +Ba6xb7+ +Ba6xc4# +Ba6xc4+ +Ba7xb6# +Ba7xb6+ +Ba7xc5# +Ba7xc5+ +Ba7xd4# +Ba7xd4+ +Ba8xb7# +Ba8xb7+ +Ba8xc6# +Ba8xc6+ +Ba8xd5# +Ba8xd5+ +Bb1xc2# +Bb1xc2+ +Bb1xd3# +Bb1xd3+ +Bb1xe4# +Bb1xe4+ +Bb2xc3# +Bb2xc3+ +Bb2xd4# +Bb2xd4+ +Bb2xe5# +Bb2xe5+ +Bb3xc2# +Bb3xc2+ +Bb3xc4# +Bb3xc4+ +Bb3xd5# +Bb3xd5+ +Bb4xc3# +Bb4xc3+ +Bb4xc5# +Bb4xc5+ +Bb4xd6# +Bb4xd6+ +Bb5xc4# +Bb5xc4+ +Bb5xc6# +Bb5xc6+ +Bb5xd3# +Bb5xd3+ +Bb6xc5# +Bb6xc5+ +Bb6xc7# +Bb6xc7+ +Bb6xd4# +Bb6xd4+ +Bb7xc6# +Bb7xc6+ +Bb7xd5# +Bb7xd5+ +Bb7xe4# +Bb7xe4+ +Bb8xc7# +Bb8xc7+ +Bb8xd6# +Bb8xd6+ +Bb8xe5# +Bb8xe5+ +Bc1xb2# +Bc1xb2+ +Bc1xd2# +Bc1xd2+ +Bc1xe3# +Bc1xe3+ +Bc2xb3# +Bc2xb3+ +Bc2xd3# +Bc2xd3+ +Bc2xe4# +Bc2xe4+ +Bc3xb2# +Bc3xb2+ +Bc3xb4# +Bc3xb4+ +Bc3xd2# +Bc3xd2+ +Bc3xd4# +Bc3xd4+ +Bc3xe5# +Bc3xe5+ +Bc4xb3# +Bc4xb3+ +Bc4xb5# +Bc4xb5+ +Bc4xd3# +Bc4xd3+ +Bc4xd5# +Bc4xd5+ +Bc4xe6# +Bc4xe6+ +Bc5xb4# +Bc5xb4+ +Bc5xb6# +Bc5xb6+ +Bc5xd4# +Bc5xd4+ +Bc5xd6# +Bc5xd6+ +Bc5xe3# +Bc5xe3+ +Bc6xb5# +Bc6xb5+ +Bc6xb7# +Bc6xb7+ +Bc6xd5# +Bc6xd5+ +Bc6xd7# +Bc6xd7+ +Bc6xe4# +Bc6xe4+ +Bc7xb6# +Bc7xb6+ +Bc7xd6# +Bc7xd6+ +Bc7xe5# +Bc7xe5+ +Bc8xb7# +Bc8xb7+ +Bc8xd7# +Bc8xd7+ +Bc8xe6# +Bc8xe6+ +Bd1xc2# +Bd1xc2+ +Bd1xe2# +Bd1xe2+ +Bd1xf3# +Bd1xf3+ +Bd2xc3# +Bd2xc3+ +Bd2xe3# +Bd2xe3+ +Bd2xf4# +Bd2xf4+ +Bd3xc2# +Bd3xc2+ +Bd3xc4# +Bd3xc4+ +Bd3xe2# +Bd3xe2+ +Bd3xe4# +Bd3xe4+ +Bd3xf5# +Bd3xf5+ +Bd4xc3# +Bd4xc3+ +Bd4xc5# +Bd4xc5+ +Bd4xe3# +Bd4xe3+ +Bd4xe5# +Bd4xe5+ +Bd4xf6# +Bd4xf6+ +Bd5xc4# +Bd5xc4+ +Bd5xc6# +Bd5xc6+ +Bd5xe4# +Bd5xe4+ +Bd5xe6# +Bd5xe6+ +Bd5xf3# +Bd5xf3+ +Bd6xc5# +Bd6xc5+ +Bd6xc7# +Bd6xc7+ +Bd6xe5# +Bd6xe5+ +Bd6xe7# +Bd6xe7+ +Bd6xf4# +Bd6xf4+ +Bd7xc6# +Bd7xc6+ +Bd7xe6# +Bd7xe6+ +Bd7xf5# +Bd7xf5+ +Bd8xc7# +Bd8xc7+ +Bd8xe7# +Bd8xe7+ +Bd8xf6# +Bd8xf6+ +Be1xc3# +Be1xc3+ +Be1xd2# +Be1xd2+ +Be1xf2# +Be1xf2+ +Be2xc4# +Be2xc4+ +Be2xd3# +Be2xd3+ +Be2xf3# +Be2xf3+ +Be3xc5# +Be3xc5+ +Be3xd2# +Be3xd2+ +Be3xd4# +Be3xd4+ +Be3xf2# +Be3xf2+ +Be3xf4# +Be3xf4+ +Be4xc6# +Be4xc6+ +Be4xd3# +Be4xd3+ +Be4xd5# +Be4xd5+ +Be4xf3# +Be4xf3+ +Be4xf5# +Be4xf5+ +Be5xc3# +Be5xc3+ +Be5xd4# +Be5xd4+ +Be5xd6# +Be5xd6+ +Be5xf4# +Be5xf4+ +Be5xf6# +Be5xf6+ +Be6xc4# +Be6xc4+ +Be6xd5# +Be6xd5+ +Be6xd7# +Be6xd7+ +Be6xf5# +Be6xf5+ +Be6xf7# +Be6xf7+ +Be7xc5# +Be7xc5+ +Be7xd6# +Be7xd6+ +Be7xf6# +Be7xf6+ +Be8xc6# +Be8xc6+ +Be8xd7# +Be8xd7+ +Be8xf7# +Be8xf7+ +Bf1xd3# +Bf1xd3+ +Bf1xe2# +Bf1xe2+ +Bf1xg2# +Bf1xg2+ +Bf2xd4# +Bf2xd4+ +Bf2xe3# +Bf2xe3+ +Bf2xg3# +Bf2xg3+ +Bf3xd5# +Bf3xd5+ +Bf3xe2# +Bf3xe2+ +Bf3xe4# +Bf3xe4+ +Bf3xg2# +Bf3xg2+ +Bf3xg4# +Bf3xg4+ +Bf4xd6# +Bf4xd6+ +Bf4xe3# +Bf4xe3+ +Bf4xe5# +Bf4xe5+ +Bf4xg3# +Bf4xg3+ +Bf4xg5# +Bf4xg5+ +Bf5xd3# +Bf5xd3+ +Bf5xe4# +Bf5xe4+ +Bf5xe6# +Bf5xe6+ +Bf5xg4# +Bf5xg4+ +Bf5xg6# +Bf5xg6+ +Bf6xd4# +Bf6xd4+ +Bf6xe5# +Bf6xe5+ +Bf6xe7# +Bf6xe7+ +Bf6xg5# +Bf6xg5+ +Bf6xg7# +Bf6xg7+ +Bf7xd5# +Bf7xd5+ +Bf7xe6# +Bf7xe6+ +Bf7xg6# +Bf7xg6+ +Bf8xd6# +Bf8xd6+ +Bf8xe7# +Bf8xe7+ +Bf8xg7# +Bf8xg7+ +Bg1xd4# +Bg1xd4+ +Bg1xe3# +Bg1xe3+ +Bg1xf2# +Bg1xf2+ +Bg2xd5# +Bg2xd5+ +Bg2xe4# +Bg2xe4+ +Bg2xf3# +Bg2xf3+ +Bg3xe5# +Bg3xe5+ +Bg3xf2# +Bg3xf2+ +Bg3xf4# +Bg3xf4+ +Bg4xe6# +Bg4xe6+ +Bg4xf3# +Bg4xf3+ +Bg4xf5# +Bg4xf5+ +Bg5xe3# +Bg5xe3+ +Bg5xf4# +Bg5xf4+ +Bg5xf6# +Bg5xf6+ +Bg6xe4# +Bg6xe4+ +Bg6xf5# +Bg6xf5+ +Bg6xf7# +Bg6xf7+ +Bg7xd4# +Bg7xd4+ +Bg7xe5# +Bg7xe5+ +Bg7xf6# +Bg7xf6+ +Bg8xd5# +Bg8xd5+ +Bg8xe6# +Bg8xe6+ +Bg8xf7# +Bg8xf7+ +Bh1xe4# +Bh1xe4+ +Bh1xf3# +Bh1xf3+ +Bh1xg2# +Bh1xg2+ +Bh2xe5# +Bh2xe5+ +Bh2xf4# +Bh2xf4+ +Bh2xg3# +Bh2xg3+ +Bh3xf5# +Bh3xf5+ +Bh3xg2# +Bh3xg2+ +Bh3xg4# +Bh3xg4+ +Bh4xf6# +Bh4xf6+ +Bh4xg3# +Bh4xg3+ +Bh4xg5# +Bh4xg5+ +Bh5xf3# +Bh5xf3+ +Bh5xg4# +Bh5xg4+ +Bh5xg6# +Bh5xg6+ +Bh6xf4# +Bh6xf4+ +Bh6xg5# +Bh6xg5+ +Bh6xg7# +Bh6xg7+ +Bh7xe4# +Bh7xe4+ +Bh7xf5# +Bh7xf5+ +Bh7xg6# +Bh7xg6+ +Bh8xe5# +Bh8xe5+ +Bh8xf6# +Bh8xf6+ +Bh8xg7# +Bh8xg7+ +Na1xb3# +Na1xb3+ +Na1xc2# +Na1xc2+ +Na2xb4# +Na2xb4+ +Na2xc3# +Na2xc3+ +Na3xb5# +Na3xb5+ +Na3xc2# +Na3xc2+ +Na3xc4# +Na3xc4+ +Na4xb6# +Na4xb6+ +Na4xc3# +Na4xc3+ +Na4xc5# +Na4xc5+ +Na5xb3# +Na5xb3+ +Na5xc4# +Na5xc4+ +Na5xc6# +Na5xc6+ +Na6xb4# +Na6xb4+ +Na6xc5# +Na6xc5+ +Na6xc7# +Na6xc7+ +Na7xb5# +Na7xb5+ +Na7xc6# +Na7xc6+ +Na8xb6# +Na8xb6+ +Na8xc7# +Na8xc7+ +Nb1xc3# +Nb1xc3+ +Nb1xd2# +Nb1xd2+ +Nb2xc4# +Nb2xc4+ +Nb2xd3# +Nb2xd3+ +Nb3xc5# +Nb3xc5+ +Nb3xd2# +Nb3xd2+ +Nb3xd4# +Nb3xd4+ +Nb4xc6# +Nb4xc6+ +Nb4xd3# +Nb4xd3+ +Nb4xd5# +Nb4xd5+ +Nb5xc3# +Nb5xc3+ +Nb5xd4# +Nb5xd4+ +Nb5xd6# +Nb5xd6+ +Nb6xc4# +Nb6xc4+ +Nb6xd5# +Nb6xd5+ +Nb6xd7# +Nb6xd7+ +Nb7xc5# +Nb7xc5+ +Nb7xd6# +Nb7xd6+ +Nb8xc6# +Nb8xc6+ +Nb8xd7# +Nb8xd7+ +Nc1xb3# +Nc1xb3+ +Nc1xd3# +Nc1xd3+ +Nc1xe2# +Nc1xe2+ +Nc2xb4# +Nc2xb4+ +Nc2xd4# +Nc2xd4+ +Nc2xe3# +Nc2xe3+ +Nc3xb5# +Nc3xb5+ +Nc3xd5# +Nc3xd5+ +Nc3xe2# +Nc3xe2+ +Nc3xe4# +Nc3xe4+ +Nc4xb6# +Nc4xb6+ +Nc4xd6# +Nc4xd6+ +Nc4xe3# +Nc4xe3+ +Nc4xe5# +Nc4xe5+ +Nc5xb3# +Nc5xb3+ +Nc5xd3# +Nc5xd3+ +Nc5xe4# +Nc5xe4+ +Nc5xe6# +Nc5xe6+ +Nc6xb4# +Nc6xb4+ +Nc6xd4# +Nc6xd4+ +Nc6xe5# +Nc6xe5+ +Nc6xe7# +Nc6xe7+ +Nc7xb5# +Nc7xb5+ +Nc7xd5# +Nc7xd5+ +Nc7xe6# +Nc7xe6+ +Nc8xb6# +Nc8xb6+ +Nc8xd6# +Nc8xd6+ +Nc8xe7# +Nc8xe7+ +Nd1xc3# +Nd1xc3+ +Nd1xe3# +Nd1xe3+ +Nd1xf2# +Nd1xf2+ +Nd2xc4# +Nd2xc4+ +Nd2xe4# +Nd2xe4+ +Nd2xf3# +Nd2xf3+ +Nd3xc5# +Nd3xc5+ +Nd3xe5# +Nd3xe5+ +Nd3xf2# +Nd3xf2+ +Nd3xf4# +Nd3xf4+ +Nd4xc6# +Nd4xc6+ +Nd4xe6# +Nd4xe6+ +Nd4xf3# +Nd4xf3+ +Nd4xf5# +Nd4xf5+ +Nd5xc3# +Nd5xc3+ +Nd5xe3# +Nd5xe3+ +Nd5xf4# +Nd5xf4+ +Nd5xf6# +Nd5xf6+ +Nd6xc4# +Nd6xc4+ +Nd6xe4# +Nd6xe4+ +Nd6xf5# +Nd6xf5+ +Nd6xf7# +Nd6xf7+ +Nd7xc5# +Nd7xc5+ +Nd7xe5# +Nd7xe5+ +Nd7xf6# +Nd7xf6+ +Nd8xc6# +Nd8xc6+ +Nd8xe6# +Nd8xe6+ +Nd8xf7# +Nd8xf7+ +Ne1xc2# +Ne1xc2+ +Ne1xd3# +Ne1xd3+ +Ne1xf3# +Ne1xf3+ +Ne2xc3# +Ne2xc3+ +Ne2xd4# +Ne2xd4+ +Ne2xf4# +Ne2xf4+ +Ne3xc2# +Ne3xc2+ +Ne3xc4# +Ne3xc4+ +Ne3xd5# +Ne3xd5+ +Ne3xf5# +Ne3xf5+ +Ne4xc3# +Ne4xc3+ +Ne4xc5# +Ne4xc5+ +Ne4xd6# +Ne4xd6+ +Ne4xf6# +Ne4xf6+ +Ne5xc4# +Ne5xc4+ +Ne5xc6# +Ne5xc6+ +Ne5xd3# +Ne5xd3+ +Ne5xf3# +Ne5xf3+ +Ne6xc5# +Ne6xc5+ +Ne6xc7# +Ne6xc7+ +Ne6xd4# +Ne6xd4+ +Ne6xf4# +Ne6xf4+ +Ne7xc6# +Ne7xc6+ +Ne7xd5# +Ne7xd5+ +Ne7xf5# +Ne7xf5+ +Ne8xc7# +Ne8xc7+ +Ne8xd6# +Ne8xd6+ +Ne8xf6# +Ne8xf6+ +Nf1xd2# +Nf1xd2+ +Nf1xe3# +Nf1xe3+ +Nf1xg3# +Nf1xg3+ +Nf2xd3# +Nf2xd3+ +Nf2xe4# +Nf2xe4+ +Nf2xg4# +Nf2xg4+ +Nf3xd2# +Nf3xd2+ +Nf3xd4# +Nf3xd4+ +Nf3xe5# +Nf3xe5+ +Nf3xg5# +Nf3xg5+ +Nf4xd3# +Nf4xd3+ +Nf4xd5# +Nf4xd5+ +Nf4xe6# +Nf4xe6+ +Nf4xg6# +Nf4xg6+ +Nf5xd4# +Nf5xd4+ +Nf5xd6# +Nf5xd6+ +Nf5xe3# +Nf5xe3+ +Nf5xg3# +Nf5xg3+ +Nf6xd5# +Nf6xd5+ +Nf6xd7# +Nf6xd7+ +Nf6xe4# +Nf6xe4+ +Nf6xg4# +Nf6xg4+ +Nf7xd6# +Nf7xd6+ +Nf7xe5# +Nf7xe5+ +Nf7xg5# +Nf7xg5+ +Nf8xd7# +Nf8xd7+ +Nf8xe6# +Nf8xe6+ +Nf8xg6# +Nf8xg6+ +Ng1xe2# +Ng1xe2+ +Ng1xf3# +Ng1xf3+ +Ng2xe3# +Ng2xe3+ +Ng2xf4# +Ng2xf4+ +Ng3xe2# +Ng3xe2+ +Ng3xe4# +Ng3xe4+ +Ng3xf5# +Ng3xf5+ +Ng4xe3# +Ng4xe3+ +Ng4xe5# +Ng4xe5+ +Ng4xf6# +Ng4xf6+ +Ng5xe4# +Ng5xe4+ +Ng5xe6# +Ng5xe6+ +Ng5xf3# +Ng5xf3+ +Ng6xe5# +Ng6xe5+ +Ng6xe7# +Ng6xe7+ +Ng6xf4# +Ng6xf4+ +Ng7xe6# +Ng7xe6+ +Ng7xf5# +Ng7xf5+ +Ng8xe7# +Ng8xe7+ +Ng8xf6# +Ng8xf6+ +Nh1xf2# +Nh1xf2+ +Nh1xg3# +Nh1xg3+ +Nh2xf3# +Nh2xf3+ +Nh2xg4# +Nh2xg4+ +Nh3xf2# +Nh3xf2+ +Nh3xf4# +Nh3xf4+ +Nh3xg5# +Nh3xg5+ +Nh4xf3# +Nh4xf3+ +Nh4xf5# +Nh4xf5+ +Nh4xg6# +Nh4xg6+ +Nh5xf4# +Nh5xf4+ +Nh5xf6# +Nh5xf6+ +Nh5xg3# +Nh5xg3+ +Nh6xf5# +Nh6xf5+ +Nh6xf7# +Nh6xf7+ +Nh6xg4# +Nh6xg4+ +Nh7xf6# +Nh7xf6+ +Nh7xg5# +Nh7xg5+ +Nh8xf7# +Nh8xf7+ +Nh8xg6# +Nh8xg6+ +Qa1xa2# +Qa1xa2+ +Qa1xa3# +Qa1xa3+ +Qa1xa4# +Qa1xa4+ +Qa1xa5# +Qa1xa5+ +Qa1xa6# +Qa1xa6+ +Qa1xa7# +Qa1xa7+ +Qa1xb1# +Qa1xb1+ +Qa1xb2# +Qa1xb2+ +Qa1xc1# +Qa1xc1+ +Qa1xc3# +Qa1xc3+ +Qa1xd1# +Qa1xd1+ +Qa1xd4# +Qa1xd4+ +Qa1xe1# +Qa1xe1+ +Qa1xe5# +Qa1xe5+ +Qa1xf1# +Qa1xf1+ +Qa1xf6# +Qa1xf6+ +Qa1xg1# +Qa1xg1+ +Qa1xg7# +Qa1xg7+ +Qa1xh8# +Qa1xh8+ +Qa2xa3# +Qa2xa3+ +Qa2xa4# +Qa2xa4+ +Qa2xa5# +Qa2xa5+ +Qa2xa6# +Qa2xa6+ +Qa2xa7# +Qa2xa7+ +Qa2xb1# +Qa2xb1+ +Qa2xb2# +Qa2xb2+ +Qa2xb3# +Qa2xb3+ +Qa2xc2# +Qa2xc2+ +Qa2xc4# +Qa2xc4+ +Qa2xd2# +Qa2xd2+ +Qa2xd5# +Qa2xd5+ +Qa2xe2# +Qa2xe2+ +Qa2xe6# +Qa2xe6+ +Qa2xf2# +Qa2xf2+ +Qa2xf7# +Qa2xf7+ +Qa2xg2# +Qa2xg2+ +Qa2xg8# +Qa2xg8+ +Qa3xa2# +Qa3xa2+ +Qa3xa4# +Qa3xa4+ +Qa3xa5# +Qa3xa5+ +Qa3xa6# +Qa3xa6+ +Qa3xa7# +Qa3xa7+ +Qa3xb2# +Qa3xb2+ +Qa3xb3# +Qa3xb3+ +Qa3xb4# +Qa3xb4+ +Qa3xc1# +Qa3xc1+ +Qa3xc3# +Qa3xc3+ +Qa3xc5# +Qa3xc5+ +Qa3xd3# +Qa3xd3+ +Qa3xd6# +Qa3xd6+ +Qa3xe3# +Qa3xe3+ +Qa3xe7# +Qa3xe7+ +Qa3xf3# +Qa3xf3+ +Qa3xf8# +Qa3xf8+ +Qa4xa2# +Qa4xa2+ +Qa4xa3# +Qa4xa3+ +Qa4xa5# +Qa4xa5+ +Qa4xa6# +Qa4xa6+ +Qa4xa7# +Qa4xa7+ +Qa4xb3# +Qa4xb3+ +Qa4xb4# +Qa4xb4+ +Qa4xb5# +Qa4xb5+ +Qa4xc2# +Qa4xc2+ +Qa4xc4# +Qa4xc4+ +Qa4xc6# +Qa4xc6+ +Qa4xd1# +Qa4xd1+ +Qa4xd4# +Qa4xd4+ +Qa4xd7# +Qa4xd7+ +Qa4xe4# +Qa4xe4+ +Qa4xe8# +Qa4xe8+ +Qa5xa2# +Qa5xa2+ +Qa5xa3# +Qa5xa3+ +Qa5xa4# +Qa5xa4+ +Qa5xa6# +Qa5xa6+ +Qa5xa7# +Qa5xa7+ +Qa5xb4# +Qa5xb4+ +Qa5xb5# +Qa5xb5+ +Qa5xb6# +Qa5xb6+ +Qa5xc3# +Qa5xc3+ +Qa5xc5# +Qa5xc5+ +Qa5xc7# +Qa5xc7+ +Qa5xd2# +Qa5xd2+ +Qa5xd5# +Qa5xd5+ +Qa5xd8# +Qa5xd8+ +Qa5xe1# +Qa5xe1+ +Qa5xe5# +Qa5xe5+ +Qa6xa2# +Qa6xa2+ +Qa6xa3# +Qa6xa3+ +Qa6xa4# +Qa6xa4+ +Qa6xa5# +Qa6xa5+ +Qa6xa7# +Qa6xa7+ +Qa6xb5# +Qa6xb5+ +Qa6xb6# +Qa6xb6+ +Qa6xb7# +Qa6xb7+ +Qa6xc4# +Qa6xc4+ +Qa6xc6# +Qa6xc6+ +Qa6xc8# +Qa6xc8+ +Qa6xd3# +Qa6xd3+ +Qa6xd6# +Qa6xd6+ +Qa6xe2# +Qa6xe2+ +Qa6xe6# +Qa6xe6+ +Qa6xf1# +Qa6xf1+ +Qa6xf6# +Qa6xf6+ +Qa7xa2# +Qa7xa2+ +Qa7xa3# +Qa7xa3+ +Qa7xa4# +Qa7xa4+ +Qa7xa5# +Qa7xa5+ +Qa7xa6# +Qa7xa6+ +Qa7xb6# +Qa7xb6+ +Qa7xb7# +Qa7xb7+ +Qa7xb8# +Qa7xb8+ +Qa7xc5# +Qa7xc5+ +Qa7xc7# +Qa7xc7+ +Qa7xd4# +Qa7xd4+ +Qa7xd7# +Qa7xd7+ +Qa7xe3# +Qa7xe3+ +Qa7xe7# +Qa7xe7+ +Qa7xf2# +Qa7xf2+ +Qa7xf7# +Qa7xf7+ +Qa7xg1# +Qa7xg1+ +Qa7xg7# +Qa7xg7+ +Qa8xa2# +Qa8xa2+ +Qa8xa3# +Qa8xa3+ +Qa8xa4# +Qa8xa4+ +Qa8xa5# +Qa8xa5+ +Qa8xa6# +Qa8xa6+ +Qa8xa7# +Qa8xa7+ +Qa8xb7# +Qa8xb7+ +Qa8xb8# +Qa8xb8+ +Qa8xc6# +Qa8xc6+ +Qa8xc8# +Qa8xc8+ +Qa8xd5# +Qa8xd5+ +Qa8xd8# +Qa8xd8+ +Qa8xe4# +Qa8xe4+ +Qa8xe8# +Qa8xe8+ +Qa8xf3# +Qa8xf3+ +Qa8xf8# +Qa8xf8+ +Qa8xg2# +Qa8xg2+ +Qa8xg8# +Qa8xg8+ +Qa8xh1# +Qa8xh1+ +Qb1xa2# +Qb1xa2+ +Qb1xb2# +Qb1xb2+ +Qb1xb3# +Qb1xb3+ +Qb1xb4# +Qb1xb4+ +Qb1xb5# +Qb1xb5+ +Qb1xb6# +Qb1xb6+ +Qb1xb7# +Qb1xb7+ +Qb1xc1# +Qb1xc1+ +Qb1xc2# +Qb1xc2+ +Qb1xd1# +Qb1xd1+ +Qb1xd3# +Qb1xd3+ +Qb1xe1# +Qb1xe1+ +Qb1xe4# +Qb1xe4+ +Qb1xf1# +Qb1xf1+ +Qb1xf5# +Qb1xf5+ +Qb1xg1# +Qb1xg1+ +Qb1xg6# +Qb1xg6+ +Qb1xh7# +Qb1xh7+ +Qb2xa1# +Qb2xa1+ +Qb2xa3# +Qb2xa3+ +Qb2xb3# +Qb2xb3+ +Qb2xb4# +Qb2xb4+ +Qb2xb5# +Qb2xb5+ +Qb2xb6# +Qb2xb6+ +Qb2xb7# +Qb2xb7+ +Qb2xc1# +Qb2xc1+ +Qb2xc2# +Qb2xc2+ +Qb2xc3# +Qb2xc3+ +Qb2xd2# +Qb2xd2+ +Qb2xd4# +Qb2xd4+ +Qb2xe2# +Qb2xe2+ +Qb2xe5# +Qb2xe5+ +Qb2xf2# +Qb2xf2+ +Qb2xf6# +Qb2xf6+ +Qb2xg2# +Qb2xg2+ +Qb2xg7# +Qb2xg7+ +Qb2xh8# +Qb2xh8+ +Qb3xa2# +Qb3xa2+ +Qb3xa4# +Qb3xa4+ +Qb3xb2# +Qb3xb2+ +Qb3xb4# +Qb3xb4+ +Qb3xb5# +Qb3xb5+ +Qb3xb6# +Qb3xb6+ +Qb3xb7# +Qb3xb7+ +Qb3xc2# +Qb3xc2+ +Qb3xc3# +Qb3xc3+ +Qb3xc4# +Qb3xc4+ +Qb3xd1# +Qb3xd1+ +Qb3xd3# +Qb3xd3+ +Qb3xd5# +Qb3xd5+ +Qb3xe3# +Qb3xe3+ +Qb3xe6# +Qb3xe6+ +Qb3xf3# +Qb3xf3+ +Qb3xf7# +Qb3xf7+ +Qb3xg3# +Qb3xg3+ +Qb3xg8# +Qb3xg8+ +Qb4xa3# +Qb4xa3+ +Qb4xa5# +Qb4xa5+ +Qb4xb2# +Qb4xb2+ +Qb4xb3# +Qb4xb3+ +Qb4xb5# +Qb4xb5+ +Qb4xb6# +Qb4xb6+ +Qb4xb7# +Qb4xb7+ +Qb4xc3# +Qb4xc3+ +Qb4xc4# +Qb4xc4+ +Qb4xc5# +Qb4xc5+ +Qb4xd2# +Qb4xd2+ +Qb4xd4# +Qb4xd4+ +Qb4xd6# +Qb4xd6+ +Qb4xe1# +Qb4xe1+ +Qb4xe4# +Qb4xe4+ +Qb4xe7# +Qb4xe7+ +Qb4xf4# +Qb4xf4+ +Qb4xf8# +Qb4xf8+ +Qb5xa4# +Qb5xa4+ +Qb5xa6# +Qb5xa6+ +Qb5xb2# +Qb5xb2+ +Qb5xb3# +Qb5xb3+ +Qb5xb4# +Qb5xb4+ +Qb5xb6# +Qb5xb6+ +Qb5xb7# +Qb5xb7+ +Qb5xc4# +Qb5xc4+ +Qb5xc5# +Qb5xc5+ +Qb5xc6# +Qb5xc6+ +Qb5xd3# +Qb5xd3+ +Qb5xd5# +Qb5xd5+ +Qb5xd7# +Qb5xd7+ +Qb5xe2# +Qb5xe2+ +Qb5xe5# +Qb5xe5+ +Qb5xe8# +Qb5xe8+ +Qb5xf1# +Qb5xf1+ +Qb5xf5# +Qb5xf5+ +Qb6xa5# +Qb6xa5+ +Qb6xa7# +Qb6xa7+ +Qb6xb2# +Qb6xb2+ +Qb6xb3# +Qb6xb3+ +Qb6xb4# +Qb6xb4+ +Qb6xb5# +Qb6xb5+ +Qb6xb7# +Qb6xb7+ +Qb6xc5# +Qb6xc5+ +Qb6xc6# +Qb6xc6+ +Qb6xc7# +Qb6xc7+ +Qb6xd4# +Qb6xd4+ +Qb6xd6# +Qb6xd6+ +Qb6xd8# +Qb6xd8+ +Qb6xe3# +Qb6xe3+ +Qb6xe6# +Qb6xe6+ +Qb6xf2# +Qb6xf2+ +Qb6xf6# +Qb6xf6+ +Qb6xg1# +Qb6xg1+ +Qb6xg6# +Qb6xg6+ +Qb7xa6# +Qb7xa6+ +Qb7xa8# +Qb7xa8+ +Qb7xb2# +Qb7xb2+ +Qb7xb3# +Qb7xb3+ +Qb7xb4# +Qb7xb4+ +Qb7xb5# +Qb7xb5+ +Qb7xb6# +Qb7xb6+ +Qb7xc6# +Qb7xc6+ +Qb7xc7# +Qb7xc7+ +Qb7xc8# +Qb7xc8+ +Qb7xd5# +Qb7xd5+ +Qb7xd7# +Qb7xd7+ +Qb7xe4# +Qb7xe4+ +Qb7xe7# +Qb7xe7+ +Qb7xf3# +Qb7xf3+ +Qb7xf7# +Qb7xf7+ +Qb7xg2# +Qb7xg2+ +Qb7xg7# +Qb7xg7+ +Qb7xh1# +Qb7xh1+ +Qb8xa7# +Qb8xa7+ +Qb8xb2# +Qb8xb2+ +Qb8xb3# +Qb8xb3+ +Qb8xb4# +Qb8xb4+ +Qb8xb5# +Qb8xb5+ +Qb8xb6# +Qb8xb6+ +Qb8xb7# +Qb8xb7+ +Qb8xc7# +Qb8xc7+ +Qb8xc8# +Qb8xc8+ +Qb8xd6# +Qb8xd6+ +Qb8xd8# +Qb8xd8+ +Qb8xe5# +Qb8xe5+ +Qb8xe8# +Qb8xe8+ +Qb8xf4# +Qb8xf4+ +Qb8xf8# +Qb8xf8+ +Qb8xg3# +Qb8xg3+ +Qb8xg8# +Qb8xg8+ +Qb8xh2# +Qb8xh2+ +Qc1xa3# +Qc1xa3+ +Qc1xb1# +Qc1xb1+ +Qc1xb2# +Qc1xb2+ +Qc1xc2# +Qc1xc2+ +Qc1xc3# +Qc1xc3+ +Qc1xc4# +Qc1xc4+ +Qc1xc5# +Qc1xc5+ +Qc1xc6# +Qc1xc6+ +Qc1xd1# +Qc1xd1+ +Qc1xd2# +Qc1xd2+ +Qc1xe1# +Qc1xe1+ +Qc1xe3# +Qc1xe3+ +Qc1xf1# +Qc1xf1+ +Qc1xf4# +Qc1xf4+ +Qc1xg1# +Qc1xg1+ +Qc1xg5# +Qc1xg5+ +Qc1xh6# +Qc1xh6+ +Qc2xa4# +Qc2xa4+ +Qc2xb1# +Qc2xb1+ +Qc2xb2# +Qc2xb2+ +Qc2xb3# +Qc2xb3+ +Qc2xc3# +Qc2xc3+ +Qc2xc4# +Qc2xc4+ +Qc2xc5# +Qc2xc5+ +Qc2xc6# +Qc2xc6+ +Qc2xc7# +Qc2xc7+ +Qc2xd1# +Qc2xd1+ +Qc2xd2# +Qc2xd2+ +Qc2xd3# +Qc2xd3+ +Qc2xe2# +Qc2xe2+ +Qc2xe4# +Qc2xe4+ +Qc2xf2# +Qc2xf2+ +Qc2xf5# +Qc2xf5+ +Qc2xg2# +Qc2xg2+ +Qc2xg6# +Qc2xg6+ +Qc2xh7# +Qc2xh7+ +Qc3xa1# +Qc3xa1+ +Qc3xa5# +Qc3xa5+ +Qc3xb2# +Qc3xb2+ +Qc3xb3# +Qc3xb3+ +Qc3xb4# +Qc3xb4+ +Qc3xc2# +Qc3xc2+ +Qc3xc4# +Qc3xc4+ +Qc3xc5# +Qc3xc5+ +Qc3xc6# +Qc3xc6+ +Qc3xc7# +Qc3xc7+ +Qc3xd2# +Qc3xd2+ +Qc3xd3# +Qc3xd3+ +Qc3xd4# +Qc3xd4+ +Qc3xe1# +Qc3xe1+ +Qc3xe3# +Qc3xe3+ +Qc3xe5# +Qc3xe5+ +Qc3xf3# +Qc3xf3+ +Qc3xf6# +Qc3xf6+ +Qc3xg3# +Qc3xg3+ +Qc3xg7# +Qc3xg7+ +Qc3xh8# +Qc3xh8+ +Qc4xa2# +Qc4xa2+ +Qc4xa6# +Qc4xa6+ +Qc4xb3# +Qc4xb3+ +Qc4xb4# +Qc4xb4+ +Qc4xb5# +Qc4xb5+ +Qc4xc2# +Qc4xc2+ +Qc4xc3# +Qc4xc3+ +Qc4xc5# +Qc4xc5+ +Qc4xc6# +Qc4xc6+ +Qc4xc7# +Qc4xc7+ +Qc4xd3# +Qc4xd3+ +Qc4xd4# +Qc4xd4+ +Qc4xd5# +Qc4xd5+ +Qc4xe2# +Qc4xe2+ +Qc4xe4# +Qc4xe4+ +Qc4xe6# +Qc4xe6+ +Qc4xf1# +Qc4xf1+ +Qc4xf4# +Qc4xf4+ +Qc4xf7# +Qc4xf7+ +Qc4xg4# +Qc4xg4+ +Qc4xg8# +Qc4xg8+ +Qc5xa3# +Qc5xa3+ +Qc5xa7# +Qc5xa7+ +Qc5xb4# +Qc5xb4+ +Qc5xb5# +Qc5xb5+ +Qc5xb6# +Qc5xb6+ +Qc5xc2# +Qc5xc2+ +Qc5xc3# +Qc5xc3+ +Qc5xc4# +Qc5xc4+ +Qc5xc6# +Qc5xc6+ +Qc5xc7# +Qc5xc7+ +Qc5xd4# +Qc5xd4+ +Qc5xd5# +Qc5xd5+ +Qc5xd6# +Qc5xd6+ +Qc5xe3# +Qc5xe3+ +Qc5xe5# +Qc5xe5+ +Qc5xe7# +Qc5xe7+ +Qc5xf2# +Qc5xf2+ +Qc5xf5# +Qc5xf5+ +Qc5xf8# +Qc5xf8+ +Qc5xg1# +Qc5xg1+ +Qc5xg5# +Qc5xg5+ +Qc6xa4# +Qc6xa4+ +Qc6xa8# +Qc6xa8+ +Qc6xb5# +Qc6xb5+ +Qc6xb6# +Qc6xb6+ +Qc6xb7# +Qc6xb7+ +Qc6xc2# +Qc6xc2+ +Qc6xc3# +Qc6xc3+ +Qc6xc4# +Qc6xc4+ +Qc6xc5# +Qc6xc5+ +Qc6xc7# +Qc6xc7+ +Qc6xd5# +Qc6xd5+ +Qc6xd6# +Qc6xd6+ +Qc6xd7# +Qc6xd7+ +Qc6xe4# +Qc6xe4+ +Qc6xe6# +Qc6xe6+ +Qc6xe8# +Qc6xe8+ +Qc6xf3# +Qc6xf3+ +Qc6xf6# +Qc6xf6+ +Qc6xg2# +Qc6xg2+ +Qc6xg6# +Qc6xg6+ +Qc6xh1# +Qc6xh1+ +Qc7xa5# +Qc7xa5+ +Qc7xb6# +Qc7xb6+ +Qc7xb7# +Qc7xb7+ +Qc7xb8# +Qc7xb8+ +Qc7xc2# +Qc7xc2+ +Qc7xc3# +Qc7xc3+ +Qc7xc4# +Qc7xc4+ +Qc7xc5# +Qc7xc5+ +Qc7xc6# +Qc7xc6+ +Qc7xd6# +Qc7xd6+ +Qc7xd7# +Qc7xd7+ +Qc7xd8# +Qc7xd8+ +Qc7xe5# +Qc7xe5+ +Qc7xe7# +Qc7xe7+ +Qc7xf4# +Qc7xf4+ +Qc7xf7# +Qc7xf7+ +Qc7xg3# +Qc7xg3+ +Qc7xg7# +Qc7xg7+ +Qc7xh2# +Qc7xh2+ +Qc8xa6# +Qc8xa6+ +Qc8xb7# +Qc8xb7+ +Qc8xb8# +Qc8xb8+ +Qc8xc3# +Qc8xc3+ +Qc8xc4# +Qc8xc4+ +Qc8xc5# +Qc8xc5+ +Qc8xc6# +Qc8xc6+ +Qc8xc7# +Qc8xc7+ +Qc8xd7# +Qc8xd7+ +Qc8xd8# +Qc8xd8+ +Qc8xe6# +Qc8xe6+ +Qc8xe8# +Qc8xe8+ +Qc8xf5# +Qc8xf5+ +Qc8xf8# +Qc8xf8+ +Qc8xg4# +Qc8xg4+ +Qc8xg8# +Qc8xg8+ +Qc8xh3# +Qc8xh3+ +Qd1xa4# +Qd1xa4+ +Qd1xb1# +Qd1xb1+ +Qd1xb3# +Qd1xb3+ +Qd1xc1# +Qd1xc1+ +Qd1xc2# +Qd1xc2+ +Qd1xd2# +Qd1xd2+ +Qd1xd3# +Qd1xd3+ +Qd1xd4# +Qd1xd4+ +Qd1xd5# +Qd1xd5+ +Qd1xe1# +Qd1xe1+ +Qd1xe2# +Qd1xe2+ +Qd1xf1# +Qd1xf1+ +Qd1xf3# +Qd1xf3+ +Qd1xg1# +Qd1xg1+ +Qd1xg4# +Qd1xg4+ +Qd1xh5# +Qd1xh5+ +Qd2xa5# +Qd2xa5+ +Qd2xb2# +Qd2xb2+ +Qd2xb4# +Qd2xb4+ +Qd2xc1# +Qd2xc1+ +Qd2xc2# +Qd2xc2+ +Qd2xc3# +Qd2xc3+ +Qd2xd3# +Qd2xd3+ +Qd2xd4# +Qd2xd4+ +Qd2xd5# +Qd2xd5+ +Qd2xd6# +Qd2xd6+ +Qd2xe1# +Qd2xe1+ +Qd2xe2# +Qd2xe2+ +Qd2xe3# +Qd2xe3+ +Qd2xf2# +Qd2xf2+ +Qd2xf4# +Qd2xf4+ +Qd2xg2# +Qd2xg2+ +Qd2xg5# +Qd2xg5+ +Qd2xh6# +Qd2xh6+ +Qd3xa6# +Qd3xa6+ +Qd3xb1# +Qd3xb1+ +Qd3xb3# +Qd3xb3+ +Qd3xb5# +Qd3xb5+ +Qd3xc2# +Qd3xc2+ +Qd3xc3# +Qd3xc3+ +Qd3xc4# +Qd3xc4+ +Qd3xd2# +Qd3xd2+ +Qd3xd4# +Qd3xd4+ +Qd3xd5# +Qd3xd5+ +Qd3xd6# +Qd3xd6+ +Qd3xd7# +Qd3xd7+ +Qd3xe2# +Qd3xe2+ +Qd3xe3# +Qd3xe3+ +Qd3xe4# +Qd3xe4+ +Qd3xf1# +Qd3xf1+ +Qd3xf3# +Qd3xf3+ +Qd3xf5# +Qd3xf5+ +Qd3xg3# +Qd3xg3+ +Qd3xg6# +Qd3xg6+ +Qd3xh7# +Qd3xh7+ +Qd4xa1# +Qd4xa1+ +Qd4xa7# +Qd4xa7+ +Qd4xb2# +Qd4xb2+ +Qd4xb4# +Qd4xb4+ +Qd4xb6# +Qd4xb6+ +Qd4xc3# +Qd4xc3+ +Qd4xc4# +Qd4xc4+ +Qd4xc5# +Qd4xc5+ +Qd4xd2# +Qd4xd2+ +Qd4xd3# +Qd4xd3+ +Qd4xd5# +Qd4xd5+ +Qd4xd6# +Qd4xd6+ +Qd4xd7# +Qd4xd7+ +Qd4xe3# +Qd4xe3+ +Qd4xe4# +Qd4xe4+ +Qd4xe5# +Qd4xe5+ +Qd4xf2# +Qd4xf2+ +Qd4xf4# +Qd4xf4+ +Qd4xf6# +Qd4xf6+ +Qd4xg1# +Qd4xg1+ +Qd4xg4# +Qd4xg4+ +Qd4xg7# +Qd4xg7+ +Qd4xh8# +Qd4xh8+ +Qd5xa2# +Qd5xa2+ +Qd5xa8# +Qd5xa8+ +Qd5xb3# +Qd5xb3+ +Qd5xb5# +Qd5xb5+ +Qd5xb7# +Qd5xb7+ +Qd5xc4# +Qd5xc4+ +Qd5xc5# +Qd5xc5+ +Qd5xc6# +Qd5xc6+ +Qd5xd2# +Qd5xd2+ +Qd5xd3# +Qd5xd3+ +Qd5xd4# +Qd5xd4+ +Qd5xd6# +Qd5xd6+ +Qd5xd7# +Qd5xd7+ +Qd5xe4# +Qd5xe4+ +Qd5xe5# +Qd5xe5+ +Qd5xe6# +Qd5xe6+ +Qd5xf3# +Qd5xf3+ +Qd5xf5# +Qd5xf5+ +Qd5xf7# +Qd5xf7+ +Qd5xg2# +Qd5xg2+ +Qd5xg5# +Qd5xg5+ +Qd5xg8# +Qd5xg8+ +Qd5xh1# +Qd5xh1+ +Qd6xa3# +Qd6xa3+ +Qd6xb4# +Qd6xb4+ +Qd6xb6# +Qd6xb6+ +Qd6xb8# +Qd6xb8+ +Qd6xc5# +Qd6xc5+ +Qd6xc6# +Qd6xc6+ +Qd6xc7# +Qd6xc7+ +Qd6xd2# +Qd6xd2+ +Qd6xd3# +Qd6xd3+ +Qd6xd4# +Qd6xd4+ +Qd6xd5# +Qd6xd5+ +Qd6xd7# +Qd6xd7+ +Qd6xe5# +Qd6xe5+ +Qd6xe6# +Qd6xe6+ +Qd6xe7# +Qd6xe7+ +Qd6xf4# +Qd6xf4+ +Qd6xf6# +Qd6xf6+ +Qd6xf8# +Qd6xf8+ +Qd6xg3# +Qd6xg3+ +Qd6xg6# +Qd6xg6+ +Qd6xh2# +Qd6xh2+ +Qd7xa4# +Qd7xa4+ +Qd7xb5# +Qd7xb5+ +Qd7xb7# +Qd7xb7+ +Qd7xc6# +Qd7xc6+ +Qd7xc7# +Qd7xc7+ +Qd7xc8# +Qd7xc8+ +Qd7xd3# +Qd7xd3+ +Qd7xd4# +Qd7xd4+ +Qd7xd5# +Qd7xd5+ +Qd7xd6# +Qd7xd6+ +Qd7xe6# +Qd7xe6+ +Qd7xe7# +Qd7xe7+ +Qd7xe8# +Qd7xe8+ +Qd7xf5# +Qd7xf5+ +Qd7xf7# +Qd7xf7+ +Qd7xg4# +Qd7xg4+ +Qd7xg7# +Qd7xg7+ +Qd7xh3# +Qd7xh3+ +Qd8xa5# +Qd8xa5+ +Qd8xb6# +Qd8xb6+ +Qd8xb8# +Qd8xb8+ +Qd8xc7# +Qd8xc7+ +Qd8xc8# +Qd8xc8+ +Qd8xd4# +Qd8xd4+ +Qd8xd5# +Qd8xd5+ +Qd8xd6# +Qd8xd6+ +Qd8xd7# +Qd8xd7+ +Qd8xe7# +Qd8xe7+ +Qd8xe8# +Qd8xe8+ +Qd8xf6# +Qd8xf6+ +Qd8xf8# +Qd8xf8+ +Qd8xg5# +Qd8xg5+ +Qd8xg8# +Qd8xg8+ +Qd8xh4# +Qd8xh4+ +Qe1xa5# +Qe1xa5+ +Qe1xb1# +Qe1xb1+ +Qe1xb4# +Qe1xb4+ +Qe1xc1# +Qe1xc1+ +Qe1xc3# +Qe1xc3+ +Qe1xd1# +Qe1xd1+ +Qe1xd2# +Qe1xd2+ +Qe1xe2# +Qe1xe2+ +Qe1xe3# +Qe1xe3+ +Qe1xe4# +Qe1xe4+ +Qe1xe5# +Qe1xe5+ +Qe1xf1# +Qe1xf1+ +Qe1xf2# +Qe1xf2+ +Qe1xg1# +Qe1xg1+ +Qe1xg3# +Qe1xg3+ +Qe1xh4# +Qe1xh4+ +Qe2xa6# +Qe2xa6+ +Qe2xb2# +Qe2xb2+ +Qe2xb5# +Qe2xb5+ +Qe2xc2# +Qe2xc2+ +Qe2xc4# +Qe2xc4+ +Qe2xd1# +Qe2xd1+ +Qe2xd2# +Qe2xd2+ +Qe2xd3# +Qe2xd3+ +Qe2xe3# +Qe2xe3+ +Qe2xe4# +Qe2xe4+ +Qe2xe5# +Qe2xe5+ +Qe2xe6# +Qe2xe6+ +Qe2xf1# +Qe2xf1+ +Qe2xf2# +Qe2xf2+ +Qe2xf3# +Qe2xf3+ +Qe2xg2# +Qe2xg2+ +Qe2xg4# +Qe2xg4+ +Qe2xh5# +Qe2xh5+ +Qe3xa7# +Qe3xa7+ +Qe3xb3# +Qe3xb3+ +Qe3xb6# +Qe3xb6+ +Qe3xc1# +Qe3xc1+ +Qe3xc3# +Qe3xc3+ +Qe3xc5# +Qe3xc5+ +Qe3xd2# +Qe3xd2+ +Qe3xd3# +Qe3xd3+ +Qe3xd4# +Qe3xd4+ +Qe3xe2# +Qe3xe2+ +Qe3xe4# +Qe3xe4+ +Qe3xe5# +Qe3xe5+ +Qe3xe6# +Qe3xe6+ +Qe3xe7# +Qe3xe7+ +Qe3xf2# +Qe3xf2+ +Qe3xf3# +Qe3xf3+ +Qe3xf4# +Qe3xf4+ +Qe3xg1# +Qe3xg1+ +Qe3xg3# +Qe3xg3+ +Qe3xg5# +Qe3xg5+ +Qe3xh6# +Qe3xh6+ +Qe4xa8# +Qe4xa8+ +Qe4xb1# +Qe4xb1+ +Qe4xb4# +Qe4xb4+ +Qe4xb7# +Qe4xb7+ +Qe4xc2# +Qe4xc2+ +Qe4xc4# +Qe4xc4+ +Qe4xc6# +Qe4xc6+ +Qe4xd3# +Qe4xd3+ +Qe4xd4# +Qe4xd4+ +Qe4xd5# +Qe4xd5+ +Qe4xe2# +Qe4xe2+ +Qe4xe3# +Qe4xe3+ +Qe4xe5# +Qe4xe5+ +Qe4xe6# +Qe4xe6+ +Qe4xe7# +Qe4xe7+ +Qe4xf3# +Qe4xf3+ +Qe4xf4# +Qe4xf4+ +Qe4xf5# +Qe4xf5+ +Qe4xg2# +Qe4xg2+ +Qe4xg4# +Qe4xg4+ +Qe4xg6# +Qe4xg6+ +Qe4xh1# +Qe4xh1+ +Qe4xh7# +Qe4xh7+ +Qe5xa1# +Qe5xa1+ +Qe5xb2# +Qe5xb2+ +Qe5xb5# +Qe5xb5+ +Qe5xb8# +Qe5xb8+ +Qe5xc3# +Qe5xc3+ +Qe5xc5# +Qe5xc5+ +Qe5xc7# +Qe5xc7+ +Qe5xd4# +Qe5xd4+ +Qe5xd5# +Qe5xd5+ +Qe5xd6# +Qe5xd6+ +Qe5xe2# +Qe5xe2+ +Qe5xe3# +Qe5xe3+ +Qe5xe4# +Qe5xe4+ +Qe5xe6# +Qe5xe6+ +Qe5xe7# +Qe5xe7+ +Qe5xf4# +Qe5xf4+ +Qe5xf5# +Qe5xf5+ +Qe5xf6# +Qe5xf6+ +Qe5xg3# +Qe5xg3+ +Qe5xg5# +Qe5xg5+ +Qe5xg7# +Qe5xg7+ +Qe5xh2# +Qe5xh2+ +Qe5xh8# +Qe5xh8+ +Qe6xa2# +Qe6xa2+ +Qe6xb3# +Qe6xb3+ +Qe6xb6# +Qe6xb6+ +Qe6xc4# +Qe6xc4+ +Qe6xc6# +Qe6xc6+ +Qe6xc8# +Qe6xc8+ +Qe6xd5# +Qe6xd5+ +Qe6xd6# +Qe6xd6+ +Qe6xd7# +Qe6xd7+ +Qe6xe2# +Qe6xe2+ +Qe6xe3# +Qe6xe3+ +Qe6xe4# +Qe6xe4+ +Qe6xe5# +Qe6xe5+ +Qe6xe7# +Qe6xe7+ +Qe6xf5# +Qe6xf5+ +Qe6xf6# +Qe6xf6+ +Qe6xf7# +Qe6xf7+ +Qe6xg4# +Qe6xg4+ +Qe6xg6# +Qe6xg6+ +Qe6xg8# +Qe6xg8+ +Qe6xh3# +Qe6xh3+ +Qe7xa3# +Qe7xa3+ +Qe7xb4# +Qe7xb4+ +Qe7xb7# +Qe7xb7+ +Qe7xc5# +Qe7xc5+ +Qe7xc7# +Qe7xc7+ +Qe7xd6# +Qe7xd6+ +Qe7xd7# +Qe7xd7+ +Qe7xd8# +Qe7xd8+ +Qe7xe3# +Qe7xe3+ +Qe7xe4# +Qe7xe4+ +Qe7xe5# +Qe7xe5+ +Qe7xe6# +Qe7xe6+ +Qe7xf6# +Qe7xf6+ +Qe7xf7# +Qe7xf7+ +Qe7xf8# +Qe7xf8+ +Qe7xg5# +Qe7xg5+ +Qe7xg7# +Qe7xg7+ +Qe7xh4# +Qe7xh4+ +Qe8xa4# +Qe8xa4+ +Qe8xb5# +Qe8xb5+ +Qe8xb8# +Qe8xb8+ +Qe8xc6# +Qe8xc6+ +Qe8xc8# +Qe8xc8+ +Qe8xd7# +Qe8xd7+ +Qe8xd8# +Qe8xd8+ +Qe8xe4# +Qe8xe4+ +Qe8xe5# +Qe8xe5+ +Qe8xe6# +Qe8xe6+ +Qe8xe7# +Qe8xe7+ +Qe8xf7# +Qe8xf7+ +Qe8xf8# +Qe8xf8+ +Qe8xg6# +Qe8xg6+ +Qe8xg8# +Qe8xg8+ +Qe8xh5# +Qe8xh5+ +Qf1xa6# +Qf1xa6+ +Qf1xb1# +Qf1xb1+ +Qf1xb5# +Qf1xb5+ +Qf1xc1# +Qf1xc1+ +Qf1xc4# +Qf1xc4+ +Qf1xd1# +Qf1xd1+ +Qf1xd3# +Qf1xd3+ +Qf1xe1# +Qf1xe1+ +Qf1xe2# +Qf1xe2+ +Qf1xf2# +Qf1xf2+ +Qf1xf3# +Qf1xf3+ +Qf1xf4# +Qf1xf4+ +Qf1xf5# +Qf1xf5+ +Qf1xf6# +Qf1xf6+ +Qf1xg1# +Qf1xg1+ +Qf1xg2# +Qf1xg2+ +Qf1xh3# +Qf1xh3+ +Qf2xa7# +Qf2xa7+ +Qf2xb2# +Qf2xb2+ +Qf2xb6# +Qf2xb6+ +Qf2xc2# +Qf2xc2+ +Qf2xc5# +Qf2xc5+ +Qf2xd2# +Qf2xd2+ +Qf2xd4# +Qf2xd4+ +Qf2xe1# +Qf2xe1+ +Qf2xe2# +Qf2xe2+ +Qf2xe3# +Qf2xe3+ +Qf2xf3# +Qf2xf3+ +Qf2xf4# +Qf2xf4+ +Qf2xf5# +Qf2xf5+ +Qf2xf6# +Qf2xf6+ +Qf2xf7# +Qf2xf7+ +Qf2xg1# +Qf2xg1+ +Qf2xg2# +Qf2xg2+ +Qf2xg3# +Qf2xg3+ +Qf2xh4# +Qf2xh4+ +Qf3xa8# +Qf3xa8+ +Qf3xb3# +Qf3xb3+ +Qf3xb7# +Qf3xb7+ +Qf3xc3# +Qf3xc3+ +Qf3xc6# +Qf3xc6+ +Qf3xd1# +Qf3xd1+ +Qf3xd3# +Qf3xd3+ +Qf3xd5# +Qf3xd5+ +Qf3xe2# +Qf3xe2+ +Qf3xe3# +Qf3xe3+ +Qf3xe4# +Qf3xe4+ +Qf3xf2# +Qf3xf2+ +Qf3xf4# +Qf3xf4+ +Qf3xf5# +Qf3xf5+ +Qf3xf6# +Qf3xf6+ +Qf3xf7# +Qf3xf7+ +Qf3xg2# +Qf3xg2+ +Qf3xg3# +Qf3xg3+ +Qf3xg4# +Qf3xg4+ +Qf3xh1# +Qf3xh1+ +Qf3xh5# +Qf3xh5+ +Qf4xb4# +Qf4xb4+ +Qf4xb8# +Qf4xb8+ +Qf4xc1# +Qf4xc1+ +Qf4xc4# +Qf4xc4+ +Qf4xc7# +Qf4xc7+ +Qf4xd2# +Qf4xd2+ +Qf4xd4# +Qf4xd4+ +Qf4xd6# +Qf4xd6+ +Qf4xe3# +Qf4xe3+ +Qf4xe4# +Qf4xe4+ +Qf4xe5# +Qf4xe5+ +Qf4xf2# +Qf4xf2+ +Qf4xf3# +Qf4xf3+ +Qf4xf5# +Qf4xf5+ +Qf4xf6# +Qf4xf6+ +Qf4xf7# +Qf4xf7+ +Qf4xg3# +Qf4xg3+ +Qf4xg4# +Qf4xg4+ +Qf4xg5# +Qf4xg5+ +Qf4xh2# +Qf4xh2+ +Qf4xh6# +Qf4xh6+ +Qf5xb1# +Qf5xb1+ +Qf5xb5# +Qf5xb5+ +Qf5xc2# +Qf5xc2+ +Qf5xc5# +Qf5xc5+ +Qf5xc8# +Qf5xc8+ +Qf5xd3# +Qf5xd3+ +Qf5xd5# +Qf5xd5+ +Qf5xd7# +Qf5xd7+ +Qf5xe4# +Qf5xe4+ +Qf5xe5# +Qf5xe5+ +Qf5xe6# +Qf5xe6+ +Qf5xf2# +Qf5xf2+ +Qf5xf3# +Qf5xf3+ +Qf5xf4# +Qf5xf4+ +Qf5xf6# +Qf5xf6+ +Qf5xf7# +Qf5xf7+ +Qf5xg4# +Qf5xg4+ +Qf5xg5# +Qf5xg5+ +Qf5xg6# +Qf5xg6+ +Qf5xh3# +Qf5xh3+ +Qf5xh7# +Qf5xh7+ +Qf6xa1# +Qf6xa1+ +Qf6xb2# +Qf6xb2+ +Qf6xb6# +Qf6xb6+ +Qf6xc3# +Qf6xc3+ +Qf6xc6# +Qf6xc6+ +Qf6xd4# +Qf6xd4+ +Qf6xd6# +Qf6xd6+ +Qf6xd8# +Qf6xd8+ +Qf6xe5# +Qf6xe5+ +Qf6xe6# +Qf6xe6+ +Qf6xe7# +Qf6xe7+ +Qf6xf2# +Qf6xf2+ +Qf6xf3# +Qf6xf3+ +Qf6xf4# +Qf6xf4+ +Qf6xf5# +Qf6xf5+ +Qf6xf7# +Qf6xf7+ +Qf6xg5# +Qf6xg5+ +Qf6xg6# +Qf6xg6+ +Qf6xg7# +Qf6xg7+ +Qf6xh4# +Qf6xh4+ +Qf6xh8# +Qf6xh8+ +Qf7xa2# +Qf7xa2+ +Qf7xb3# +Qf7xb3+ +Qf7xb7# +Qf7xb7+ +Qf7xc4# +Qf7xc4+ +Qf7xc7# +Qf7xc7+ +Qf7xd5# +Qf7xd5+ +Qf7xd7# +Qf7xd7+ +Qf7xe6# +Qf7xe6+ +Qf7xe7# +Qf7xe7+ +Qf7xe8# +Qf7xe8+ +Qf7xf2# +Qf7xf2+ +Qf7xf3# +Qf7xf3+ +Qf7xf4# +Qf7xf4+ +Qf7xf5# +Qf7xf5+ +Qf7xf6# +Qf7xf6+ +Qf7xg6# +Qf7xg6+ +Qf7xg7# +Qf7xg7+ +Qf7xg8# +Qf7xg8+ +Qf7xh5# +Qf7xh5+ +Qf8xa3# +Qf8xa3+ +Qf8xb4# +Qf8xb4+ +Qf8xb8# +Qf8xb8+ +Qf8xc5# +Qf8xc5+ +Qf8xc8# +Qf8xc8+ +Qf8xd6# +Qf8xd6+ +Qf8xd8# +Qf8xd8+ +Qf8xe7# +Qf8xe7+ +Qf8xe8# +Qf8xe8+ +Qf8xf3# +Qf8xf3+ +Qf8xf4# +Qf8xf4+ +Qf8xf5# +Qf8xf5+ +Qf8xf6# +Qf8xf6+ +Qf8xf7# +Qf8xf7+ +Qf8xg7# +Qf8xg7+ +Qf8xg8# +Qf8xg8+ +Qf8xh6# +Qf8xh6+ +Qg1xa7# +Qg1xa7+ +Qg1xb1# +Qg1xb1+ +Qg1xb6# +Qg1xb6+ +Qg1xc1# +Qg1xc1+ +Qg1xc5# +Qg1xc5+ +Qg1xd1# +Qg1xd1+ +Qg1xd4# +Qg1xd4+ +Qg1xe1# +Qg1xe1+ +Qg1xe3# +Qg1xe3+ +Qg1xf1# +Qg1xf1+ +Qg1xf2# +Qg1xf2+ +Qg1xg2# +Qg1xg2+ +Qg1xg3# +Qg1xg3+ +Qg1xg4# +Qg1xg4+ +Qg1xg5# +Qg1xg5+ +Qg1xg6# +Qg1xg6+ +Qg1xg7# +Qg1xg7+ +Qg1xh2# +Qg1xh2+ +Qg2xa8# +Qg2xa8+ +Qg2xb2# +Qg2xb2+ +Qg2xb7# +Qg2xb7+ +Qg2xc2# +Qg2xc2+ +Qg2xc6# +Qg2xc6+ +Qg2xd2# +Qg2xd2+ +Qg2xd5# +Qg2xd5+ +Qg2xe2# +Qg2xe2+ +Qg2xe4# +Qg2xe4+ +Qg2xf1# +Qg2xf1+ +Qg2xf2# +Qg2xf2+ +Qg2xf3# +Qg2xf3+ +Qg2xg3# +Qg2xg3+ +Qg2xg4# +Qg2xg4+ +Qg2xg5# +Qg2xg5+ +Qg2xg6# +Qg2xg6+ +Qg2xg7# +Qg2xg7+ +Qg2xh1# +Qg2xh1+ +Qg2xh3# +Qg2xh3+ +Qg3xb3# +Qg3xb3+ +Qg3xb8# +Qg3xb8+ +Qg3xc3# +Qg3xc3+ +Qg3xc7# +Qg3xc7+ +Qg3xd3# +Qg3xd3+ +Qg3xd6# +Qg3xd6+ +Qg3xe1# +Qg3xe1+ +Qg3xe3# +Qg3xe3+ +Qg3xe5# +Qg3xe5+ +Qg3xf2# +Qg3xf2+ +Qg3xf3# +Qg3xf3+ +Qg3xf4# +Qg3xf4+ +Qg3xg2# +Qg3xg2+ +Qg3xg4# +Qg3xg4+ +Qg3xg5# +Qg3xg5+ +Qg3xg6# +Qg3xg6+ +Qg3xg7# +Qg3xg7+ +Qg3xh2# +Qg3xh2+ +Qg3xh4# +Qg3xh4+ +Qg4xc4# +Qg4xc4+ +Qg4xc8# +Qg4xc8+ +Qg4xd1# +Qg4xd1+ +Qg4xd4# +Qg4xd4+ +Qg4xd7# +Qg4xd7+ +Qg4xe2# +Qg4xe2+ +Qg4xe4# +Qg4xe4+ +Qg4xe6# +Qg4xe6+ +Qg4xf3# +Qg4xf3+ +Qg4xf4# +Qg4xf4+ +Qg4xf5# +Qg4xf5+ +Qg4xg2# +Qg4xg2+ +Qg4xg3# +Qg4xg3+ +Qg4xg5# +Qg4xg5+ +Qg4xg6# +Qg4xg6+ +Qg4xg7# +Qg4xg7+ +Qg4xh3# +Qg4xh3+ +Qg4xh5# +Qg4xh5+ +Qg5xc1# +Qg5xc1+ +Qg5xc5# +Qg5xc5+ +Qg5xd2# +Qg5xd2+ +Qg5xd5# +Qg5xd5+ +Qg5xd8# +Qg5xd8+ +Qg5xe3# +Qg5xe3+ +Qg5xe5# +Qg5xe5+ +Qg5xe7# +Qg5xe7+ +Qg5xf4# +Qg5xf4+ +Qg5xf5# +Qg5xf5+ +Qg5xf6# +Qg5xf6+ +Qg5xg2# +Qg5xg2+ +Qg5xg3# +Qg5xg3+ +Qg5xg4# +Qg5xg4+ +Qg5xg6# +Qg5xg6+ +Qg5xg7# +Qg5xg7+ +Qg5xh4# +Qg5xh4+ +Qg5xh6# +Qg5xh6+ +Qg6xb1# +Qg6xb1+ +Qg6xb6# +Qg6xb6+ +Qg6xc2# +Qg6xc2+ +Qg6xc6# +Qg6xc6+ +Qg6xd3# +Qg6xd3+ +Qg6xd6# +Qg6xd6+ +Qg6xe4# +Qg6xe4+ +Qg6xe6# +Qg6xe6+ +Qg6xe8# +Qg6xe8+ +Qg6xf5# +Qg6xf5+ +Qg6xf6# +Qg6xf6+ +Qg6xf7# +Qg6xf7+ +Qg6xg2# +Qg6xg2+ +Qg6xg3# +Qg6xg3+ +Qg6xg4# +Qg6xg4+ +Qg6xg5# +Qg6xg5+ +Qg6xg7# +Qg6xg7+ +Qg6xh5# +Qg6xh5+ +Qg6xh7# +Qg6xh7+ +Qg7xa1# +Qg7xa1+ +Qg7xb2# +Qg7xb2+ +Qg7xb7# +Qg7xb7+ +Qg7xc3# +Qg7xc3+ +Qg7xc7# +Qg7xc7+ +Qg7xd4# +Qg7xd4+ +Qg7xd7# +Qg7xd7+ +Qg7xe5# +Qg7xe5+ +Qg7xe7# +Qg7xe7+ +Qg7xf6# +Qg7xf6+ +Qg7xf7# +Qg7xf7+ +Qg7xf8# +Qg7xf8+ +Qg7xg2# +Qg7xg2+ +Qg7xg3# +Qg7xg3+ +Qg7xg4# +Qg7xg4+ +Qg7xg5# +Qg7xg5+ +Qg7xg6# +Qg7xg6+ +Qg7xh6# +Qg7xh6+ +Qg7xh8# +Qg7xh8+ +Qg8xa2# +Qg8xa2+ +Qg8xb3# +Qg8xb3+ +Qg8xb8# +Qg8xb8+ +Qg8xc4# +Qg8xc4+ +Qg8xc8# +Qg8xc8+ +Qg8xd5# +Qg8xd5+ +Qg8xd8# +Qg8xd8+ +Qg8xe6# +Qg8xe6+ +Qg8xe8# +Qg8xe8+ +Qg8xf7# +Qg8xf7+ +Qg8xf8# +Qg8xf8+ +Qg8xg2# +Qg8xg2+ +Qg8xg3# +Qg8xg3+ +Qg8xg4# +Qg8xg4+ +Qg8xg5# +Qg8xg5+ +Qg8xg6# +Qg8xg6+ +Qg8xg7# +Qg8xg7+ +Qg8xh7# +Qg8xh7+ +Qh1xa8# +Qh1xa8+ +Qh1xb1# +Qh1xb1+ +Qh1xb7# +Qh1xb7+ +Qh1xc1# +Qh1xc1+ +Qh1xc6# +Qh1xc6+ +Qh1xd1# +Qh1xd1+ +Qh1xd5# +Qh1xd5+ +Qh1xe1# +Qh1xe1+ +Qh1xe4# +Qh1xe4+ +Qh1xf1# +Qh1xf1+ +Qh1xf3# +Qh1xf3+ +Qh1xg1# +Qh1xg1+ +Qh1xg2# +Qh1xg2+ +Qh1xh2# +Qh1xh2+ +Qh1xh3# +Qh1xh3+ +Qh1xh4# +Qh1xh4+ +Qh1xh5# +Qh1xh5+ +Qh1xh6# +Qh1xh6+ +Qh1xh7# +Qh1xh7+ +Qh2xb2# +Qh2xb2+ +Qh2xb8# +Qh2xb8+ +Qh2xc2# +Qh2xc2+ +Qh2xc7# +Qh2xc7+ +Qh2xd2# +Qh2xd2+ +Qh2xd6# +Qh2xd6+ +Qh2xe2# +Qh2xe2+ +Qh2xe5# +Qh2xe5+ +Qh2xf2# +Qh2xf2+ +Qh2xf4# +Qh2xf4+ +Qh2xg1# +Qh2xg1+ +Qh2xg2# +Qh2xg2+ +Qh2xg3# +Qh2xg3+ +Qh2xh3# +Qh2xh3+ +Qh2xh4# +Qh2xh4+ +Qh2xh5# +Qh2xh5+ +Qh2xh6# +Qh2xh6+ +Qh2xh7# +Qh2xh7+ +Qh3xc3# +Qh3xc3+ +Qh3xc8# +Qh3xc8+ +Qh3xd3# +Qh3xd3+ +Qh3xd7# +Qh3xd7+ +Qh3xe3# +Qh3xe3+ +Qh3xe6# +Qh3xe6+ +Qh3xf1# +Qh3xf1+ +Qh3xf3# +Qh3xf3+ +Qh3xf5# +Qh3xf5+ +Qh3xg2# +Qh3xg2+ +Qh3xg3# +Qh3xg3+ +Qh3xg4# +Qh3xg4+ +Qh3xh2# +Qh3xh2+ +Qh3xh4# +Qh3xh4+ +Qh3xh5# +Qh3xh5+ +Qh3xh6# +Qh3xh6+ +Qh3xh7# +Qh3xh7+ +Qh4xd4# +Qh4xd4+ +Qh4xd8# +Qh4xd8+ +Qh4xe1# +Qh4xe1+ +Qh4xe4# +Qh4xe4+ +Qh4xe7# +Qh4xe7+ +Qh4xf2# +Qh4xf2+ +Qh4xf4# +Qh4xf4+ +Qh4xf6# +Qh4xf6+ +Qh4xg3# +Qh4xg3+ +Qh4xg4# +Qh4xg4+ +Qh4xg5# +Qh4xg5+ +Qh4xh2# +Qh4xh2+ +Qh4xh3# +Qh4xh3+ +Qh4xh5# +Qh4xh5+ +Qh4xh6# +Qh4xh6+ +Qh4xh7# +Qh4xh7+ +Qh5xd1# +Qh5xd1+ +Qh5xd5# +Qh5xd5+ +Qh5xe2# +Qh5xe2+ +Qh5xe5# +Qh5xe5+ +Qh5xe8# +Qh5xe8+ +Qh5xf3# +Qh5xf3+ +Qh5xf5# +Qh5xf5+ +Qh5xf7# +Qh5xf7+ +Qh5xg4# +Qh5xg4+ +Qh5xg5# +Qh5xg5+ +Qh5xg6# +Qh5xg6+ +Qh5xh2# +Qh5xh2+ +Qh5xh3# +Qh5xh3+ +Qh5xh4# +Qh5xh4+ +Qh5xh6# +Qh5xh6+ +Qh5xh7# +Qh5xh7+ +Qh6xc1# +Qh6xc1+ +Qh6xc6# +Qh6xc6+ +Qh6xd2# +Qh6xd2+ +Qh6xd6# +Qh6xd6+ +Qh6xe3# +Qh6xe3+ +Qh6xe6# +Qh6xe6+ +Qh6xf4# +Qh6xf4+ +Qh6xf6# +Qh6xf6+ +Qh6xf8# +Qh6xf8+ +Qh6xg5# +Qh6xg5+ +Qh6xg6# +Qh6xg6+ +Qh6xg7# +Qh6xg7+ +Qh6xh2# +Qh6xh2+ +Qh6xh3# +Qh6xh3+ +Qh6xh4# +Qh6xh4+ +Qh6xh5# +Qh6xh5+ +Qh6xh7# +Qh6xh7+ +Qh7xb1# +Qh7xb1+ +Qh7xb7# +Qh7xb7+ +Qh7xc2# +Qh7xc2+ +Qh7xc7# +Qh7xc7+ +Qh7xd3# +Qh7xd3+ +Qh7xd7# +Qh7xd7+ +Qh7xe4# +Qh7xe4+ +Qh7xe7# +Qh7xe7+ +Qh7xf5# +Qh7xf5+ +Qh7xf7# +Qh7xf7+ +Qh7xg6# +Qh7xg6+ +Qh7xg7# +Qh7xg7+ +Qh7xg8# +Qh7xg8+ +Qh7xh2# +Qh7xh2+ +Qh7xh3# +Qh7xh3+ +Qh7xh4# +Qh7xh4+ +Qh7xh5# +Qh7xh5+ +Qh7xh6# +Qh7xh6+ +Qh8xa1# +Qh8xa1+ +Qh8xb2# +Qh8xb2+ +Qh8xb8# +Qh8xb8+ +Qh8xc3# +Qh8xc3+ +Qh8xc8# +Qh8xc8+ +Qh8xd4# +Qh8xd4+ +Qh8xd8# +Qh8xd8+ +Qh8xe5# +Qh8xe5+ +Qh8xe8# +Qh8xe8+ +Qh8xf6# +Qh8xf6+ +Qh8xf8# +Qh8xf8+ +Qh8xg7# +Qh8xg7+ +Qh8xg8# +Qh8xg8+ +Qh8xh2# +Qh8xh2+ +Qh8xh3# +Qh8xh3+ +Qh8xh4# +Qh8xh4+ +Qh8xh5# +Qh8xh5+ +Qh8xh6# +Qh8xh6+ +Qh8xh7# +Qh8xh7+ +axb1=B# +axb1=B+ +axb1=N# +axb1=N+ +axb1=Q# +axb1=Q+ +axb1=R# +axb1=R+ +axb8=B# +axb8=B+ +axb8=N# +axb8=N+ +axb8=Q# +axb8=Q+ +axb8=R# +axb8=R+ +bxa1=B# +bxa1=B+ +bxa1=N# +bxa1=N+ +bxa1=Q# +bxa1=Q+ +bxa1=R# +bxa1=R+ +bxa8=B# +bxa8=B+ +bxa8=N# +bxa8=N+ +bxa8=Q# +bxa8=Q+ +bxa8=R# +bxa8=R+ +bxc1=B# +bxc1=B+ +bxc1=N# +bxc1=N+ +bxc1=Q# +bxc1=Q+ +bxc1=R# +bxc1=R+ +bxc8=B# +bxc8=B+ +bxc8=N# +bxc8=N+ +bxc8=Q# +bxc8=Q+ +bxc8=R# +bxc8=R+ +cxb1=B# +cxb1=B+ +cxb1=N# +cxb1=N+ +cxb1=Q# +cxb1=Q+ +cxb1=R# +cxb1=R+ +cxb8=B# +cxb8=B+ +cxb8=N# +cxb8=N+ +cxb8=Q# +cxb8=Q+ +cxb8=R# +cxb8=R+ +cxd1=B# +cxd1=B+ +cxd1=N# +cxd1=N+ +cxd1=Q# +cxd1=Q+ +cxd1=R# +cxd1=R+ +cxd8=B# +cxd8=B+ +cxd8=N# +cxd8=N+ +cxd8=Q# +cxd8=Q+ +cxd8=R# +cxd8=R+ +dxc1=B# +dxc1=B+ +dxc1=N# +dxc1=N+ +dxc1=Q# +dxc1=Q+ +dxc1=R# +dxc1=R+ +dxc8=B# +dxc8=B+ +dxc8=N# +dxc8=N+ +dxc8=Q# +dxc8=Q+ +dxc8=R# +dxc8=R+ +dxe1=B# +dxe1=B+ +dxe1=N# +dxe1=N+ +dxe1=Q# +dxe1=Q+ +dxe1=R# +dxe1=R+ +dxe8=B# +dxe8=B+ +dxe8=N# +dxe8=N+ +dxe8=Q# +dxe8=Q+ +dxe8=R# +dxe8=R+ +exd1=B# +exd1=B+ +exd1=N# +exd1=N+ +exd1=Q# +exd1=Q+ +exd1=R# +exd1=R+ +exd8=B# +exd8=B+ +exd8=N# +exd8=N+ +exd8=Q# +exd8=Q+ +exd8=R# +exd8=R+ +exf1=B# +exf1=B+ +exf1=N# +exf1=N+ +exf1=Q# +exf1=Q+ +exf1=R# +exf1=R+ +exf8=B# +exf8=B+ +exf8=N# +exf8=N+ +exf8=Q# +exf8=Q+ +exf8=R# +exf8=R+ +fxe1=B# +fxe1=B+ +fxe1=N# +fxe1=N+ +fxe1=Q# +fxe1=Q+ +fxe1=R# +fxe1=R+ +fxe8=B# +fxe8=B+ +fxe8=N# +fxe8=N+ +fxe8=Q# +fxe8=Q+ +fxe8=R# +fxe8=R+ +fxg1=B# +fxg1=B+ +fxg1=N# +fxg1=N+ +fxg1=Q# +fxg1=Q+ +fxg1=R# +fxg1=R+ +fxg8=B# +fxg8=B+ +fxg8=N# +fxg8=N+ +fxg8=Q# +fxg8=Q+ +fxg8=R# +fxg8=R+ +gxf1=B# +gxf1=B+ +gxf1=N# +gxf1=N+ +gxf1=Q# +gxf1=Q+ +gxf1=R# +gxf1=R+ +gxf8=B# +gxf8=B+ +gxf8=N# +gxf8=N+ +gxf8=Q# +gxf8=Q+ +gxf8=R# +gxf8=R+ +gxh1=B# +gxh1=B+ +gxh1=N# +gxh1=N+ +gxh1=Q# +gxh1=Q+ +gxh1=R# +gxh1=R+ +gxh8=B# +gxh8=B+ +gxh8=N# +gxh8=N+ +gxh8=Q# +gxh8=Q+ +gxh8=R# +gxh8=R+ +hxg1=B# +hxg1=B+ +hxg1=N# +hxg1=N+ +hxg1=Q# +hxg1=Q+ +hxg1=R# +hxg1=R+ +hxg8=B# +hxg8=B+ +hxg8=N# +hxg8=N+ +hxg8=Q# +hxg8=Q+ +hxg8=R# +hxg8=R+ diff --git a/torchrl/envs/transforms/transforms.py b/torchrl/envs/transforms/transforms.py index 3cba7d2bd1f..65eda4bc6ec 100644 --- a/torchrl/envs/transforms/transforms.py +++ b/torchrl/envs/transforms/transforms.py @@ -861,7 +861,9 @@ def rand_action(self, tensordict: Optional[TensorDictBase] = None) -> TensorDict f"The rand_action method from the base env {self.base_env.__class__.__name__} " "has been overwritten, but the transforms appended to the environment modify " "the action. To call the base env rand_action method, we should then invert the " - "action transform, which is (in general) not doable." + "action transform, which is (in general) not doable. " + f"The full action spec of the base env is: {self.base_env.full_action_spec}, \n" + f"the full action spec of the transformed env is {self.full_action_spec}." ) return self.base_env.rand_action(tensordict) return super().rand_action(tensordict) @@ -5070,23 +5072,73 @@ def transform_input_spec(self, input_spec: Composite) -> Composite: # We need to cap the spec to generate valid random strings for out_key in self.out_keys_inv: if out_key in input_spec["full_state_spec"].keys(True, True): + new_shape = input_spec["full_state_spec"][out_key].shape + if self.max_length is None: + # Then we can't tell what the shape will be + new_shape = new_shape[:-1] + torch.Size((-1,)) input_spec["full_state_spec"][out_key] = Bounded( 0, self.tokenizer.vocab_size, - shape=input_spec["full_state_spec"][out_key].shape, + shape=new_shape, device=input_spec["full_state_spec"][out_key].device, dtype=input_spec["full_state_spec"][out_key].dtype, ) elif out_key in input_spec["full_action_spec"].keys(True, True): + new_shape = input_spec["full_action_spec"][out_key].shape + if self.max_length is None: + # Then we can't tell what the shape will be + new_shape = new_shape[:-1] + torch.Size((-1,)) input_spec["full_action_spec"][out_key] = Bounded( 0, self.tokenizer.vocab_size, - shape=input_spec["full_action_spec"][out_key].shape, + shape=new_shape, device=input_spec["full_action_spec"][out_key].device, dtype=input_spec["full_action_spec"][out_key].dtype, ) return input_spec + def transform_output_spec(self, output_spec: Composite) -> Composite: + output_spec = super().transform_output_spec(output_spec) + # We need to cap the spec to generate valid random strings + for out_key in self.out_keys: + if out_key in output_spec["full_observation_spec"].keys(True, True): + new_shape = output_spec["full_observation_spec"][out_key].shape + if self.max_length is None: + # Then we can't tell what the shape will be + new_shape = new_shape[:-1] + torch.Size((-1,)) + output_spec["full_observation_spec"][out_key] = Bounded( + 0, + self.tokenizer.vocab_size, + shape=new_shape, + device=output_spec["full_observation_spec"][out_key].device, + dtype=output_spec["full_observation_spec"][out_key].dtype, + ) + elif out_key in output_spec["full_reward_spec"].keys(True, True): + new_shape = output_spec["full_reward_spec"][out_key].shape + if self.max_length is None: + # Then we can't tell what the shape will be + new_shape = new_shape[:-1] + torch.Size((-1,)) + output_spec["full_reward_spec"][out_key] = Bounded( + 0, + self.tokenizer.vocab_size, + shape=new_shape, + device=output_spec["full_reward_spec"][out_key].device, + dtype=output_spec["full_reward_spec"][out_key].dtype, + ) + elif out_key in output_spec["full_done_spec"].keys(True, True): + new_shape = output_spec["full_done_spec"][out_key].shape + if self.max_length is None: + # Then we can't tell what the shape will be + new_shape = new_shape[:-1] + torch.Size((-1,)) + output_spec["full_done_spec"][out_key] = Bounded( + 0, + self.tokenizer.vocab_size, + shape=new_shape, + device=output_spec["full_done_spec"][out_key].device, + dtype=output_spec["full_done_spec"][out_key].dtype, + ) + return output_spec + class Stack(Transform): """Stacks tensors and tensordicts. diff --git a/torchrl/envs/utils.py b/torchrl/envs/utils.py index 878df8dad07..02d13c4924a 100644 --- a/torchrl/envs/utils.py +++ b/torchrl/envs/utils.py @@ -1391,7 +1391,7 @@ def _update_during_reset( # get the reset signal reset = tensordict.pop(reset_key, None) - # check if this reset should be ignored -- this happens whenever the a + # check if this reset should be ignored -- this happens whenever the # root node has already been updated root = () if isinstance(reset_key, str) else reset_key[:-1] processed = any(reset_key_tuple[: len(x)] == x for x in roots)