diff --git a/open_spiel/games/CMakeLists.txt b/open_spiel/games/CMakeLists.txt index 6d374d9a77..0b30813f7c 100644 --- a/open_spiel/games/CMakeLists.txt +++ b/open_spiel/games/CMakeLists.txt @@ -90,6 +90,10 @@ set(GAME_SOURCES hearts/hearts.h hex/hex.cc hex/hex.h + hive/hive.cc + hive/hive.h + hive/hive_board.cc + hive/hive_board.h kriegspiel/kriegspiel.cc kriegspiel/kriegspiel.h kuhn_poker/kuhn_poker.cc @@ -461,6 +465,10 @@ add_executable(hex_test hex/hex_test.cc ${OPEN_SPIEL_OBJECTS} $) add_test(hex_test hex_test) +add_executable(hive_test hive/hive_test.cc ${OPEN_SPIEL_OBJECTS} + $) +add_test(hive_test hive_test) + add_executable(kriegspiel_test kriegspiel/kriegspiel_test.cc ${OPEN_SPIEL_OBJECTS} $) add_test(kriegspiel_test kriegspiel_test) diff --git a/open_spiel/games/hive/README.md b/open_spiel/games/hive/README.md new file mode 100644 index 0000000000..e24422dcfa --- /dev/null +++ b/open_spiel/games/hive/README.md @@ -0,0 +1,70 @@ +# Hive + +Implements the base game of [Hive](https://www.gen42.com/games/hive) and its three expansion pieces: Mosquito, Ladybug, and Pillbug. + +![Picture of playing on the console:](https://imgur.com/mkEObfx.png) + +*
Example game state viewed on the command-line (left) and with an external viewer "Mzinga" (right)
* + +This implementation follows the rules outlined by the Universal Hive Protocol ([UHP](https://github.com/jonthysell/Mzinga/wiki/UniversalHiveProtocol)), which means states can be serialized to and deserialized from valid UHP game strings. With a bit of I/O handling, this can also be used as a UHP-compliant Hive Engine, making interactions with other engines straightforward. + +## State + +### Observation Tensor + +First, the hexagonal grid needs to be represented as a rectangular one for 2D convolution: + +![Storing a hexagonal grid in a 2D array](https://imgur.com/CIy5ctM.png) + +*
Example transformation - taken from [RedBlobGames](https://www.redblobgames.com/grids/hexagons/#map-storage)
* + +The observation tensor then takes the form of multiple 2D feature planes describing the board and turn state, similar to what was done for AlphaZero chess. + +However, since Hive's "board" is a repeating hexagonal tiling, the size is bounded only by the maximum number of tiles that can be laid in a straight line (28 total tiles for all expansions). Yet, a grid of size 28x28 is far too large to be computationally practical. + +To help offset the complications this would bring for training in AlphaZero, the board can be paramaterized with `board_size` to reduce the tensor's overall sparsity. Using a `board_size` smaller than `kMaxBoardSize` means that some outlier games cannot be perfectly represented and are instead forced to a Draw. In practice, games that would approach that board length are extremely rare, so the trade-off feels acceptable. + +The 2D feature planes are one-hot encodings that indicate: + +- the presence of a particular bug type, for each player +- which bugs are pinned +- which bugs are covered +- the available positions that each player can place a new bug tile +- all 1's or all 0's to distinguish the current player's turn + +### Action Space + +**An action in Hive is described as:** +1) choosing which tile to move +2) choosing which tile it moves next to (or on top of) +3) the relative direction of the tile it moves next to + +*e.g.* "wA2 bL/" - *White moves their 2nd Ant to the top right edge of Black's Ladybug* + +With there being 28 unique tiles and 7 directions (the 6 hexagonal edges and "above"), the action space can be thought of as entries into a 3D matrix with dimensions **7 x 28 x 28** = **5488** total actions. + +This is not a *perfect* action space representation as there are a handful of unused actions (e.g. moving a tile next to itself?), but it does capture every legal move. Unfortunately, with the introduction of the Pillbug, each player is able to move their own piece *or* the enemy's, meaning we can't implicitly expect the tile being moved to be the colour of the current player. This ends up doubling the action space size from 7x14x28 to 7x28x28 + +## To-do + +Below are some concrete features and fixes I intend to implement to either help speed up training or improve the interoperability between other Hive software (e.g. displaying games directly to [MzingaViewer](https://github.com/jonthysell/Mzinga)): + +- [ ] Address the efficiency of code that uses the most compute time (`HiveState::GenerateValidSlides()` and `HiveState::IsGated()` from recent perf tests) +- [ ] Implement zobrist hashing to handle a "3-repeated moves" forced draw (unofficial community rule) +- [ ] Undo() +- [ ] Perft() +- [ ] Make it possible to load many UHP gamestrings from a file for training, or to collect interesting game statistics +- [ ] Create a separate binary that handles I/O and behaves as a proper UHP-compliant engine +- [ ] Provide a simplified action space for games that do not use expansion pieces + +## Future Improvements / Thoughts + +While developing this engine, I came across many interesting ideas that have the potential for serious progress towards a viable expert-level AZ-bot for Hive. And as of this submission, no such Hive AI exists, making the prospect of any improvements much more appealing. + +Below is a record of those miscellaneous thoughts, in approximate order of the potential I think it has: + +- **Design a more exact action space**. There are a handful of other suggested notations from the Hive community, each with their own advantages and drawbacks, that may be useful to look into for an alternative action space. One that looks very promising is [Direction-Based Notation](https://psoukenik.medium.com/direction-based-notation-for-hive-dd7fd234d4d), as it implicitly covers all rotations and reflections by design. + +- **Use a Hexagonal CNN model or filter**. One problem that has been conveniently unaddressed is the fact that 2D convolution is performed on Hexagonal data that has be refitted onto a square. The typical 3x3 filter then doesn't accurately describe the 6 neighbours of a hex, as 2 extra values are contained in the filter. One option would be to use a custom 3x3 filter that zeroes-out the two values along the diagonal, or to attempt using a more advanced implementation like [HexCNN](https://arxiv.org/pdf/2101.10897) or [Rotational-Invariant CNN](https://www.jstage.jst.go.jp/article/transinf/E107.D/2/E107.D_2023EDP7023/_pdf/-char/en). The first option would be much easier to implement into the existing AlphaZero framework. + +- **Attempt a graph/node-based representation**. With how a game of Hive is structed like a graph itself, I think there is potential in using Graph Neural Networks (GNN) for learning. Some recent research has been done by applying [GNNs to AlphaZero for board game AI](https://arxiv.org/pdf/2107.08387), which indicates there is at least some proven success already. diff --git a/open_spiel/games/hive/hive.cc b/open_spiel/games/hive/hive.cc new file mode 100644 index 0000000000..2d31cad802 --- /dev/null +++ b/open_spiel/games/hive/hive.cc @@ -0,0 +1,580 @@ +// Copyright 2024 DeepMind Technologies Limited +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "open_spiel/games/hive/hive.h" + +#include +#include +#include +#include +#include +#include + +#include "open_spiel/abseil-cpp/absl/algorithm/container.h" +#include "open_spiel/abseil-cpp/absl/strings/str_format.h" +#include "open_spiel/abseil-cpp/absl/strings/str_split.h" +#include "open_spiel/game_parameters.h" +#include "open_spiel/spiel_utils.h" +#include "open_spiel/utils/tensor_view.h" + +namespace open_spiel { +namespace hive { +namespace { + +// Facts about the game. +const GameType kGameType{/*short_name=*/"hive", + /*long_name=*/"Hive", + GameType::Dynamics::kSequential, + GameType::ChanceMode::kDeterministic, + GameType::Information::kPerfectInformation, + GameType::Utility::kZeroSum, + GameType::RewardModel::kTerminal, + /*max_num_players=*/2, + /*min_num_players=*/2, + /*provides_information_state_string=*/true, + /*provides_information_state_tensor=*/false, + /*provides_observation_string=*/true, + /*provides_observation_tensor=*/true, + /*parameter_specification=*/ + { + // the radius of the underlying hexagonal grid. + // customisable to reduce computational complexity + // where needed. Max size of 14. + {"board_size", GameParameter(kDefaultBoardRadius)}, + // expansion pieces, included by default + {"uses_mosquito", GameParameter(true)}, + {"uses_ladybug", GameParameter(true)}, + {"uses_pillbug", GameParameter(true)}, + {"ansi_color_output", GameParameter(false)}, + }}; + +std::shared_ptr Factory(const GameParameters& params) { + return std::shared_ptr(new HiveGame(params)); +} + +REGISTER_SPIEL_GAME(kGameType, Factory); + +RegisterSingleTensorObserver single_tensor(kGameType.short_name); + +} // namespace + +HiveState::HiveState(std::shared_ptr game, int board_size, + ExpansionInfo expansions, int num_bug_types, + bool ansi_color_output) + : State(game), + expansions_(expansions), + board_(std::min(board_size, kMaxBoardRadius), expansions), + num_bug_types_(num_bug_types), + ansi_color_output_(ansi_color_output), + force_terminal_(false) {} + +std::string HiveState::ActionToString(Player player, Action action_id) const { + return ActionToMove(action_id).ToUHP(); +} + +std::string HiveState::ToString() const { + if (!ansi_color_output_) { + return Serialize(); + } + + static std::string white = "\033[38;5;223m"; // white-beige-ish + static std::string black = "\033[1;31m"; // using red to represent black + static std::string reset = "\033[1;39m"; + static float indent_size = 2.5f; + + std::string string = "\n"; + string.reserve(Board().SquareDimensions() * Board().SquareDimensions() * 5); + std::vector top_tiles; + + // loop over valid Q, R, to generate a hexagon + int radius = Board().Radius(); + for (int r = -radius; r <= radius; ++r) { + // indent based on which row we are on (r). Intentionally taking the floor + // to offset odd numbered rows + int num_spaces = std::abs(r) * indent_size; + for (int i = 0; i < num_spaces; ++i) { + absl::StrAppend(&string, " "); + } + + // print each tile on row r by iterating valid q indices + for (int q = std::max(-radius, -r - radius); + q <= std::min(radius, -r + radius); ++q) { + HiveTile tile = Board().GetTopTileAt({q, r}); + + std::ostringstream oss; + if (tile.HasValue()) { + if (tile.GetColour() == Colour::kWhite) { + oss << white; + } else { + oss << black; + } + + std::string uhp = tile.ToUHP(); + if (Board().GetPositionOf(tile).H() > 0) { + uhp = absl::StrCat("^", uhp); + top_tiles.push_back(tile); + } + + // print the tile's UHP representation, or "-" otherwise, centered + // around a padded 5 char long string + int left_padding = (5 - uhp.size()) / 2; + int right_padding = (5 - uhp.size()) - left_padding; + for (int i = 0; i < left_padding; ++i) { + oss << ' '; + } + + oss << uhp; + + // use an asterisk to indicate this bug was most recently moved + if (tile == Board().LastMovedTile()) { + oss << "*"; + --right_padding; + } + + for (int i = 0; i < right_padding; ++i) { + oss << ' '; + } + + oss << reset; + } else { + // use an asterisk to indicate the location of the last moved tile + if (Board().LastMovedTile().HasValue() && + Board().LastMovedFrom() == HivePosition(q, r)) { + if (Board().LastMovedTile().GetColour() == Colour::kWhite) { + oss << white; + } else { + oss << black; + } + + oss << " * " << reset; + } else { + oss << " - " << reset; + } + } + absl::StrAppend(&string, oss.str()); + } + absl::StrAppend(&string, "\n\n"); + } + + // print bug stacks + for (auto tile : top_tiles) { + HivePosition pos = Board().GetPositionOf(tile); + absl::StrAppend(&string, tile.ToUHP()); + + HiveTile below = Board().GetTileBelow(pos); + while (below.HasValue()) { + absl::StrAppend(&string, " > ", below.ToUHP()); + + pos += {0, 0, -1}; + if (pos.H() <= 0) { + break; + } + + below = Board().GetTileBelow(pos); + } + + absl::StrAppend(&string, "\n"); + } + + return string; +} + +// e.g. the string "wA2 /bQ" translates to: "Move White's 2nd Ant to the +// south-west of Black's Queen" +Action HiveState::StringToAction(Player player, + const std::string& move_str) const { + // pass move? + if (move_str == "pass") { + return PassAction(); + } + + Move move; + move.direction = Direction::kNumAllDirections; + std::vector bugs = absl::StrSplit(move_str, " "); + SPIEL_DCHECK_GT(bugs.size(), 0); + SPIEL_DCHECK_LE(bugs.size(), 2); + + // first bug should always be valid + move.from = HiveTile::UHPToTile(bugs[0]); + if (!move.from.HasValue()) { + SpielFatalError("HiveState::StringToAction() - invalid move string: " + + move_str); + } + + // special case: if only one bug is provided, it is a 1st turn move + if (bugs.size() == 1) { + return MoveToAction(move); + } + + // get second bug and its relative direction + char c = bugs[1].front(); + if (c == '\\') { + move.direction = Direction::kNW; + } else if (c == '-') { + move.direction = Direction::kW; + } else if (c == '/') { + move.direction = Direction::kSW; + } + + // check last char if we haven't found a direction + if (move.direction == Direction::kNumAllDirections) { + c = bugs[1].back(); + if (c == '\\') { + move.direction = Direction::kSE; + } else if (c == '-') { + move.direction = Direction::kE; + } else if (c == '/') { + move.direction = Direction::kNE; + } + } + + // if still no direction, it must be above + if (move.direction == Direction::kNumAllDirections) { + move.direction = Direction::kAbove; + } + + // now extract just the bug + ordinal from string + size_t start_index = bugs[1].find_first_not_of("\\-/"); + size_t end_index = bugs[1].find_last_not_of("\\-/"); + move.to = HiveTile::UHPToTile( + bugs[1].substr(start_index, end_index - start_index + 1)); + + return MoveToAction(move); +} + +std::vector HiveState::Returns() const { + bool white_winner = WinConditionMet(kPlayerWhite); + bool black_winner = WinConditionMet(kPlayerBlack); + + if (white_winner ^ black_winner) { + return {white_winner ? 1.f : -1.f, black_winner ? 1.f : -1.f}; + } + + return {0, 0}; +} + +std::string HiveState::InformationStateString(Player player) const { + SPIEL_CHECK_GE(player, 0); + SPIEL_CHECK_LT(player, num_players_); + return HistoryString(); +} + +std::string HiveState::ObservationString(Player player) const { + SPIEL_CHECK_GE(player, 0); + SPIEL_CHECK_LT(player, num_players_); + return ToString(); +} + +void HiveState::ObservationTensor(Player player, + absl::Span values) const { + SPIEL_CHECK_GE(player, 0); + SPIEL_CHECK_LT(player, num_players_); + + // starting indices for each 2D feature plane, variable based on expansions + int articulation_idx = num_bug_types_ * num_players_; + int placeable_idx = articulation_idx + 2; + int covered_idx = placeable_idx + 2; + int turn_idx = covered_idx + 2; + + // Treat values as a 3d-tensor, where each feature plane has square dimensions + // (radius * 2 + 1) x (radius * 2 + 1), and contains one-hot encodings of the + // current board state + TensorView<3> view(values, + {game_->ObservationTensorShape()[0], + Board().SquareDimensions(), Board().SquareDimensions()}, + true); + + int plane_idx = 0; + Colour my_colour = PlayerToColour(player); + Colour opposing_colour = OtherColour(my_colour); + + // populate all planes that reference a tile in play + for (auto tile : Board().GetPlayedTiles()) { + HivePosition pos = Board().GetPositionOf(tile); + std::array indices = AxialToTensorIndex(pos); + bool is_opposing = tile.GetColour() == opposing_colour; + + // bug type planes + plane_idx = BugTypeToTensorIndex(tile.GetBugType()) + + (is_opposing ? num_bug_types_ : 0); + view[{plane_idx, indices[0], indices[1]}] = 1.0f; + + // pinned plane + plane_idx = articulation_idx + (is_opposing ? 1 : 0); + if (Board().IsPinned(pos)) { + view[{plane_idx, indices[0], indices[1]}] = 1.0f; + } + + // covered plane + plane_idx = covered_idx + (is_opposing ? 1 : 0); + if (Board().IsCovered(tile)) { + view[{plane_idx, indices[0], indices[1]}] = 1.0f; + } + } + + // populate all planes that reference a specific position + int radius = Board().Radius(); + for (int r = -radius; r <= radius; ++r) { + for (int q = -radius; q <= radius; ++q) { + HivePosition pos = {q, r, 0}; + std::array indices = AxialToTensorIndex(pos); + + // current player's turn + view[{turn_idx, indices[0], indices[1]}] = + static_cast(current_player_); + + // player and opponent's placeable positions + if (Board().IsPlaceable(my_colour, pos)) { + view[{placeable_idx, indices[0], indices[1]}] = 1.0f; + } else if (Board().IsPlaceable(opposing_colour, pos)) { + view[{placeable_idx + 1, indices[0], indices[1]}] = 1.0f; + } + } + } +} + +std::unique_ptr HiveState::Clone() const { + return std::unique_ptr(new HiveState(*this)); +} + +std::vector HiveState::LegalActions() const { + if (IsTerminal()) { + return {}; + } + + std::vector moves; + std::set unique_actions; + + Board().GenerateAllMoves(&moves, PlayerToColour(current_player_), + move_number_); + std::transform(moves.begin(), moves.end(), + std::inserter(unique_actions, unique_actions.end()), + [this](Move& m) { return MoveToAction(m); }); + + std::vector actions(unique_actions.begin(), unique_actions.end()); + + // if a player has no legal actions, then they must pass + if (actions.size() == 0) { + actions.push_back(PassAction()); + } + + return actions; +} + +std::string HiveState::Serialize() const { + return absl::StrJoin( + {UHPGameString(), UHPProgressString(), UHPTurnString(), UHPMovesString()}, + ";", [](std::string* out, const absl::string_view& t) { + if (!t.empty()) { + absl::StrAppend(out, t); + } + }); +} + +Move HiveState::ActionToMove(Action action) const { + // pass action + if (action == PassAction()) { + return Move{HiveTile::kNoneTile, HiveTile::kNoneTile, + Direction::kNumAllDirections}; + } + + int64_t direction = action % Direction::kNumAllDirections; + int64_t to = (action / Direction::kNumAllDirections) % kMaxTileCount; + int64_t from = action / (kMaxTileCount * Direction::kNumAllDirections); + + // special case: for the first turn actions, they are encoded as playing a + // tile on top of itself. In this case, we want "to" to be kNoneTile + if (from == to && direction == Direction::kAbove) { + to = HiveTile::kNoneTile; + } + + return Move{from, to, static_cast(direction)}; +} + +Action HiveState::MoveToAction(Move move) const { + // pass move encoded as "moving no tile" + if (move.IsPass()) { + return PassAction(); + } + + // if there is no second bug "to", then we have a special case for first turn + if (!move.to.HasValue()) { + return (move.from * (kMaxTileCount * Direction::kNumAllDirections)) + + (move.from * Direction::kNumAllDirections) + Direction::kAbove; + } + + // as if indexing into a 3d array with indices [from][to][direction] + return (move.from * (kMaxTileCount * Direction::kNumAllDirections)) + + (move.to * Direction::kNumAllDirections) + move.direction; +} + +std::string HiveState::UHPGameString() const { + return absl::StrFormat("Base%s%s%s%s", expansions_.HasAny() ? "+" : "", + expansions_.uses_mosquito ? "M" : "", + expansions_.uses_ladybug ? "L" : "", + expansions_.uses_pillbug ? "P" : ""); +} + +std::string HiveState::UHPProgressString() const { + if (move_number_ == 0) { + return kUHPNotStarted; + } + + if (move_number_ > game_->MaxGameLength()) { + return kUHPDraw; + } + + if (IsTerminal()) { + auto returns = Returns(); + if (returns[kPlayerWhite] > returns[kPlayerBlack]) { + return kUHPWhiteWins; + } else if (returns[kPlayerWhite] < returns[kPlayerBlack]) { + return kUHPBlackWins; + } else { + return kUHPDraw; + } + } + + return kUHPInProgress; +} + +std::string HiveState::UHPTurnString() const { + return absl::StrFormat("%s[%d]", + current_player_ == kPlayerWhite ? "White" : "Black", + (move_number_ + 2) / 2); +} + +std::string HiveState::UHPMovesString() const { + return absl::StrJoin(ActionsToStrings(*this, History()), ";"); +} + +size_t HiveState::BugTypeToTensorIndex(BugType type) const { + size_t index = 0; + for (uint8_t i = 0; i < static_cast(BugType::kNumBugTypes); ++i) { + if (expansions_.IsBugTypeEnabled(static_cast(i))) { + if (type == static_cast(i)) { + return index; + } + + ++index; + } + } + + return -1; +} + +// we assume the move is valid at this point and simply apply it +void HiveState::DoApplyAction(Action action) { + if (action == PassAction()) { + Board().Pass(); + } else { + bool success = Board().MoveTile(ActionToMove(action)); + + // if something has gone wrong, force end the game as a draw + // (should only happen with with reduced board_sizes that go out of bounds) + if (!success) { + force_terminal_ = true; + } + } + + current_player_ = (++current_player_) % kNumPlayers; +} + +HiveGame::HiveGame(const GameParameters& params) + : Game(kGameType, params), + board_radius_(ParameterValue("board_size")), + ansi_color_output_(ParameterValue("ansi_color_output")), + num_bug_types_(kNumBaseBugTypes), + expansions_({ParameterValue("uses_mosquito"), + ParameterValue("uses_ladybug"), + ParameterValue("uses_pillbug")}) { + if (expansions_.uses_mosquito) { + ++num_bug_types_; + } + + if (expansions_.uses_ladybug) { + ++num_bug_types_; + } + + if (expansions_.uses_pillbug) { + ++num_bug_types_; + } +} + +std::unique_ptr HiveGame::DeserializeState( + const std::string& str) const { + std::vector tokens = absl::StrSplit(str, ';'); + SPIEL_DCHECK_GE(tokens.size(), 3); + + // first substring is the game string (e.g. "Base+MLP" for all expansions). + // since we are already inside a const game object, verify that the UHP game + // string matches what we expect it to be at this point + SPIEL_DCHECK_TRUE(tokens[0].find("Base") != absl::string_view::npos); + if (expansions_.uses_mosquito) { + SPIEL_DCHECK_TRUE(tokens[0].find('M') != absl::string_view::npos); + } + if (expansions_.uses_ladybug) { + SPIEL_DCHECK_TRUE(tokens[0].find('L') != absl::string_view::npos); + } + if (expansions_.uses_pillbug) { + SPIEL_DCHECK_TRUE(tokens[0].find('P') != absl::string_view::npos); + } + + std::unique_ptr state = NewInitialState(); + if (tokens[1] == kUHPNotStarted) { + return state; + } + + // skip tokens[2] (turn string) as it is implicitly derived from the actions + for (int i = 3; i < tokens.size(); ++i) { + state->ApplyAction(state->StringToAction(std::string(tokens[i]))); + } + + // now verify state string (tokens[1]) + if (state->IsTerminal()) { + if (state->Returns()[kPlayerWhite] > 0) { + SPIEL_DCHECK_TRUE(tokens[1] == kUHPWhiteWins); + } else if (state->Returns()[kPlayerBlack] > 0) { + SPIEL_DCHECK_TRUE(tokens[1] == kUHPBlackWins); + } else { + SPIEL_DCHECK_TRUE(tokens[1] == kUHPDraw); + } + } else { + SPIEL_DCHECK_TRUE(tokens[1] == kUHPInProgress); + } + + return state; +} + +std::pair, std::unique_ptr> +DeserializeUHPGameAndState(const std::string& uhp_string) { + auto pos = uhp_string.find(';'); + auto game_str = uhp_string.substr(0, pos); + SPIEL_DCHECK_TRUE(game_str.find("Base") != std::string::npos); + + GameParameters params{}; + params["name"] = GameParameter(kGameType.short_name); + params["uses_mosquito"] = + GameParameter(game_str.find('M') != std::string::npos); + params["uses_ladybug"] = + GameParameter(game_str.find('L') != std::string::npos); + params["uses_pillbug"] = + GameParameter(game_str.find('P') != std::string::npos); + + auto game = LoadGame(params); + return {game, game->DeserializeState(uhp_string)}; +} + +} // namespace hive +} // namespace open_spiel diff --git a/open_spiel/games/hive/hive.h b/open_spiel/games/hive/hive.h new file mode 100644 index 0000000000..cb35a20215 --- /dev/null +++ b/open_spiel/games/hive/hive.h @@ -0,0 +1,222 @@ +// Copyright 2024 DeepMind Technologies Limited +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef OPEN_SPIEL_GAMES_HIVE_H_ +#define OPEN_SPIEL_GAMES_HIVE_H_ + +#include +#include +#include +#include +#include +#include +#include + +#include "open_spiel/games/hive/hive_board.h" +#include "open_spiel/spiel.h" + +// from https://en.wikipedia.org/wiki/Hive_(game): +// +// +// "The object of Hive is to capture the opponent's queen bee by allowing it +// to become completely surrounded by other pieces (belonging to either +// player), while avoiding the capture of one's own queen. Hive differs from +// other tile-based games in that the tiles, once placed, can then be moved to +// other positions according to various rules, much like chess pieces." +// +// +// The intent of this Hive implementation is to provide a representation of the +// board state and action space that is compatible for use in the Alpha Zero +// algorithm (or similar). +// +// This becomes particularly tricky as one of the most notable design choices +// in Hive is that it is played on an unbounded surface, with no concept of a +// grid shape or size outside of the total number of tiles present. With the +// tiles being hexagonal in shape, a classic 2D grid representation used in +// 2D convolution complicates things even further. +// +// This implementation aims to minimize the effects of such problems by +// providing bounded grid sizes to reduce computational complexity (most games +// stay within ~6 units of the inital tile in practice). More information can +// be found under the HiveBoard class. +// +// Another important feature is the support of the Universal Hive Protocol (UHP) +// (https://github.com/jonthysell/Mzinga/wiki/UniversalHiveProtocol) +// +// While not a fully compliant UHP-engine implementation (mainly missing the +// required I/O and commands), the board game and state can be serialized to and +// de-serialized from a valid UHP gamestring. This allows the ever-growing +// archive of Hive replay data to be used for model training. +// +// +// Parameters: +// "board_size" int radius of the underlying hexagonal board +// (default = 8) +// "uses_mosquito" bool Whether to use the Mosquito expansion tile. +// (default = true) +// "uses_ladybug" bool Whether to use the Ladybug expansion tile. +// (default = true) +// "uses_pillbug" bool Whether to use the Pillbug expansion tile. +// (default = true) +// "ansi_color_output" bool Whether to color the output for a terminal. +// (default = false) + +namespace open_spiel { +namespace hive { + +inline constexpr int kNumPlayers = 2; +inline constexpr int kNumBaseBugTypes = 5; +inline constexpr const char* kUHPNotStarted = "NotStarted"; +inline constexpr const char* kUHPInProgress = "InProgress"; +inline constexpr const char* kUHPWhiteWins = "WhiteWins"; +inline constexpr const char* kUHPBlackWins = "BlackWins"; +inline constexpr const char* kUHPDraw = "Draw"; + +// State of an in-play game. +class HiveState : public State { + public: + explicit HiveState(std::shared_ptr game, + int board_size = kDefaultBoardRadius, + ExpansionInfo expansions = {}, + int num_bug_types = kNumBaseBugTypes, + bool ansi_color_output = false); + + HiveState(const HiveState&) = default; + HiveState& operator=(const HiveState&) = default; + + Player CurrentPlayer() const override { + return IsTerminal() ? kTerminalPlayerId : current_player_; + } + + // prettyprints the board state when using ansi_color_output_, and + // prints the UHP string representation otherwise + std::string ToString() const override; + + std::string ActionToString(Player player, Action action_id) const override; + Action StringToAction(Player player, + const std::string& move_str) const override; + + bool IsTerminal() const override { + return WinConditionMet(kPlayerWhite) || WinConditionMet(kPlayerBlack) || + MoveNumber() >= game_->MaxGameLength() || force_terminal_; + } + std::vector Returns() const override; + std::string InformationStateString(Player player) const override; + std::string ObservationString(Player player) const override; + + // A 3d-tensor where each binary 2d-plane represents the features below. + // The # of feature planes varies based on the # of expansion tiles in use. + // Example feature plane indices with all expansion tiles: + // + // (0-7): current player's bugs in play for each of the 8 bug types + // (8-15): opposing player's bugs in play for each of the 8 bug types + // (16): current player's "pinned" bugs + // (17): opposing player's "pinned" bugs + // (18): current player's valid placement positions + // (19): opposing player's valid placement positions + // (20): current player's "covered" bugs + // (21): opposing player's "covered" bugs + // (22): all 0's if it's White's turn, and all 1's if it's Black's turn + void ObservationTensor(Player player, + absl::Span values) const override; + std::unique_ptr Clone() const override; + std::vector LegalActions() const override; + + // serializes this state into a valid Universal Hive Protocol game string: + // GameTypeString;GameStateString;TurnString;MoveString1;...;MoveStringN + // https://github.com/jonthysell/Mzinga/wiki/UniversalHiveProtocol#gamestring + std::string Serialize() const override; + + HiveBoard& Board() { return board_; } + const HiveBoard& Board() const { return board_; } + + Move ActionToMove(Action action) const; + Action MoveToAction(Move move) const; + Action PassAction() const { return NumDistinctActions() - 1; } + std::string UHPGameString() const; + std::string UHPProgressString() const; + std::string UHPTurnString() const; + std::string UHPMovesString() const; + inline bool WinConditionMet(Player player) const { + return Board().IsQueenSurrounded(OtherColour(PlayerToColour(player))); + } + + protected: + void DoApplyAction(Action action) override; + + private: + // allows any combination of expansion pieces to be used for the observation + size_t BugTypeToTensorIndex(BugType type) const; + + // an axial coordinate at position (q, r) is stored at index [r][q] after + // translating the axial coordinate by the length of the radius + inline std::array AxialToTensorIndex(HivePosition pos) const { + return {pos.R() + Board().Radius(), pos.Q() + Board().Radius()}; + } + + Player current_player_ = kPlayerWhite; + HiveBoard board_; + ExpansionInfo expansions_; + int num_bug_types_; + bool ansi_color_output_; + bool force_terminal_; +}; + +class HiveGame : public Game { + public: + explicit HiveGame(const GameParameters& params); + + std::array ActionsShape() const { return {7, 28, 28}; } + int NumDistinctActions() const override { return 5488 + 1; } // +1 for pass + inline std::unique_ptr NewInitialState() const override { + return std::make_unique(shared_from_this(), board_radius_, + expansions_, num_bug_types_, + ansi_color_output_); + } + int NumPlayers() const override { return kNumPlayers; } + double MinUtility() const override { return -1; } + double MaxUtility() const override { return 1; } + absl::optional UtilitySum() const override { return 0; } + + std::vector ObservationTensorShape() const override { + return {num_bug_types_ * kNumPlayers // 2 * the # of bug types in play + + 2 // articulation point planes + + 2 // placeability planes + + 2 // covered planes + + 1, // player turn plane + 2 * board_radius_ + 1, // dimensions of a sq board from hex board + 2 * board_radius_ + 1}; + } + + int MaxGameLength() const override { return 500; } + std::unique_ptr DeserializeState( + const std::string& str) const override; + + ExpansionInfo GetExpansionInfo() const { return expansions_; } + + private: + int board_radius_; + int num_bug_types_; + bool ansi_color_output_; + ExpansionInfo expansions_; +}; + +// helper to construct a game and state from a properly formed UHP string +std::pair, std::unique_ptr> +DeserializeUHPGameAndState(const std::string& uhp_state); + +} // namespace hive +} // namespace open_spiel + +#endif // OPEN_SPIEL_GAMES_HIVE_H_ diff --git a/open_spiel/games/hive/hive_board.cc b/open_spiel/games/hive/hive_board.cc new file mode 100644 index 0000000000..9f7b9b9835 --- /dev/null +++ b/open_spiel/games/hive/hive_board.cc @@ -0,0 +1,915 @@ +// Copyright 2024 DeepMind Technologies Limited +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "open_spiel/games/hive/hive_board.h" + +#include +#include +#include +#include + +#include "open_spiel/spiel.h" + +namespace open_spiel { +namespace hive { + +HiveBoard::HiveBoard(int board_radius, ExpansionInfo expansions) + : hex_radius_(std::min(board_radius, kMaxBoardRadius)), + expansions_(expansions), + tile_grid_(SquareDimensions() * SquareDimensions()) {} + +void HiveBoard::GenerateAllMoves(std::vector* out_vec, Colour to_move, + int move_number) const { + GeneratePlacementMoves(out_vec, to_move, move_number); + + // generate legal moves for tiles in play (Queen must also be in play) + if (IsInPlay(to_move, BugType::kQueen)) { + for (auto tile : played_tiles_) { + if (tile.GetColour() == to_move && tile != last_moved_) { + GenerateMovesFor(out_vec, tile, tile.GetBugType(), to_move); + } + } + } +} + +void HiveBoard::GeneratePlacementMoves(std::vector* out, Colour to_move, + int move_number) const { + // first two moves in a game have special placement rules + // move 0: white must play a (non-queen) tile at the origin + if (move_number == 0) { + for (auto tile : HiveTile::GetTilesForColour(to_move)) { + if (tile.GetBugType() == BugType::kQueen) { + continue; + } + + if (!expansions_.IsBugTypeEnabled(tile.GetBugType())) { + continue; + } + + // playing the first tile at the origin is encoded as a move where + // a tile is placed "on top of nothing", i.e. from=tile, to=nullptr + out->emplace_back(Move{tile, HiveTile::kNoneTile, Direction::kAbove}); + } + + // move 1: black must play a (non-queen) tile next to white's first tile. + // this is the only time placing a tile next to an opponent's is allowed + } else if (move_number == 1) { + for (auto tile : HiveTile::GetTilesForColour(to_move)) { + if (tile.GetBugType() == BugType::kQueen) { + continue; + } + + if (!expansions_.IsBugTypeEnabled(tile.GetBugType())) { + continue; + } + + for (int i = 0; i < Direction::kNumCardinalDirections; ++i) { + out->emplace_back( + Move{tile, played_tiles_.front(), static_cast(i)}); + } + } + } else { + // Queen *must* be played by each player's 4th turn (8 total moves). For + // all other turns, find valid placement locations by computing a + // set difference of the player's influence positions + bool queen_placed = + move_number >= 8 || + IsInPlay(to_move == Colour::kWhite ? HiveTile::wQ : HiveTile::bQ); + for (auto tile : HiveTile::GetTilesForColour(to_move)) { + if (!expansions_.IsBugTypeEnabled(tile.GetBugType())) { + continue; + } + + if (IsInPlay(tile)) { + continue; + } + + // Queen *must* be played by each player's 4th turn + if ((move_number == 6 || move_number == 7) && !queen_placed && + tile.GetBugType() != BugType::kQueen) { + continue; + } + + // check all influence positions for validity + for (auto pos : colour_influence_[static_cast(to_move)]) { + if (GetTopTileAt(pos).HasValue()) { + continue; + } + + // skip - other player's tile is next to this spot + if (colour_influence_[static_cast(OtherColour(to_move))].contains( + pos)) { + continue; + } + + // for completeness, any neighbouring tile can be used as the reference. + // would be nice to have an alternative action space to limit this down + for (uint8_t i = 0; i < Direction::kNumCardinalDirections; ++i) { + HivePosition to_pos = pos + kNeighbourOffsets[i]; + HiveTile neighbour = GetTopTileAt(to_pos); + if (neighbour.HasValue()) { + out->emplace_back(Move{tile, neighbour, OppositeDirection(i)}); + } + } + } + } + } +} + +void HiveBoard::GenerateMovesFor(std::vector* out, HiveTile tile, + BugType acting_type, Colour to_move) const { + SPIEL_DCHECK_TRUE(expansions_.IsBugTypeEnabled(acting_type)); + + HivePosition start_pos = tile_positions_[tile]; + absl::flat_hash_set positions; + + // using an explicitly provided acting BugType to account for the Mosquito + switch (acting_type) { + case BugType::kQueen: + GenerateValidSlides(&positions, tile, start_pos, 1); + break; + + case BugType::kAnt: + GenerateValidSlides(&positions, tile, start_pos, -1); + break; + + case BugType::kGrasshopper: + GenerateValidGrasshopperPositions(&positions, tile, start_pos); + break; + + case BugType::kSpider: + GenerateValidSlides(&positions, tile, start_pos, 3); + break; + + case BugType::kBeetle: + GenerateValidClimbs(&positions, tile, start_pos); + if (start_pos.H() == 0) { + GenerateValidSlides(&positions, tile, start_pos, 1); + } + break; + + case BugType::kMosquito: + GenerateValidMosquitoPositions(out, tile, start_pos, to_move); + break; + + case BugType::kLadybug: + GenerateValidLadybugPositions(&positions, tile, start_pos); + break; + + case BugType::kPillbug: + GenerateValidSlides(&positions, tile, start_pos, 1); + GenerateValidPillbugSpecials(out, tile, start_pos); + break; + } + + // turn each position into moves by finding neighbouring tiles as reference + for (auto to_pos : positions) { + if (to_pos.H() > 0) { + // only generate kAbove moves when on top the hive + out->emplace_back(Move{tile, GetTopTileAt(to_pos), Direction::kAbove}); + } else { + // check for a valid reference tile in each cardinal direction + for (uint8_t dir = 0; dir < Direction::kNumCardinalDirections; ++dir) { + HiveTile neighbour = GetTopTileAt(to_pos + kNeighbourOffsets[dir]); + if (neighbour.HasValue()) { + if (start_pos.H() > 0 && neighbour == tile) { + // special case where the only neighbouring reference tile is itself + // on top of the stack, so use the tile directly below it + out->emplace_back( + Move{tile, GetTileBelow(start_pos), OppositeDirection(dir)}); + } else if (neighbour != tile) { + out->emplace_back(Move{tile, neighbour, OppositeDirection(dir)}); + } + } + } + } + } +} + +void HiveBoard::GenerateValidSlides(absl::flat_hash_set* out, + HiveTile tile, HivePosition start_pos, + int distance) const { + if (IsPinned(tile) || IsCovered(tile)) { + return; + } + + const bool unlimited_distance = distance < 0; + absl::flat_hash_set visited; + + auto dfs = [&](auto& dfs, HivePosition pos, Direction from, + int depth) -> void { + if (visited.contains(pos) || (!unlimited_distance && depth > distance)) { + return; + } + + // validate positions breadth-first + for (uint8_t dir = 0; dir < Direction::kNumCardinalDirections; ++dir) { + HivePosition to_test = pos + kNeighbourOffsets[dir]; + HiveTile test_tile = GetTopTileAt(to_test); + + if (dir == from) { + continue; + } + + if (visited.contains(to_test)) { + continue; + } + + // all must be false to be a valid slide direction + if (test_tile.HasValue() || + IsGated(pos, static_cast(dir), start_pos) || + !IsConnected(to_test, start_pos)) { + continue; + } + + if (depth == distance || unlimited_distance) { + out->insert(to_test); + } + } + + if (depth == distance) { + return; + } + + visited.insert(pos); + + // traverse depth-first + for (uint8_t dir = 0; dir < Direction::kNumCardinalDirections; ++dir) { + HivePosition to_test = pos + kNeighbourOffsets[dir]; + HiveTile test_tile = GetTopTileAt(to_test); + + if (dir == from) { + continue; + } + + if (visited.contains(to_test)) { + continue; + } + + // all must be false to be a valid slide direction + if (test_tile.HasValue() || + IsGated(pos, static_cast(dir), start_pos) || + !IsConnected(to_test, start_pos)) { + continue; + } + + if (depth == distance || unlimited_distance) { + out->insert(to_test); + } + + dfs(dfs, to_test, OppositeDirection(dir), depth + 1); + + if (!unlimited_distance) { + visited.erase(to_test); + } + } + }; + + dfs(dfs, start_pos, Direction::kNumAllDirections, 1); +} + +void HiveBoard::GenerateValidClimbs(absl::flat_hash_set* out, + HiveTile tile, + HivePosition start_pos) const { + if (IsPinned(tile) || IsCovered(tile)) { + return; + } + + HivePosition ground_pos = start_pos.Grounded(); + + // find the top tile, or an empty position, in each adjacent position + for (uint8_t d = 0; d < Direction::kNumCardinalDirections; ++d) { + HiveTile neighbour = GetTopTileAt(ground_pos + kNeighbourOffsets[d]); + if (neighbour.HasValue()) { + HivePosition to_pos = + tile_positions_[neighbour].NeighbourAt(Direction::kAbove); + // climbing UP: check for a gate at the *target*'s height + if (to_pos.H() > start_pos.H() && + !IsGated({start_pos.Q(), start_pos.R(), to_pos.H()}, + static_cast(d))) { + out->insert(to_pos); + // climbing DOWN or across: check for gate at *this* tile's height + } else if (to_pos.H() <= start_pos.H() && + !IsGated(start_pos, + static_cast( + d)) /*&& !position_cache_.contains(to_pos)*/) { + out->insert(to_pos); + } + } else { + HivePosition to_pos = ground_pos + kNeighbourOffsets[d]; + // climbing DOWN to empty space: check for a gate at *this* tile's height + if (to_pos.H() < start_pos.H() && + !IsGated(start_pos, + static_cast( + d)) /*&& !position_cache_.contains(to_pos)*/) { + out->insert(to_pos); + } + } + } +} + +void HiveBoard::GenerateValidGrasshopperPositions( + absl::flat_hash_set* out, HiveTile tile, + HivePosition start_pos) const { + if (IsPinned(tile) || IsCovered(tile)) { + return; + } + + // in each cardinal direction that contains a tile, jump over all tiles in + // that direction until reaching an empty space to land + for (uint8_t d = 0; d < Direction::kNumCardinalDirections; ++d) { + bool found = false; + HivePosition to_test = start_pos + kNeighbourOffsets[d]; + while (GetTopTileAt(to_test).HasValue()) { + to_test += kNeighbourOffsets[d]; + found = true; + } + + if (found) { + out->insert(to_test); + } + } +} + +void HiveBoard::GenerateValidLadybugPositions( + absl::flat_hash_set* out, HiveTile tile, + HivePosition start_pos) const { + if (IsPinned(tile) || IsCovered(tile)) { + return; + } + + // A lady bug moves in *exactly* 3 distinct steps: a climb onto the hive, + // a slide/climb across the hive, and a climb down from the hive + absl::flat_hash_set intermediates1; + absl::flat_hash_set intermediates2; + absl::flat_hash_set intermediates3; + + // step 1 + GenerateValidClimbs(&intermediates1, tile, start_pos); + + // step 2 + for (auto pos : intermediates1) { + GenerateValidClimbs(&intermediates2, tile, pos); + } + + // step 3 + for (auto pos : intermediates2) { + // ensure destination is above the hive but not "above itself" + if (pos.H() == 0 || + pos == start_pos + kNeighbourOffsets[Direction::kAbove]) { + continue; + } + + GenerateValidClimbs(&intermediates3, tile, pos); + } + + // only consider moves that finish on ground level + for (auto pos : intermediates3) { + if (pos.H() == 0) { + out->insert(pos); + } + } +} + +void HiveBoard::GenerateValidMosquitoPositions(std::vector* out, + HiveTile tile, + HivePosition start_pos, + Colour to_move) const { + // we defer IsPinned() check as the Mosquito could still use a Pillbug special + if (IsCovered(tile)) { + return; + } + + // when on top of the hive, a Mosquito can only act as a Beetle + if (start_pos.H() > 0) { + GenerateMovesFor(out, tile, BugType::kBeetle, to_move); + return; + } + + // Mosquitos copy the movement capabilities of any adjacent bug type + std::array(BugType::kNumBugTypes)> types_seen{}; + for (auto neighbour : NeighboursOf(start_pos)) { + BugType type = neighbour.GetBugType(); + + if (!types_seen[static_cast(type)]) { + types_seen[static_cast(type)] = true; + + if (type == BugType::kMosquito) { + continue; + } + + // Queen and Spider moves are strict subsets of an Ant's moves + if ((type == BugType::kQueen || type == BugType::kSpider) && + types_seen[static_cast(BugType::kAnt)]) { + continue; + } + + GenerateMovesFor(out, tile, type, to_move); + } + } +} + +void HiveBoard::GenerateValidPillbugSpecials(std::vector* out, + HiveTile tile, + HivePosition start_pos) const { + // Pillbug can still perform its special when Pinned + if (IsCovered(tile)) { + return; + } + + std::vector valid_targets; + std::vector valid_positions; + + for (uint8_t dir = 0; dir < Direction::kNumCardinalDirections; ++dir) { + // ensure there is no "gate" blocking above for this direction + if (IsGated(start_pos + kNeighbourOffsets[Direction::kAbove], + static_cast(dir))) { + continue; + } + + HivePosition test_pos = start_pos + kNeighbourOffsets[dir]; + HiveTile test_tile = GetTopTileAt(test_pos); + if (test_tile.HasValue()) { + // valid IFF the target tile is not: Pinned, Covered, the LastMovedTile, + // or above the hive + if (!IsPinned(test_tile) && !IsCovered(test_tile) && + test_tile != LastMovedTile() && GetPositionOf(test_tile).H() == 0) { + valid_targets.push_back(test_tile); + } + } else { + valid_positions.push_back(test_pos); + } + } + + // for every target_tile, add a move to every valid position by checking + // that position for its neighbours + for (auto target_tile : valid_targets) { + for (auto target_pos : valid_positions) { + for (uint8_t dir = 0; dir < Direction::kNumCardinalDirections; ++dir) { + HiveTile ref_tile = GetTopTileAt(target_pos + kNeighbourOffsets[dir]); + if (ref_tile.HasValue() && ref_tile != target_tile) { + out->emplace_back( + Move{target_tile, ref_tile, + OppositeDirection(static_cast(dir))}); + } + } + } + } +} + +std::vector HiveBoard::NeighboursOf(HivePosition pos, + HivePosition to_ignore) const { + std::vector neighbours; + for (auto neighbour : pos.Neighbours()) { + auto tile = GetTopTileAt(neighbour); + if (tile.HasValue()) { + neighbours.push_back(tile); + } + } + + return neighbours; +} + +bool HiveBoard::MoveTile(Move move) { + SPIEL_DCHECK_TRUE(move.from.HasValue()); + + // compute the final position from the reference tile + direction + HivePosition new_pos; + if (move.to.HasValue()) { + new_pos = tile_positions_[move.to] + kNeighbourOffsets[move.direction]; + + if (IsOutOfBounds(new_pos)) { + if (RecenterBoard(new_pos)) { + new_pos = tile_positions_[move.to] + kNeighbourOffsets[move.direction]; + } else { + // if the new position is still out of bounds, force terminate the game + // as a draw (possible with board_sizes smaller than kMaxBoardRadius) + return false; + } + } + + // if the reference tile was higher on the hive, the new_pos may need to + // "fall down" until it hits either the ground or another tile + if (new_pos.H() > 0) { + HiveTile top_tile = GetTopTileAt(new_pos); + if (top_tile.HasValue()) { + new_pos.SetH(tile_positions_[top_tile].H() + 1); + } else { + new_pos.SetH(0); + } + } + + } else { + // having no "to" tile encodes the opening move at the origin + new_pos = kOriginPosition; + } + + HivePosition old_pos = tile_positions_[move.from]; + if (old_pos == kNullPosition) { + played_tiles_.push_back(move.from); + } + + if (new_pos != old_pos) { + last_moved_from_ = old_pos; + } + + size_t old_idx = AxialToIndex(old_pos); + size_t new_idx = AxialToIndex(new_pos); + + // if a tile already exists at the new position, it's now condsidered covered + if (tile_grid_[new_idx].HasValue()) { + for (int i = 0; i < covered_tiles_.size(); ++i) { + if (!covered_tiles_[i].HasValue()) { + covered_tiles_[i] = tile_grid_[new_idx]; + break; + } + } + } + + // perform the move + tile_grid_[new_idx] = move.from; + tile_positions_[move.from] = new_pos; + last_moved_ = move.from; + + // potentially reinstate a covered tile at the old position + HiveTile old_tile = GetTopTileAt(old_pos); + if (old_pos.H() > 0) { + // reverse iterating guarantees the first tile found has the next highest H + for (int i = covered_tiles_.size() - 1; i >= 0; --i) { + if (covered_tiles_[i] == HiveTile::kNoneTile) { + continue; + } + + if (old_pos.Grounded() == GetPositionOf(covered_tiles_[i]).Grounded()) { + tile_grid_[old_idx] = covered_tiles_[i]; + covered_tiles_[i] = HiveTile::kNoneTile; + + // left-rotate the kNoneTile to the end of the covered_tiles_ array + // to maintain height order + std::rotate(covered_tiles_.begin() + i, covered_tiles_.begin() + i + 1, + covered_tiles_.end()); + break; + } + } + } else if (old_pos != kNullPosition) { + tile_grid_[old_idx] = HiveTile::kNoneTile; + } + + // update influence of the moved tile's colour. Potentially have to update + // both influences if the moved tile was part of a stack + UpdateInfluence(move.from.GetColour()); + if (old_pos.H() > 0 || new_pos.H() > 0) { + UpdateInfluence(OtherColour(move.from.GetColour())); + } + + UpdateArticulationPoints(); + + return true; +} + +bool HiveBoard::IsOutOfBounds(HivePosition pos) const { + return pos.DistanceTo(kOriginPosition) > hex_radius_; +} + +bool HiveBoard::RecenterBoard(HivePosition new_pos) { + int8_t max_Q = 0; + int8_t min_Q = 0; + int8_t max_R = 0; + int8_t min_R = 0; + int8_t max_S = 0; + int8_t min_S = 0; + + for (auto tile : played_tiles_) { + HivePosition pos = GetPositionOf(tile); + max_Q = std::max(max_Q, pos.Q()); + min_Q = std::min(min_Q, pos.Q()); + max_R = std::max(max_R, pos.R()); + min_R = std::min(min_R, pos.R()); + max_S = std::max(max_S, pos.S()); + min_S = std::min(min_S, pos.S()); + } + + // determine the new "center" by averaging each axis and round + // to the nearest integer hex coordinate + double avg_Q = (max_Q + min_Q) / 2.0; + double avg_R = (max_R + min_R) / 2.0; + double avg_S = (max_S + min_S) / 2.0; + + int8_t round_Q = std::round(avg_Q); + int8_t round_R = std::round(avg_R); + int8_t round_S = std::round(avg_S); + + double diff_Q = std::abs(round_Q - avg_Q); + double diff_R = std::abs(round_R - avg_R); + double diff_S = std::abs(round_S - avg_S); + + if (diff_Q > diff_R && diff_Q > diff_S) { + round_Q = -round_R - round_S; + } else if (diff_R > diff_S) { + round_R = -round_Q - round_S; + } + + HivePosition offset = HivePosition(-round_Q, -round_R); + + // there are no valid directions to reposition the board without going OOB + if (offset == kOriginPosition || IsOutOfBounds(new_pos + offset)) { + return false; + } + + // apply this offset to each valid position + bool oob = false; + std::for_each(played_tiles_.begin(), played_tiles_.end(), + [this, offset, &oob](HiveTile tile) { + tile_positions_[tile] += offset; + + // this usually occurs when tiles exist at each axes' extremes + if (IsOutOfBounds(tile_positions_[tile])) { + oob = true; + } + }); + + if (oob) { + return false; + } + + // re-calculate grid indices + std::fill(tile_grid_.begin(), tile_grid_.end(), HiveTile::kNoneTile); + for (uint8_t i = HiveTile::wQ; i < HiveTile::kNumTiles; ++i) { + if (IsInPlay(i) && !IsCovered(i)) { + tile_grid_[AxialToIndex(GetPositionOf(i))] = i; + } + } + + UpdateInfluence(Colour::kWhite); + UpdateInfluence(Colour::kBlack); + UpdateArticulationPoints(); + + return true; +} + +void HiveBoard::Pass() { + last_moved_ = HiveTile::kNoneTile; + last_moved_from_ = kNullPosition; +} + +bool HiveBoard::IsQueenSurrounded(Colour c) const { + HiveTile queen = c == Colour::kWhite ? HiveTile::wQ : HiveTile::bQ; + if (!IsInPlay(c, BugType::kQueen)) { + return false; + } + + for (auto neighbour_pos : tile_positions_[queen].Neighbours()) { + if (GetTopTileAt(neighbour_pos) == HiveTile::kNoneTile) { + return false; + } + } + + return true; +} + +// tile accessor with bounds checking +HiveTile HiveBoard::GetTopTileAt(HivePosition pos) const { + if (pos.DistanceTo(kOriginPosition) > Radius()) { + return HiveTile::kNoneTile; + } + + SPIEL_DCHECK_GE(AxialToIndex(pos), 0); + SPIEL_DCHECK_LT(AxialToIndex(pos), tile_grid_.size()); + return tile_grid_[AxialToIndex(pos)]; +} + +HiveTile HiveBoard::GetTileBelow(HivePosition pos) const { + SPIEL_DCHECK_TRUE(pos.H() > 0); + + HivePosition below = pos - kNeighbourOffsets[Direction::kAbove]; + // first check the top tile at this axial position + if (GetPositionOf(GetTopTileAt(below)) == below) { + return GetTopTileAt(below); + } + + // otherwise, check the covered_tiles_ list + for (auto tile : covered_tiles_) { + if (tile.HasValue() && tile_positions_[tile] == below) { + return tile; + } + } + + return HiveTile::kNoneTile; +} + +// IsGated verifies requirement (3) in GenerateValidSlides() +bool HiveBoard::IsGated(HivePosition pos, Direction d, + HivePosition to_ignore) const { + HivePosition cw = pos + kNeighbourOffsets[ClockwiseDirection(d)]; + HivePosition ccw = pos + kNeighbourOffsets[CounterClockwiseDirection(d)]; + + bool cw_exists = + cw != to_ignore && GetPositionOf(GetTopTileAt(cw)).H() >= pos.H(); + bool ccw_exists = + ccw != to_ignore && GetPositionOf(GetTopTileAt(ccw)).H() >= pos.H(); + return pos.H() == 0 ? cw_exists == ccw_exists : cw_exists && ccw_exists; +} + +bool HiveBoard::IsConnected(HivePosition pos, HivePosition to_ignore) const { + return NeighboursOf(pos, to_ignore).size() > 0; +} + +bool HiveBoard::IsCovered(HivePosition pos) const { + return std::find_if( + covered_tiles_.begin(), covered_tiles_.end(), + [this, pos](HiveTile tile) { return GetPositionOf(tile) == pos; }); +} + +bool HiveBoard::IsCovered(HiveTile tile) const { + return tile.HasValue() && + std::find(covered_tiles_.begin(), covered_tiles_.end(), tile) != + covered_tiles_.end(); +} + +bool HiveBoard::IsPinned(HivePosition pos) const { + return articulation_points_.contains(pos); +} + +bool HiveBoard::IsPinned(HiveTile tile) const { + return tile.HasValue() && IsPinned(tile_positions_[tile]); +} + +bool HiveBoard::IsPlaceable(Colour c, HivePosition pos) const { + return colour_influence_[static_cast(c)].contains(pos) && + !colour_influence_[static_cast(OtherColour(c))].contains(pos) && + !IsInPlay(GetTopTileAt(pos)); +} + +// clear and recalculate this tile's player's influence range +void HiveBoard::UpdateInfluence(Colour c) { + colour_influence_[static_cast(c)].clear(); + for (auto tile : played_tiles_) { + if (tile.GetColour() != c) { + continue; + } + + // if a tile is covered, it has no influence + if (IsCovered(tile)) { + continue; + } + + // exert influence on all neighbouring positions + for (auto pos : tile_positions_[tile].Neighbours()) { + // 0 out the height, so that stacked tiles influence the ground tiles + // around them, not tiles floating in air + colour_influence_[static_cast(c)].insert(pos.Grounded()); + } + } +} + +void HiveBoard::UpdateArticulationPoints() { + articulation_points_.clear(); + + int visit_order = 0; + absl::flat_hash_set visited; + absl::flat_hash_map entry_point; + absl::flat_hash_map low_point; + + auto dfs = [&](auto& dfs, HivePosition vertex, HivePosition parent, + bool is_root) -> void { + visited.insert(vertex); + entry_point[vertex] = low_point[vertex] = visit_order; + ++visit_order; + + int children = 0; + for (uint8_t dir = 0; dir < Direction::kNumCardinalDirections; ++dir) { + HivePosition to_vertex = vertex + kNeighbourOffsets[dir]; + if (!GetTopTileAt(to_vertex).HasValue()) { + continue; + } + + if (to_vertex == parent) { + continue; + } + + if (visited.contains(to_vertex)) { + low_point[vertex] = std::min(low_point[vertex], entry_point[to_vertex]); + } else { + dfs(dfs, to_vertex, vertex, false); + ++children; + low_point[vertex] = std::min(low_point[vertex], low_point[to_vertex]); + if (low_point[to_vertex] >= entry_point[vertex] && !is_root) { + articulation_points_.insert(vertex); + } + } + } + + if (is_root && children > 1) { + articulation_points_.insert(vertex); + } + }; + + // any arbitrary starting point would do, but the Queen is guaranteed to be + // in play when generating moves + dfs(dfs, tile_positions_[HiveTile::wQ], kNullPosition, true); +} + +std::string HiveTile::ToUHP() const { + SPIEL_DCHECK_TRUE(HasValue()); + std::string uhp = ""; + + // colour + GetColour() == Colour::kWhite ? absl::StrAppend(&uhp, "w") + : absl::StrAppend(&uhp, "b"); + + // bug type + BugType type = GetBugType(); + switch (type) { + case BugType::kQueen: + absl::StrAppend(&uhp, "Q"); + break; + case BugType::kAnt: + absl::StrAppend(&uhp, "A"); + break; + case BugType::kGrasshopper: + absl::StrAppend(&uhp, "G"); + break; + case BugType::kSpider: + absl::StrAppend(&uhp, "S"); + break; + case BugType::kBeetle: + absl::StrAppend(&uhp, "B"); + break; + case BugType::kLadybug: + absl::StrAppend(&uhp, "L"); + break; + case BugType::kMosquito: + absl::StrAppend(&uhp, "M"); + break; + case BugType::kPillbug: + absl::StrAppend(&uhp, "P"); + break; + } + + // bug type ordinal (for bugs where there can be more than 1) + if (type == BugType::kAnt || type == BugType::kGrasshopper || + type == BugType::kSpider || type == BugType::kBeetle) { + absl::StrAppend(&uhp, GetOrdinal()); + } + + return uhp; +} + +// UHP string representation of a move +std::string Move::ToUHP() { + // special case: pass for when a player has no possible legal moves + if (IsPass()) { + return "pass"; + } + + // special case: for the first turn, there is no reference tile 'to' + if (!to.HasValue()) { + return from.ToUHP(); + } + + std::string reference_tile_uhp = to.ToUHP(); + std::string offset_formatted = ""; + + // add a prefix or suffix depending on the relative position + switch (direction) { + case Direction::kNE: + offset_formatted = reference_tile_uhp + "/"; + break; + case Direction::kE: + offset_formatted = reference_tile_uhp + "-"; + break; + case Direction::kSE: + offset_formatted = reference_tile_uhp + "\\"; + break; + case Direction::kSW: + offset_formatted = "/" + reference_tile_uhp; + break; + case Direction::kW: + offset_formatted = "-" + reference_tile_uhp; + break; + case Direction::kNW: + offset_formatted = "\\" + reference_tile_uhp; + break; + case Direction::kAbove: + offset_formatted = reference_tile_uhp; + break; + default: + SpielFatalError("Move::ToUHP() - Move has an invalid direction!"); + } + + return absl::StrCat(from.ToUHP(), " ", offset_formatted); +} + +} // namespace hive +} // namespace open_spiel diff --git a/open_spiel/games/hive/hive_board.h b/open_spiel/games/hive/hive_board.h new file mode 100644 index 0000000000..bc70489ad1 --- /dev/null +++ b/open_spiel/games/hive/hive_board.h @@ -0,0 +1,613 @@ +// Copyright 2024 DeepMind Technologies Limited +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef OPEN_SPIEL_GAMES_HIVE_BOARD_H_ +#define OPEN_SPIEL_GAMES_HIVE_BOARD_H_ + +#include +#include +#include +#include +#include +#include +#include + +#include "open_spiel/abseil-cpp/absl/base/attributes.h" +#include "open_spiel/abseil-cpp/absl/container/flat_hash_map.h" +#include "open_spiel/abseil-cpp/absl/container/flat_hash_set.h" +#include "open_spiel/spiel.h" + +namespace open_spiel { +namespace hive { + +enum class BugType : uint8_t { + kQueen = 0, + kAnt, + kGrasshopper, + kSpider, + kBeetle, + kMosquito, + kLadybug, + kPillbug, + kNumBugTypes, + kNone, +}; + +enum Direction : uint8_t { + kNE = 0, + kE, + kSE, + kSW, + kW, + kNW, + kAbove, + kNumCardinalDirections = kAbove, // syntactic sugar for iterating + kNumAllDirections +}; + +enum class Colour { kWhite, kBlack }; + +struct ExpansionInfo { + bool uses_mosquito; + bool uses_ladybug; + bool uses_pillbug; + + bool HasAny() const { return uses_mosquito || uses_ladybug || uses_pillbug; } + bool IsBugTypeEnabled(BugType type) const { + switch (type) { + case BugType::kQueen: + case BugType::kAnt: + case BugType::kGrasshopper: + case BugType::kSpider: + case BugType::kBeetle: + return true; + case BugType::kMosquito: + return uses_mosquito; + case BugType::kLadybug: + return uses_ladybug; + case BugType::kPillbug: + return uses_pillbug; + default: + return false; + } + } +}; + +// HivePosition +// +// Describes as position using the Axial coordinate system (q,r) as well as +// a height to account for beetles/mosquitos on top of the hive +// https://www.redblobgames.com/grids/hexagons/#coordinates-axial +class HivePosition { + public: + // default initialization to kNullPosition + constexpr HivePosition() : q_(0), r_(0), h_(-1) {} + constexpr HivePosition(int8_t q, int8_t r, int8_t h = 0) + : q_(q), r_(r), h_(h) {} + + int8_t Q() const { return q_; } + int8_t R() const { return r_; } + + // height above the hive, where 0 == "ground" + int8_t H() const { return h_; } + + // implicit 3rd axial coordinate S to maintain constraint: q + r + s = 0 + int8_t S() const { return -q_ - r_; } + + int DistanceTo(HivePosition other) const { + return (std::abs(q_ - other.q_) + + std::abs((q_ - other.q_) + (r_ - other.r_)) + + std::abs(r_ - other.r_)) / + 2; + } + + bool operator==(HivePosition other) const { + return q_ == other.q_ && r_ == other.r_ && h_ == other.h_; + } + + bool operator!=(HivePosition other) const { return !operator==(other); } + + HivePosition operator+(HivePosition other) const { + return HivePosition(q_ + other.q_, r_ + other.r_, h_ + other.h_); + } + + HivePosition operator-(HivePosition other) const { + return HivePosition(q_ - other.q_, r_ - other.r_, h_ - other.h_); + } + + HivePosition& operator+=(HivePosition other) { + q_ += other.q_; + r_ += other.r_; + h_ += other.h_; + + return *this; + } + + std::string ToString() const { + return absl::StrCat("(", std::to_string(q_), ", ", std::to_string(r_), ", ", + std::to_string(h_), ")"); + } + + std::array Neighbours() + const { + return {{{q_ + 1, r_ - 1}, + {q_ + 1, r_}, + {q_, r_ + 1}, + {q_ - 1, r_ + 1}, + {q_ - 1, r_}, + {q_, r_ - 1}}}; + } + + HivePosition NeighbourAt(Direction dir) const; + HivePosition Grounded() const { return {q_, r_, 0}; } + + void SetQ(int8_t q) { q_ = q; } + void SetR(int8_t r) { r_ = r; } + void SetH(int8_t h) { h_ = h; } + + private: + int8_t q_; + int8_t r_; + int8_t h_; +}; + +inline constexpr int kMaxTileCount = 28; +inline constexpr int kMaxBoardRadius = 14; +inline constexpr int kDefaultBoardRadius = 8; +inline constexpr std::array(BugType::kNumBugTypes)> + kBugCounts = {{1, 3, 3, 2, 2, 1, 1, 1}}; +inline constexpr Player kPlayerWhite = 0; +inline constexpr Player kPlayerBlack = 1; +inline constexpr HivePosition kOriginPosition{0, 0, 0}; +inline constexpr HivePosition kNullPosition{0, 0, -1}; + +// support hashing for HivePosition +template +H AbslHashValue(H state, HivePosition pos) { + return H::combine(std::move(state), pos.Q(), pos.R(), pos.H()); +} + +// All offsets starting at top-right neighbour, and then rotating clockwise, +// plus above for beetles/mosquitos +// 5 0 +// 4 1 +// 3 2 +constexpr std::array + kNeighbourOffsets = { + // NE E SE SW W NW Above + {{1, -1}, {1, 0}, {0, 1}, {-1, 1}, {-1, 0}, {0, -1}, {0, 0, 1}}}; + +inline HivePosition HivePosition::NeighbourAt(Direction dir) const { + return operator+(kNeighbourOffsets[dir]); +} + +inline std::ostream& operator<<(std::ostream& stream, HivePosition pos) { + return stream << pos.ToString(); +} + +inline Player OtherPlayer(Player p) { + SPIEL_DCHECK_TRUE(p != kInvalidPlayer); + return p == kPlayerWhite ? kPlayerBlack : kPlayerWhite; +} + +inline Colour OtherColour(Colour c) { + return c == Colour::kWhite ? Colour::kBlack : Colour::kWhite; +} + +inline Colour PlayerToColour(Player p) { + SPIEL_DCHECK_TRUE(p != kInvalidPlayer); + return p == kPlayerWhite ? Colour::kWhite : Colour::kBlack; +} + +inline Direction OppositeDirection(uint8_t in) { + SPIEL_DCHECK_TRUE(in < Direction::kNumCardinalDirections); + return static_cast((in + 3) % Direction::kNumCardinalDirections); +} + +inline Direction ClockwiseDirection(uint8_t in) { + SPIEL_DCHECK_TRUE(in < Direction::kNumCardinalDirections); + return static_cast((in + 1) % Direction::kNumCardinalDirections); +} + +inline Direction CounterClockwiseDirection(uint8_t in) { + SPIEL_DCHECK_TRUE(in < Direction::kNumCardinalDirections); + return static_cast((in + 5) % Direction::kNumCardinalDirections); +} + +// Wrapper class that uses an enum to represent each unique physical tile. +// This would be similar to using a uint8_t with bit fields to encode +// colour/type/ordinal, but instead with the convenient features of a class +class HiveTile { + public: + // the Value enum is a ubiquitous list of physical tiles found in the game + // using their corresponding UHP names + enum Value : uint8_t { + // white tiles + wQ = 0, + wA1, + wA2, + wA3, + wG1, + wG2, + wG3, + wS1, + wS2, + wB1, + wB2, + wM, + wL, + wP, + // black tiles + bQ, + bA1, + bA2, + bA3, + bG1, + bG2, + bG3, + bS1, + bS2, + bB1, + bB2, + bM, + bL, + bP, + // constants + kNumTiles, + kNoneTile = kNumTiles + }; + + constexpr HiveTile() : tile_name_(kNoneTile) {} + constexpr HiveTile(Value val) : tile_name_(val) {} + constexpr HiveTile(uint8_t val) : tile_name_(static_cast(val)) {} + + // evaluates to the Value enum when used in expressions + constexpr operator Value() const { return tile_name_; } + + constexpr bool HasValue() const { return tile_name_ < kNoneTile; } + + static constexpr std::array GetTilesForColour(Colour c) { + switch (c) { + case Colour::kWhite: + return {wQ, wA1, wA2, wA3, wG1, wG2, wG3, + wS1, wS2, wB1, wB2, wM, wL, wP}; + case Colour::kBlack: + return {bQ, bA1, bA2, bA3, bG1, bG2, bG3, + bS1, bS2, bB1, bB2, bM, bL, bP}; + } + } + + static constexpr Value GetTileFrom(Colour c, BugType type, + uint8_t ordinal = 1) { + uint8_t retval = c == Colour::kWhite ? wQ : bQ; + + // sort of like reverse-iterating through an enum to determine its index + switch (type) { + case BugType::kPillbug: + retval += kBugCounts[static_cast(BugType::kLadybug)]; + ABSL_FALLTHROUGH_INTENDED; + case BugType::kLadybug: + retval += kBugCounts[static_cast(BugType::kMosquito)]; + ABSL_FALLTHROUGH_INTENDED; + case BugType::kMosquito: + retval += kBugCounts[static_cast(BugType::kBeetle)]; + ABSL_FALLTHROUGH_INTENDED; + case BugType::kBeetle: + retval += kBugCounts[static_cast(BugType::kSpider)]; + ABSL_FALLTHROUGH_INTENDED; + case BugType::kSpider: + retval += kBugCounts[static_cast(BugType::kGrasshopper)]; + ABSL_FALLTHROUGH_INTENDED; + case BugType::kGrasshopper: + retval += kBugCounts[static_cast(BugType::kAnt)]; + ABSL_FALLTHROUGH_INTENDED; + case BugType::kAnt: + retval += kBugCounts[static_cast(BugType::kQueen)]; + ABSL_FALLTHROUGH_INTENDED; + default: + // no-op + break; + } + + return static_cast(retval + ordinal - 1); + } + + static Value UHPToTile(const std::string& uhp) { + static absl::flat_hash_map string_mapping = { + {"wQ", wQ}, + {"wA1", wA1}, {"wA2", wA2}, {"wA3", wA3}, + {"wG1", wG1}, {"wG2", wG2}, {"wG3", wG3}, + {"wS1", wS1}, {"wS2", wS2}, + {"wB1", wB1}, {"wB2", wB2}, + {"wM", wM}, + {"wL", wL}, + {"wP", wP}, + // + {"bQ", bQ}, + {"bA1", bA1}, {"bA2", bA2}, {"bA3", bA3}, + {"bG1", bG1}, {"bG2", bG2}, {"bG3", bG3}, + {"bS1", bS1}, {"bS2", bS2}, + {"bB1", bB1}, {"bB2", bB2}, + {"bM", bM}, + {"bL", bL}, + {"bP", bP}}; + + auto it = string_mapping.find(uhp); + SPIEL_CHECK_TRUE(it != string_mapping.end()); + return it->second; + } + + static std::string TileToUHP(HiveTile tile) { + static absl::flat_hash_map enum_mapping = { + {wQ, "wQ"}, + {wA1, "wA1"}, {wA2, "wA2"}, {wA3, "wA3"}, + {wG1, "wG1"}, {wG2, "wG2"}, {wG3, "wG3"}, + {wS1, "wS1"}, {wS2, "wS2"}, + {wB1, "wB1"}, {wB2, "wB2"}, + {wM, "wM"}, + {wL, "wL"}, + {wP, "wP"}, + // + {bQ, "bQ"}, + {bA1, "bA1"}, {bA2, "bA2"}, {bA3, "bA3"}, + {bG1, "bG1"}, {bG2, "bG2"}, {bG3, "bG3"}, + {bS1, "bS1"}, {bS2, "bS2"}, + {bB1, "bB1"}, {bB2, "bB2"}, + {bM, "bM"}, + {bL, "bL"}, + {bP, "bP"}}; + + auto it = enum_mapping.find(tile); + SPIEL_CHECK_TRUE(it != enum_mapping.end()); + return it->second; + } + + constexpr BugType GetBugType() const { + switch (tile_name_) { + case wQ: + case bQ: + return BugType::kQueen; + case wA1: case wA2: case wA3: + case bA1: case bA2: case bA3: + return BugType::kAnt; + case wG1: case wG2: case wG3: + case bG1: case bG2: case bG3: + return BugType::kGrasshopper; + case wS1: case wS2: + case bS1: case bS2: + return BugType::kSpider; + case wB1: case wB2: + case bB1: case bB2: + return BugType::kBeetle; + case wM: + case bM: + return BugType::kMosquito; + case wL: + case bL: + return BugType::kLadybug; + case wP: + case bP: + return BugType::kPillbug; + default: + return BugType::kNone; + } + } + + constexpr Colour GetColour() const { + switch (tile_name_) { + case wQ: case wA1: case wA2: case wA3: case wG1: case wG2: case wG3: + case wS1: case wS2: case wB1: case wB2: case wM: case wL: case wP: + return Colour::kWhite; + case bQ: case bA1: case bA2: case bA3: case bG1: case bG2: case bG3: + case bS1: case bS2: case bB1: case bB2: case bM: case bL: case bP: + return Colour::kBlack; + default: + SpielFatalError("GetColour() - invalid enum value"); + } + } + + constexpr uint8_t GetOrdinal() const { + switch (tile_name_) { + case kNoneTile: + return 0; + case wA2: case wG2: case wS2: case wB2: + case bA2: case bG2: case bS2: case bB2: + return 2; + case wA3: case wG3: + case bA3: case bG3: + return 3; + default: + return 1; + } + } + + std::string ToUHP() const; + + private: + Value tile_name_; +}; + +// The in-game representation of an Action +struct Move { + HiveTile from; // the tile that's being moved + HiveTile to; // the reference tile + Direction direction; // offset applied to the reference tile + + std::string ToUHP(); + bool IsPass() const { return !from.HasValue(); } +}; + +// HiveBoard +// +// One of the most apparent problems to solve for Hive is how to represent an +// infinitely-sized board in a fixed-sized manner? This is especially the case +// when also needing an accurate 2D representation of the board state for use +// as an ObservationTensor. +// +// While the game logic could be implemented with a wrap-around grid big enough +// to account for all tiles (a 29x29 grid for all expansion pieces), the +// resulting ObservationTensor would be: +// 1) massively large in size (compared to the typical size of a Hive game) +// 2) be extremely sparse, which could negatively affect learning, and +// 3) unsuitable for 2D convolution in AlphaZero with no way to account for +// hexagonal wrapping of the tensor (that I know of). And even if there +// was a potential solution, a vast majority of playthroughs would be +// unlikely to ever reach a state where wrapping is necessary +// +// With all of that in mind, I have chosen the following board design: +// - the board will be stored as a fixed-sized and flattened 2d array where +// each index contains an enum describing either the existance of a +// specific tile, or an empty space on the grid +// - each tile enum can be used to index into fixed-sized arrays that store +// information about that specific tile. e.g. tile_positions_[::wA2] stores +// the HivePosition of white's 2nd Ant tile +// - most of the game logic is computed using the Axial coordinate system +// (described above under HivePosition), then later translated to an index +// when needed for the grid. This helps with the maths and allows for +// quick computation of rotational and reflectional symmetry +// +// Example board state with radius == 2 to illustrate (X means empty): +// +// ___0____1____2____3____4__ +// X bQ X 0 | | | | bQ | | +// |____|____|____|____|____| +// X X bA1 X 1 | | | | bA1| | +// AxialToIndex() |____|____|____|____|____| +// X wQ wL X X -------------> 2 | | wQ | wL | | | +// |____|____|____|____|____| +// X wG1 X X 3 | | wG1| | | | +// |____|____|____|____|____| +// X X X 4 | | | | | | +// |____|____|____|____|____| +// +class HiveBoard { + public: + // Creates a regular hexagonal board with given radius from the center + HiveBoard(int board_radius, ExpansionInfo expansions); + + int Radius() const { return hex_radius_; } + int SquareDimensions() const { return Radius() * 2 + 1; } + + // Axial position (Q,R) is stored at the 2d-index: + // grid_[R + Radius()][Q + Radius()] + // which translates to the flattened index: + // grid_[Q + Radius() + ((R + Radius()) * SqDims)] + size_t AxialToIndex(HivePosition pos) const { + return pos.Q() + Radius() + ((pos.R() + Radius()) * SquareDimensions()); + } + + HiveTile GetTopTileAt(HivePosition pos) const; + HiveTile GetTileBelow(HivePosition pos) const; + const std::vector& GetPlayedTiles() const { return played_tiles_; } + std::vector NeighboursOf( + HivePosition pos, HivePosition to_ignore = kNullPosition) const; + HivePosition GetPositionOf(HiveTile tile) const { + return tile.HasValue() ? tile_positions_[tile] : kNullPosition; + } + + HivePosition LastMovedFrom() const { return last_moved_from_; } + HiveTile LastMovedTile() const { return last_moved_; } + + // returns false if the move was unsuccessful + bool MoveTile(Move move); + void Pass(); + + bool IsQueenSurrounded(Colour c) const; + bool IsGated(HivePosition pos, Direction d, + HivePosition to_ignore = kNullPosition) const; + bool IsConnected(HivePosition pos, HivePosition to_ignore) const; + bool IsCovered(HivePosition pos) const; + bool IsCovered(HiveTile tile) const; + bool IsOutOfBounds(HivePosition pos) const; + bool IsPinned(HivePosition pos) const; + bool IsPinned(HiveTile tile) const; + bool IsPlaceable(Colour c, HivePosition pos) const; + bool IsInPlay(HiveTile tile) const { + return tile.HasValue() && tile_positions_[tile] != kNullPosition; + } + bool IsInPlay(Colour c, BugType type, int ordinal = 1) const { + return IsInPlay(HiveTile::GetTileFrom(c, type, ordinal)); + } + + void GenerateAllMoves(std::vector* out, Colour to_move, + int move_number) const; + void GenerateMovesFor(std::vector* out, HiveTile tile, + BugType acting_type, Colour to_move) const; + + private: + // moves all tiles closer to the center relative to the distance of each axis + bool RecenterBoard(HivePosition new_pos); + + // creates moves where a player can place an unplayed-tile from hand + void GeneratePlacementMoves(std::vector* out, Colour to_move, + int move_number) const; + + // In order for a tile to slide in direction D, the following must hold true: + // 1) The tile must not be "pinned" (i.e. at an articulation point) + // 2) The tile must not be covered by another tile + // 3) The tile must be able to physically slide into the position without + // displacing other tiles. That is, when sliding in direction D, exactly + // one of the two adjacent positions (D-1) (D+1) must be empty to + // physically move in, and the other position must be occupied in order + // to remain attached to the hive at all times (One-Hive rule) + void GenerateValidSlides(absl::flat_hash_set* out, + HiveTile tile, HivePosition pos, int distance) const; + + // A climb consists of a slide on top the hive laterally, with an optional + // vertical movement, in any non-gated direction. This slide is less + // restrictive than a ground-level slide as you do not require neighbours + // to remain connected to the hive + void GenerateValidClimbs(absl::flat_hash_set* out, + HiveTile tile, HivePosition pos) const; + + void GenerateValidGrasshopperPositions(absl::flat_hash_set* out, + HiveTile tile, HivePosition pos) const; + void GenerateValidLadybugPositions(absl::flat_hash_set* out, + HiveTile tile, HivePosition pos) const; + void GenerateValidMosquitoPositions(std::vector* out, HiveTile tile, + HivePosition pos, Colour to_move) const; + void GenerateValidPillbugSpecials(std::vector* out, HiveTile tile, + HivePosition pos) const; + + // Articulation points in a connected graph are vertices where, when removed, + // separate the graph into multiple components that are no longer connected. + // Tiles at an articulation point are considered "pinned" (and thus, can't be + // moved) as it would split the hive in two and invalidate the "One-Hive" rule + // https://en.wikipedia.org/wiki/Biconnected_component + // https://cp-algorithms.com/graph/cutpoints.html + void UpdateArticulationPoints(); + void UpdateInfluence(Colour col); + + int hex_radius_; + ExpansionInfo expansions_; + + std::vector tile_grid_; + std::vector played_tiles_; + std::array tile_positions_; + + // there are max 6 tiles that can climb on the hive to cover a tile + std::array covered_tiles_; + absl::flat_hash_set articulation_points_; + + // contains the positions surrounding played tiles. Used for placement rules + std::array, 2> colour_influence_; + + HiveTile last_moved_; + HivePosition last_moved_from_; +}; + +} // namespace hive +} // namespace open_spiel + +#endif // OPEN_SPIEL_GAMES_HIVE_BOARD_H_ diff --git a/open_spiel/games/hive/hive_test.cc b/open_spiel/games/hive/hive_test.cc new file mode 100644 index 0000000000..584d962388 --- /dev/null +++ b/open_spiel/games/hive/hive_test.cc @@ -0,0 +1,243 @@ +// Copyright 2024 DeepMind Technologies Limited +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "open_spiel/games/hive/hive.h" + +#include "open_spiel/abseil-cpp/absl/strings/str_split.h" +#include "open_spiel/spiel.h" +#include "open_spiel/spiel_utils.h" +#include "open_spiel/tests/basic_tests.h" + +namespace open_spiel { +namespace hive { +namespace { + +namespace testing = open_spiel::testing; + +// Move generation tests for each bug type. Modified from the original set +// to account for invalid move test cases. +// https://github.com/edre/nokamute/blob/master/data/uhp_tests.txt +constexpr const char* queen_test_game = + "Base+MLP;InProgress;White[9];wS1;bS1 wS1-;wQ -wS1;bQ bS1-;wQ \\wS1;bQ " + "bS1/;wG1 /wQ;bG1 bQ\\;wB1 \\wQ;bB1 bQ/;wG2 wB1/;bG2 \\bB1;wA1 /wB1;bA1 " + "bB1\\;wQ wG2\\;bA2 bA1/"; +constexpr const char* queen_valid_moves = "wQ wG2-;wQ -bG2;wQ wG1/"; +constexpr const char* queen_invalid_moves = "wQ -bB1;wQ -bQ;wQ \\bS1"; + +constexpr const char* ant_test_game = + "Base+MLP;InProgress;White[13];wS1;bB1 wS1-;wQ -wS1;bQ bB1-;wB1 \\wQ;bG1 " + "bQ/;wB2 \\wB1;bG2 bG1/;wS2 \\wB2;bS1 bG2/;wA1 \\wS1;bB2 bS1/;wA2 " + "\\wS2;bG3 \\bB2;wA1 -bG1;bA1 \\bG3;wG1 wA2/;bS2 -bA1;wG2 wG1/;bA2 " + "-bS2;wA3 wG2-;bA3 bS2\\;wG3 wA3\\;bA3 wG3\\"; +constexpr const char* ant_valid_moves = + "wA1 -bG2;wA1 -bS1;wA1 /bG3;wA1 bS2\\;wA1 bA2\\;wA1 /bA2;wA1 bA3-;wA1 " + "bA3\\;wA1 /bA3;wA1 /wG3;wA1 wG2\\;wA1 wG1\\;wA1 wB2/;wA1 wB1/;wA1 " + "\\wS1;wA1 \\bB1"; +constexpr const char* ant_invalid_moves = "wA1 -bA2;wA1 wA3-"; + +constexpr const char* grasshopper_test_game = + "Base+MLP;InProgress;White[11];wG1;bG1 wG1-;wQ /wG1;bQ bG1-;wS1 wQ\\;bA1 " + "bQ-;wB1 /wS1;bA1 -wQ;wB1 wS1\\;bA2 bQ-;wB1 /wS1;bA2 wG1\\;wB1 wS1\\;bA3 " + "bQ-;wB1 /wS1;bS1 bQ\\;wB1 wS1;bS1 wB1\\;wB1 /wB1;bA3 -wB1"; +constexpr const char* grasshopper_valid_moves = + "wG1 /wQ;wG1 bA2\\;wG1 bQ-;wG1 \\wB1"; +constexpr const char* grasshopper_invalid_moves = "wG1 \\bG1;wG1 bA1/"; + +constexpr const char* spider_test_game = + "Base+MLP;InProgress;White[12];wG1;bA1 wG1-;wS1 \\wG1;bQ bA1-;wQ /wG1;bG1 " + "bQ\\;wG2 wQ\\;bB1 /bG1;wB1 /wG2;bG2 bG1\\;wG3 /wB1;bG2 -bB1;wB2 wG3\\;bA1 " + "bG1\\;wA1 wB2-;bA1 bB1\\;wA2 wA1/;bA1 bG1-;wS2 wA2-;bA1 bG1\\;wA3 " + "wS2\\;bA1 wA3-"; +constexpr const char* spider_valid_moves = "wS1 \\bQ;wS1 /bQ;wS1 wG1\\;wS1 /wQ"; +constexpr const char* spider_invalid_moves = "wS1 -bQ;wS1 wG1/"; + +constexpr const char* beetle_test_game = + "Base+MLP;InProgress;White[16];wB1;bB1 wB1-;wQ \\wB1;bQ bB1/;wG1 /wB1;bB2 " + "bB1\\;wA1 /wG1;bA1 bQ\\;wG2 -wA1;bQ \\bB1;wB2 /wG2;bA2 \\bA1;wG3 " + "wB2\\;bA2 \\wQ;wA2 wG3-;bB2 wB1\\;wS1 wA2\\;bA1 bB1\\;wS2 wS1-;bA1 " + "bB1-;wA3 wS2/;bA1 \\wA3;wL -wG1;bM bB1\\;wA1 wG2\\;bM bB2;wA1 wL\\;bB1 " + "bQ;wL bB1\\;bA1 -wG1"; +constexpr const char* beetle_valid_moves = "wB1 wQ;wB1 bB1;wB1 wG1;wB1 bM"; +constexpr const char* beetle_invalid_moves = "wB1 bQ;wB1 bB2;wB1 wL;wB1 /wQ"; + +constexpr const char* mosquito_test_game = + "Base+MLP;InProgress;White[13];wM;bG1 wM-;wS1 /wM;bQ bG1-;wQ /wS1;bB1 " + "bG1\\;wB1 /wQ;bB1 wM\\;wS2 /wB1;bA1 bQ-;wB2 wS2\\;bA1 bQ\\;wG1 wB2-;bA1 " + "bQ-;wG2 wG1/;bA1 bQ\\;wG3 wG2/;bA1 bQ-;wA1 wG3-;bA1 bQ/;wA2 wA1-;bA1 " + "bQ-;wA3 wA2\\;bA1 /wA3"; +constexpr const char* mosquito_valid_moves = + "wM bQ-;wM bB1\\;wM /wS2;wM \\bG1;wM bG1;wM bB1;wM wS1;wM \\wS1;wM bQ/;wM " + "-wQ"; +constexpr const char* mosquito_invalid_moves = "wM /wA2;wM \\bQ"; + +constexpr const char* ladybug_test_game = + "Base+MLP;InProgress;White[15];wL;bL wL/;wQ -wL;bQ bL/;wQ -bL;bA1 bQ/;wB1 " + "\\wQ;bA1 bQ-;wS1 \\wB1;bA1 bQ/;wB2 \\wS1;bA1 bQ-;wS2 wB2/;bA1 bQ/;wA1 " + "wS2-;bA1 bQ-;wG1 wA1/;bA1 bQ/;wG2 wG1-;bA1 bQ-;wA2 wG2\\;bA1 bQ/;wA3 " + "wA2-;bA1 bQ-;wG3 wA3/;bA1 \\wG3;wL bL\\;bQ \\bL"; +constexpr const char* ladybug_valid_moves = + "wL wB1/;wL /wB1;wL wS1-;wL \\bQ;wL bQ/;wL bQ-;wL /wQ;wL wQ\\"; +constexpr const char* ladybug_invalid_moves = "wL /wS1;wL bL-"; + +constexpr const char* pillbug_test_game = + "Base+MLP;InProgress;White[6];wP;bM wP-;wQ \\wP;bL bM\\;wA1 /wQ;bQ bL/;wA2 " + "-wQ;bA1 /bL;wA2 wP\\;bM wP/"; +constexpr const char* pillbug_valid_moves = "wQ -wA2;wQ -bQ;wA1 bM\\"; +constexpr const char* pillbug_invalid_moves = "bM wA1\\;wP -bQ;wQ bM/"; + +// game states to test basic functionality +constexpr const char* white_wins_game = + "Base;WhiteWins;Black[8];wS1;bS1 wS1-;wQ -wS1;bQ bS1/;wG1 -wQ;bG1 \\bQ;wG1 " + "bQ\\;bG2 bQ/;wA1 wQ\\;bA1 bG2/;wA1 bG2\\;bA1 \\bG2;wQ \\wS1;bA1 bG2/;wQ " + "/bG1"; +constexpr const char* white_wins_on_black_turn_game = + "Base;WhiteWins;White[7];wS1;bS1 wS1-;wQ -wS1;bQ bS1/;wG1 -wQ;bG1 \\bQ;wG1 " + "bQ\\;bG2 bQ/;wA1 wQ\\;bA1 bG2/;wA1 bG2\\;bA1 /bG1"; +constexpr const char* draw_game = + "Base;Draw;White[11];wS1;bS1 wS1-;wQ -wS1;bQ bS1/;wG1 -wQ;bG1 \\bQ;wG1 " + "bQ\\;bG2 bQ/;wA1 wQ\\;bA1 bG2/;wA1 bG2\\;bA1 \\bG2;wQ \\wS1;bG1 wA1/;wQ " + "-bQ;bA1 \\wQ;wB1 -wS1;bG3 bG1-;wB1 /bA1;bG3 -bG2"; +constexpr const char* force_pass_game = + "Base;InProgress;White[7];wA1;bS1 wA1-;wQ -wA1;bQ bS1/;wQ \\wA1;bA1 " + "bS1\\;wQ -wA1;bA2 bQ\\;wQ \\wA1;bA1 \\wQ;wG1 /wQ;bA2 /wG1"; + +// uncommonly encountered corner-cases +constexpr const char* beetle_gate_game = + "Base;InProgress;White[12];wB1;bS1 wB1-;wQ \\wB1;bQ bS1/;wB2 -wQ;bB1 " + "bQ\\;wS1 /wB2;bB1 bS1;wG1 /wS1;bQ \\bB1;wG2 wG1\\;bB2 bQ/;wG3 wG2\\;bB2 " + "\\bQ;wA1 wG3-;bB2 wQ;wA2 wA1-;bA1 bQ/;wS2 wA2-;bA1 bB1/;wA3 wS2/;bA1 wA3/"; +constexpr const char* beetle_gate_valid_moves = + "wB1 bB2;wB1 bB1;wB1 /bB1;wB1 wB2\\"; + +constexpr const char* ladybug_gate_game = + "Base+L;InProgress;White[14];wL;bG1 wL/;wQ -wL;bQ bG1/;wQ -bG1;bG2 bQ-;wB1 " + "\\wQ;bB1 bG2-;wS1 \\wB1;bB1 bG2;wS2 \\wS1;bG3 \\bQ;wG1 wS2/;bB2 bG3/;wB2 " + "wG1/;bB2 bG3;wA1 wB2-;bA1 bB1-;wA2 wA1-;bA1 bB1\\;wG2 wA2-;bA1 bB1-;wG3 " + "wG2\\;bA1 bB1\\;wA3 wG3\\;bA1 wA3\\"; +constexpr const char* ladybug_gate_valid_moves = + "wL -bB2;wL /bB2;wL /wB1;wL /wS1;wL bQ\\;wL bG1\\;wL /wQ"; + +constexpr const char* pillbug_gate_game = + "Base+P;InProgress;White[9];wP;bB1 wP-;wQ /wP;bQ bB1/;wQ wP\\;bQ \\bB1;wQ " + "/wP;bA1 bQ/;wQ wP\\;bA1 -bQ;wQ /wP;bB2 \\bQ;wQ wP\\;bB2 bQ;bA1 -wP;bB1 wQ"; +constexpr const char* pillbug_gate_valid_moves = "bA1 -bB2;bA1 /wP"; + +void BasicHiveTests() { + testing::LoadGameTest("hive"); + std::shared_ptr game_mlp = + open_spiel::LoadGame("hive"); + testing::NoChanceOutcomesTest(*game_mlp); + testing::RandomSimTest(*game_mlp, 5); + + // test all win conditions + auto state = DeserializeUHPGameAndState(white_wins_game).second; + SPIEL_CHECK_TRUE(state->IsTerminal()); + SPIEL_CHECK_FLOAT_EQ(state->PlayerReturn(kPlayerWhite), 1.0); + SPIEL_CHECK_FLOAT_EQ(state->PlayerReturn(kPlayerBlack), -1.0); + + state = DeserializeUHPGameAndState(white_wins_on_black_turn_game).second; + SPIEL_CHECK_TRUE(state->IsTerminal()); + SPIEL_CHECK_FLOAT_EQ(state->PlayerReturn(kPlayerWhite), 1.0); + SPIEL_CHECK_FLOAT_EQ(state->PlayerReturn(kPlayerBlack), -1.0); + + state = DeserializeUHPGameAndState(draw_game).second; + SPIEL_CHECK_TRUE(state->IsTerminal()); + SPIEL_CHECK_FLOAT_EQ(state->PlayerReturn(kPlayerWhite), 0.0); + SPIEL_CHECK_FLOAT_EQ(state->PlayerReturn(kPlayerBlack), 0.0); + + // pass action + state = DeserializeUHPGameAndState(force_pass_game).second; + SPIEL_CHECK_TRUE(state->LegalActions().size() == 1); + SPIEL_CHECK_TRUE(state->LegalActions().at(0) == + state->StringToAction("pass")); + + // test all expansion variations + testing::RandomSimTest(*LoadGame("hive(uses_mosquito=false)"), 1); + testing::RandomSimTest( + *LoadGame("hive(uses_mosquito=false,uses_ladybug=false)"), 1); + testing::RandomSimTest( + *LoadGame("hive(uses_mosquito=false,uses_pillbug=false)"), 1); + testing::RandomSimTest( + *LoadGame("hive(uses_ladybug=false,uses_pillbug=false)"), 1); + testing::RandomSimTest( + *LoadGame( + "hive(uses_mosquito=false,uses_ladybug=false,uses_pillbug=false)"), + 1); + + // test with maximum board size + testing::RandomSimTest( + *LoadGame(absl::StrFormat("hive(board_size=%d)", kMaxBoardRadius)), 1); + + // test prettyprint with ansi colours + testing::RandomSimTest(*LoadGame("hive(ansi_color_output=true)"), 1); +} + +void TestMoves(std::unique_ptr&& state, const char* valid_moves, + const char* invalid_moves) { + std::vector legal_action_mask = state->LegalActionsMask(); + std::vector valid_move_list = + absl::StrSplit(valid_moves, ';', absl::SkipEmpty()); + std::vector invalid_move_list = + absl::StrSplit(invalid_moves, ';', absl::SkipEmpty()); + + for (auto& move : valid_move_list) { + SPIEL_CHECK_TRUE(legal_action_mask[state->StringToAction(move)] == 1); + } + + for (auto& move : invalid_move_list) { + SPIEL_CHECK_TRUE(legal_action_mask[state->StringToAction(move)] == 0); + } +} + +void TestBugMoves() { + std::shared_ptr game = open_spiel::LoadGame("hive"); + + // Base Bugs + TestMoves(DeserializeUHPGameAndState(queen_test_game).second, + queen_valid_moves, queen_invalid_moves); + TestMoves(DeserializeUHPGameAndState(ant_test_game).second, ant_valid_moves, + ant_invalid_moves); + TestMoves(DeserializeUHPGameAndState(grasshopper_test_game).second, + grasshopper_valid_moves, grasshopper_invalid_moves); + TestMoves(DeserializeUHPGameAndState(spider_test_game).second, + spider_valid_moves, spider_invalid_moves); + TestMoves(DeserializeUHPGameAndState(beetle_test_game).second, + beetle_valid_moves, beetle_invalid_moves); + + // Expansion Bugs + TestMoves(DeserializeUHPGameAndState(mosquito_test_game).second, + mosquito_valid_moves, mosquito_invalid_moves); + TestMoves(DeserializeUHPGameAndState(ladybug_test_game).second, + ladybug_valid_moves, ladybug_invalid_moves); + TestMoves(DeserializeUHPGameAndState(pillbug_test_game).second, + pillbug_valid_moves, pillbug_invalid_moves); + + // Special Cases + TestMoves(DeserializeUHPGameAndState(beetle_gate_game).second, + beetle_gate_valid_moves, ""); + TestMoves(DeserializeUHPGameAndState(ladybug_gate_game).second, + ladybug_gate_valid_moves, ""); + TestMoves(DeserializeUHPGameAndState(pillbug_gate_game).second, + pillbug_gate_valid_moves, ""); +} + +} // namespace +} // namespace hive +} // namespace open_spiel + +int main(int argc, char** argv) { + // TODO: perft() + open_spiel::hive::BasicHiveTests(); + open_spiel::hive::TestBugMoves(); +} diff --git a/open_spiel/integration_tests/playthroughs/hive.txt b/open_spiel/integration_tests/playthroughs/hive.txt new file mode 100644 index 0000000000..318ed7d2cd --- /dev/null +++ b/open_spiel/integration_tests/playthroughs/hive.txt @@ -0,0 +1,1598 @@ +game: hive + +GameType.chance_mode = ChanceMode.DETERMINISTIC +GameType.dynamics = Dynamics.SEQUENTIAL +GameType.information = Information.PERFECT_INFORMATION +GameType.long_name = "Hive" +GameType.max_num_players = 2 +GameType.min_num_players = 2 +GameType.parameter_specification = ["ansi_color_output", "board_size", "uses_ladybug", "uses_mosquito", "uses_pillbug"] +GameType.provides_information_state_string = True +GameType.provides_information_state_tensor = False +GameType.provides_observation_string = True +GameType.provides_observation_tensor = True +GameType.provides_factored_observation_string = False +GameType.reward_model = RewardModel.TERMINAL +GameType.short_name = "hive" +GameType.utility = Utility.ZERO_SUM + +NumDistinctActions() = 5489 +PolicyTensorShape() = [5489] +MaxChanceOutcomes() = 0 +GetParameters() = {ansi_color_output=False,board_size=8,uses_ladybug=True,uses_mosquito=True,uses_pillbug=True} +NumPlayers() = 2 +MinUtility() = -1.0 +MaxUtility() = 1.0 +UtilitySum() = 0.0 +ObservationTensorShape() = [23, 17, 17] +ObservationTensorLayout() = TensorLayout.CHW +ObservationTensorSize() = 6647 +MaxGameLength() = 500 +ToString() = "hive()" + +# State 0 +# Base+MLP;NotStarted;White[1]; +IsTerminal() = False +History() = [] +HistoryString() = "" +IsChanceNode() = False +IsSimultaneousNode() = False +CurrentPlayer() = 0 +InformationStateString(0) = "" +InformationStateString(1) = "" +ObservationString(0) = "Base+MLP;NotStarted;White[1];" +ObservationString(1) = "Base+MLP;NotStarted;White[1];" +ObservationTensor(0): +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +ObservationTensor(1): +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +Rewards() = [0, 0] +Returns() = [0, 0] +LegalActions() = [209, 412, 615, 818, 1021, 1224, 1427, 1630, 1833, 2036, 2239, 2442, 2645] +StringLegalActions() = ["wA1", "wA2", "wA3", "wG1", "wG2", "wG3", "wS1", "wS2", "wB1", "wB2", "wM", "wL", "wP"] + +# Apply action "wS2" +action: 1630 + +# State 1 +# Base+MLP;InProgress;Black[1];wS2 +IsTerminal() = False +History() = [1630] +HistoryString() = "1630" +IsChanceNode() = False +IsSimultaneousNode() = False +CurrentPlayer() = 1 +InformationStateString(0) = "1630" +InformationStateString(1) = "1630" +ObservationString(0) = "Base+MLP;InProgress;Black[1];wS2" +ObservationString(1) = "Base+MLP;InProgress;Black[1];wS2" +ObservationTensor(0): +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◉◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◉◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◉◉◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +ObservationTensor(1): +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◉◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +Rewards() = [0, 0] +Returns() = [0, 0] +LegalActions() = [2996, 2997, 2998, 2999, 3000, 3001, 3192, 3193, 3194, 3195, 3196, 3197, 3388, 3389, 3390, 3391, 3392, 3393, 3584, 3585, 3586, 3587, 3588, 3589, 3780, 3781, 3782, 3783, 3784, 3785, 3976, 3977, 3978, 3979, 3980, 3981, 4172, 4173, 4174, 4175, 4176, 4177, 4368, 4369, 4370, 4371, 4372, 4373, 4564, 4565, 4566, 4567, 4568, 4569, 4760, 4761, 4762, 4763, 4764, 4765, 4956, 4957, 4958, 4959, 4960, 4961, 5152, 5153, 5154, 5155, 5156, 5157, 5348, 5349, 5350, 5351, 5352, 5353] +StringLegalActions() = ["bA1 wS2/", "bA1 wS2-", "bA1 wS2\", "bA1 /wS2", "bA1 -wS2", "bA1 \wS2", "bA2 wS2/", "bA2 wS2-", "bA2 wS2\", "bA2 /wS2", "bA2 -wS2", "bA2 \wS2", "bA3 wS2/", "bA3 wS2-", "bA3 wS2\", "bA3 /wS2", "bA3 -wS2", "bA3 \wS2", "bG1 wS2/", "bG1 wS2-", "bG1 wS2\", "bG1 /wS2", "bG1 -wS2", "bG1 \wS2", "bG2 wS2/", "bG2 wS2-", "bG2 wS2\", "bG2 /wS2", "bG2 -wS2", "bG2 \wS2", "bG3 wS2/", "bG3 wS2-", "bG3 wS2\", "bG3 /wS2", "bG3 -wS2", "bG3 \wS2", "bS1 wS2/", "bS1 wS2-", "bS1 wS2\", "bS1 /wS2", "bS1 -wS2", "bS1 \wS2", "bS2 wS2/", "bS2 wS2-", "bS2 wS2\", "bS2 /wS2", "bS2 -wS2", "bS2 \wS2", "bB1 wS2/", "bB1 wS2-", "bB1 wS2\", "bB1 /wS2", "bB1 -wS2", "bB1 \wS2", "bB2 wS2/", "bB2 wS2-", "bB2 wS2\", "bB2 /wS2", "bB2 -wS2", "bB2 \wS2", "bM wS2/", "bM wS2-", "bM wS2\", "bM /wS2", "bM -wS2", "bM \wS2", "bL wS2/", "bL wS2-", "bL wS2\", "bL /wS2", "bL -wS2", "bL \wS2", "bP wS2/", "bP wS2-", "bP wS2\", "bP /wS2", "bP -wS2", "bP \wS2"] + +# Apply action "bA3 /wS2" +action: 3391 + +# State 2 +# Base+MLP;InProgress;White[2];wS2;bA3 /wS2 +IsTerminal() = False +History() = [1630, 3391] +HistoryString() = "1630, 3391" +IsChanceNode() = False +IsSimultaneousNode() = False +CurrentPlayer() = 0 +InformationStateString(0) = "1630, 3391" +InformationStateString(1) = "1630, 3391" +ObservationString(0) = "Base+MLP;InProgress;White[2];wS2;bA3 /wS2" +ObservationString(1) = "Base+MLP;InProgress;White[2];wS2;bA3 /wS2" +ObservationTensor(0): +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◉◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +ObservationTensor(1): +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◉◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +Rewards() = [0, 0] +Returns() = [0, 0] +LegalActions() = [56, 57, 61, 252, 253, 257, 448, 449, 453, 644, 645, 649, 840, 841, 845, 1036, 1037, 1041, 1232, 1233, 1237, 1428, 1429, 1433, 1820, 1821, 1825, 2016, 2017, 2021, 2212, 2213, 2217, 2408, 2409, 2413, 2604, 2605, 2609] +StringLegalActions() = ["wQ wS2/", "wQ wS2-", "wQ \wS2", "wA1 wS2/", "wA1 wS2-", "wA1 \wS2", "wA2 wS2/", "wA2 wS2-", "wA2 \wS2", "wA3 wS2/", "wA3 wS2-", "wA3 \wS2", "wG1 wS2/", "wG1 wS2-", "wG1 \wS2", "wG2 wS2/", "wG2 wS2-", "wG2 \wS2", "wG3 wS2/", "wG3 wS2-", "wG3 \wS2", "wS1 wS2/", "wS1 wS2-", "wS1 \wS2", "wB1 wS2/", "wB1 wS2-", "wB1 \wS2", "wB2 wS2/", "wB2 wS2-", "wB2 \wS2", "wM wS2/", "wM wS2-", "wM \wS2", "wL wS2/", "wL wS2-", "wL \wS2", "wP wS2/", "wP wS2-", "wP \wS2"] + +# Apply action "wG1 wS2/" +action: 840 + +# State 3 +# Base+MLP;InProgress;Black[2];wS2;bA3 /wS2;wG1 wS2/ +IsTerminal() = False +History() = [1630, 3391, 840] +HistoryString() = "1630, 3391, 840" +IsChanceNode() = False +IsSimultaneousNode() = False +CurrentPlayer() = 1 +InformationStateString(0) = "1630, 3391, 840" +InformationStateString(1) = "1630, 3391, 840" +ObservationString(0) = "Base+MLP;InProgress;Black[2];wS2;bA3 /wS2;wG1 wS2/" +ObservationString(1) = "Base+MLP;InProgress;Black[2];wS2;bA3 /wS2;wG1 wS2/" +ObservationTensor(0): +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◉◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◉◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +ObservationTensor(1): +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◉◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +Rewards() = [0, 0] +Returns() = [0, 0] +LegalActions() = [2865, 2866, 2867, 3061, 3062, 3063, 3257, 3258, 3259, 3649, 3650, 3651, 3845, 3846, 3847, 4041, 4042, 4043, 4237, 4238, 4239, 4433, 4434, 4435, 4629, 4630, 4631, 4825, 4826, 4827, 5021, 5022, 5023, 5217, 5218, 5219, 5413, 5414, 5415] +StringLegalActions() = ["bQ bA3\", "bQ /bA3", "bQ -bA3", "bA1 bA3\", "bA1 /bA3", "bA1 -bA3", "bA2 bA3\", "bA2 /bA3", "bA2 -bA3", "bG1 bA3\", "bG1 /bA3", "bG1 -bA3", "bG2 bA3\", "bG2 /bA3", "bG2 -bA3", "bG3 bA3\", "bG3 /bA3", "bG3 -bA3", "bS1 bA3\", "bS1 /bA3", "bS1 -bA3", "bS2 bA3\", "bS2 /bA3", "bS2 -bA3", "bB1 bA3\", "bB1 /bA3", "bB1 -bA3", "bB2 bA3\", "bB2 /bA3", "bB2 -bA3", "bM bA3\", "bM /bA3", "bM -bA3", "bL bA3\", "bL /bA3", "bL -bA3", "bP bA3\", "bP /bA3", "bP -bA3"] + +# Apply action "bS1 /bA3" +action: 4238 + +# State 4 +# Base+MLP;InProgress;White[3];wS2;bA3 /wS2;wG1 wS2/;bS1 /bA3 +IsTerminal() = False +History() = [1630, 3391, 840, 4238] +HistoryString() = "1630, 3391, 840, 4238" +IsChanceNode() = False +IsSimultaneousNode() = False +CurrentPlayer() = 0 +InformationStateString(0) = "1630, 3391, 840, 4238" +InformationStateString(1) = "1630, 3391, 840, 4238" +ObservationString(0) = "Base+MLP;InProgress;White[3];wS2;bA3 /wS2;wG1 wS2/;bS1 /bA3" +ObservationString(1) = "Base+MLP;InProgress;White[3];wS2;bA3 /wS2;wG1 wS2/;bS1 /bA3" +ObservationTensor(0): +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◉◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◉◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◉◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◉◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +ObservationTensor(1): +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◉◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◉◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +Rewards() = [0, 0] +Returns() = [0, 0] +LegalActions() = [28, 29, 30, 32, 33, 57, 61, 224, 225, 226, 228, 229, 253, 257, 420, 421, 422, 424, 425, 449, 453, 616, 617, 618, 620, 621, 645, 649, 1008, 1009, 1010, 1012, 1013, 1037, 1041, 1204, 1205, 1206, 1208, 1209, 1233, 1237, 1400, 1401, 1402, 1404, 1405, 1429, 1433, 1792, 1793, 1794, 1796, 1797, 1821, 1825, 1988, 1989, 1990, 1992, 1993, 2017, 2021, 2184, 2185, 2186, 2188, 2189, 2213, 2217, 2380, 2381, 2382, 2384, 2385, 2409, 2413, 2576, 2577, 2578, 2580, 2581, 2605, 2609] +StringLegalActions() = ["wQ wG1/", "wQ wG1-", "wQ wG1\", "wQ -wG1", "wQ \wG1", "wQ wS2-", "wQ \wS2", "wA1 wG1/", "wA1 wG1-", "wA1 wG1\", "wA1 -wG1", "wA1 \wG1", "wA1 wS2-", "wA1 \wS2", "wA2 wG1/", "wA2 wG1-", "wA2 wG1\", "wA2 -wG1", "wA2 \wG1", "wA2 wS2-", "wA2 \wS2", "wA3 wG1/", "wA3 wG1-", "wA3 wG1\", "wA3 -wG1", "wA3 \wG1", "wA3 wS2-", "wA3 \wS2", "wG2 wG1/", "wG2 wG1-", "wG2 wG1\", "wG2 -wG1", "wG2 \wG1", "wG2 wS2-", "wG2 \wS2", "wG3 wG1/", "wG3 wG1-", "wG3 wG1\", "wG3 -wG1", "wG3 \wG1", "wG3 wS2-", "wG3 \wS2", "wS1 wG1/", "wS1 wG1-", "wS1 wG1\", "wS1 -wG1", "wS1 \wG1", "wS1 wS2-", "wS1 \wS2", "wB1 wG1/", "wB1 wG1-", "wB1 wG1\", "wB1 -wG1", "wB1 \wG1", "wB1 wS2-", "wB1 \wS2", "wB2 wG1/", "wB2 wG1-", "wB2 wG1\", "wB2 -wG1", "wB2 \wG1", "wB2 wS2-", "wB2 \wS2", "wM wG1/", "wM wG1-", "wM wG1\", "wM -wG1", "wM \wG1", "wM wS2-", "wM \wS2", "wL wG1/", "wL wG1-", "wL wG1\", "wL -wG1", "wL \wG1", "wL wS2-", "wL \wS2", "wP wG1/", "wP wG1-", "wP wG1\", "wP -wG1", "wP \wG1", "wP wS2-", "wP \wS2"] + +# Apply action "wQ wG1-" +action: 29 + +# State 5 +# Base+MLP;InProgress;Black[3];wS2;bA3 /wS2;wG1 wS2/;bS1 /bA3;wQ wG1- +IsTerminal() = False +History() = [1630, 3391, 840, 4238, 29] +HistoryString() = "1630, 3391, 840, 4238, 29" +IsChanceNode() = False +IsSimultaneousNode() = False +CurrentPlayer() = 1 +InformationStateString(0) = "1630, 3391, 840, 4238, 29" +InformationStateString(1) = "1630, 3391, 840, 4238, 29" +ObservationString(0) = "Base+MLP;InProgress;Black[3];wS2;bA3 /wS2;wG1 wS2/;bS1 /bA3;wQ wG1-" +ObservationString(1) = "Base+MLP;InProgress;Black[3];wS2;bA3 /wS2;wG1 wS2/;bS1 /bA3;wQ wG1-" +ObservationTensor(0): +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◉◉◉◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◉◯◯◉◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◉◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◉◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◉◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +ObservationTensor(1): +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◉◉◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◯◉◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◉◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◉◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +Rewards() = [0, 0] +Returns() = [0, 0] +LegalActions() = [2865, 2867, 2892, 2893, 2894, 2895, 2896, 3061, 3063, 3088, 3089, 3090, 3091, 3092, 3257, 3259, 3284, 3285, 3286, 3287, 3288, 3649, 3651, 3676, 3677, 3678, 3679, 3680, 3845, 3847, 3872, 3873, 3874, 3875, 3876, 4041, 4043, 4068, 4069, 4070, 4071, 4072, 4433, 4435, 4460, 4461, 4462, 4463, 4464, 4629, 4631, 4656, 4657, 4658, 4659, 4660, 4825, 4827, 4852, 4853, 4854, 4855, 4856, 5021, 5023, 5048, 5049, 5050, 5051, 5052, 5217, 5219, 5244, 5245, 5246, 5247, 5248, 5413, 5415, 5440, 5441, 5442, 5443, 5444] +StringLegalActions() = ["bQ bA3\", "bQ -bA3", "bQ bS1-", "bQ bS1\", "bQ /bS1", "bQ -bS1", "bQ \bS1", "bA1 bA3\", "bA1 -bA3", "bA1 bS1-", "bA1 bS1\", "bA1 /bS1", "bA1 -bS1", "bA1 \bS1", "bA2 bA3\", "bA2 -bA3", "bA2 bS1-", "bA2 bS1\", "bA2 /bS1", "bA2 -bS1", "bA2 \bS1", "bG1 bA3\", "bG1 -bA3", "bG1 bS1-", "bG1 bS1\", "bG1 /bS1", "bG1 -bS1", "bG1 \bS1", "bG2 bA3\", "bG2 -bA3", "bG2 bS1-", "bG2 bS1\", "bG2 /bS1", "bG2 -bS1", "bG2 \bS1", "bG3 bA3\", "bG3 -bA3", "bG3 bS1-", "bG3 bS1\", "bG3 /bS1", "bG3 -bS1", "bG3 \bS1", "bS2 bA3\", "bS2 -bA3", "bS2 bS1-", "bS2 bS1\", "bS2 /bS1", "bS2 -bS1", "bS2 \bS1", "bB1 bA3\", "bB1 -bA3", "bB1 bS1-", "bB1 bS1\", "bB1 /bS1", "bB1 -bS1", "bB1 \bS1", "bB2 bA3\", "bB2 -bA3", "bB2 bS1-", "bB2 bS1\", "bB2 /bS1", "bB2 -bS1", "bB2 \bS1", "bM bA3\", "bM -bA3", "bM bS1-", "bM bS1\", "bM /bS1", "bM -bS1", "bM \bS1", "bL bA3\", "bL -bA3", "bL bS1-", "bL bS1\", "bL /bS1", "bL -bS1", "bL \bS1", "bP bA3\", "bP -bA3", "bP bS1-", "bP bS1\", "bP /bS1", "bP -bS1", "bP \bS1"] + +# Apply action "bS2 bS1-" +action: 4460 + +# State 6 +# Apply action "wL wG1\" +action: 2382 + +# State 7 +# Apply action "bQ /bS2" +action: 2901 + +# State 8 +# Apply action "wA3 wQ/" +action: 588 + +# State 9 +# Apply action "bL /bS1" +action: 5246 + +# State 10 +# Apply action "wA1 -wA3" +action: 221 + +# State 11 +# Apply action "bG2 bQ\" +action: 3824 + +# State 12 +# Apply action "wG3 \wA1" +action: 1188 + +# State 13 +# Apply action "bG1 bG2\" +action: 3663 + +# State 14 +# Apply action "wA2 \wS2" +action: 453 + +# State 15 +# Apply action "bM \bS1" +action: 5052 + +# State 16 +# Apply action "wA2 wS2\" +action: 450 + +# State 17 +# Apply action "bB1 bQ-" +action: 4607 + +# State 18 +# Apply action "wA2 -wG3" +action: 438 + +# State 19 +# Apply action "bG3 /bL" +action: 4105 + +# State 20 +# Base+MLP;InProgress;White[11];wS2;bA3 /wS2;wG1 wS2/;bS1 /bA3;wQ wG1-;bS2 bS1-;wL wG1\;bQ /bS2;wA3 wQ/;bL /bS1;wA1 -wA3;bG2 bQ\;wG3 \wA1;bG1 bG2\;wA2 \wS2;bM \bS1;wA2 wS2\;bB1 bQ-;wA2 -wG3;bG3 /bL +IsTerminal() = False +History() = [1630, 3391, 840, 4238, 29, 4460, 2382, 2901, 588, 5246, 221, 3824, 1188, 3663, 453, 5052, 450, 4607, 438, 4105] +HistoryString() = "1630, 3391, 840, 4238, 29, 4460, 2382, 2901, 588, 5246, 221, 3824, 1188, 3663, 453, 5052, 450, 4607, 438, 4105" +IsChanceNode() = False +IsSimultaneousNode() = False +CurrentPlayer() = 0 +InformationStateString(0) = "1630, 3391, 840, 4238, 29, 4460, 2382, 2901, 588, 5246, 221, 3824, 1188, 3663, 453, 5052, 450, 4607, 438, 4105" +InformationStateString(1) = "1630, 3391, 840, 4238, 29, 4460, 2382, 2901, 588, 5246, 221, 3824, 1188, 3663, 453, 5052, 450, 4607, 438, 4105" +ObservationString(0) = "Base+MLP;InProgress;White[11];wS2;bA3 /wS2;wG1 wS2/;bS1 /bA3;wQ wG1-;bS2 bS1-;wL wG1\\;bQ /bS2;wA3 wQ/;bL /bS1;wA1 -wA3;bG2 bQ\\;wG3 \\wA1;bG1 bG2\\;wA2 \\wS2;bM \\bS1;wA2 wS2\\;bB1 bQ-;wA2 -wG3;bG3 /bL" +ObservationString(1) = "Base+MLP;InProgress;White[11];wS2;bA3 /wS2;wG1 wS2/;bS1 /bA3;wQ wG1-;bS2 bS1-;wL wG1\\;bQ /bS2;wA3 wQ/;bL /bS1;wA1 -wA3;bG2 bQ\\;wG3 \\wA1;bG1 bG2\\;wA2 \\wS2;bM \\bS1;wA2 wS2\\;bB1 bQ-;wA2 -wG3;bG3 /bL" +ObservationTensor(0): +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◉◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◉◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◉◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◉◉◉◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◉◯◯◉◉◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◉◉◯◯◉◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◉◯◯◉◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◉◯◯◉◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◉◯◯◯◉◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◉◯◉◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◉◉◉◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◉◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +ObservationTensor(1): +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◉◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◉◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◉◉◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◯◉◉◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◉◯◯◉◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◯◉◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◉◯◯◉◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◉◯◯◯◉◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◉◯◉◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◉◉◉◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◉◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +Rewards() = [0, 0] +Returns() = [0, 0] +LegalActions() = [23, 85, 393, 394, 399, 403, 413, 414, 415, 418, 424, 425, 434, 435, 437, 439, 450, 452, 453, 477, 478, 479, 493, 512, 516, 518, 519, 520, 521, 522, 526, 528, 529, 533, 534, 535, 536, 537, 543, 546, 547, 553, 554, 555, 567, 570, 571, 572, 576, 578, 579, 589, 590, 595, 599, 602, 604, 605, 606, 607, 620, 621, 630, 631, 633, 635, 646, 648, 649, 673, 674, 675, 689, 708, 712, 714, 715, 716, 717, 718, 722, 724, 725, 729, 730, 731, 732, 733, 739, 742, 743, 749, 750, 751, 763, 766, 767, 768, 772, 774, 775, 785, 791, 807, 810, 827, 870, 927, 981, 982, 987, 991, 994, 996, 997, 998, 999, 1001, 1002, 1003, 1006, 1012, 1013, 1022, 1023, 1025, 1027, 1041, 1065, 1066, 1373, 1374, 1379, 1383, 1386, 1388, 1389, 1390, 1391, 1393, 1394, 1395, 1398, 1404, 1405, 1414, 1415, 1417, 1419, 1433, 1457, 1458, 1765, 1766, 1771, 1775, 1778, 1780, 1781, 1782, 1783, 1785, 1786, 1787, 1790, 1796, 1797, 1806, 1807, 1809, 1811, 1825, 1849, 1850, 1961, 1962, 1967, 1971, 1974, 1976, 1977, 1978, 1979, 1981, 1982, 1983, 1986, 1992, 1993, 2002, 2003, 2005, 2007, 2021, 2045, 2046, 2157, 2158, 2163, 2167, 2170, 2172, 2173, 2174, 2175, 2177, 2178, 2179, 2182, 2188, 2189, 2198, 2199, 2201, 2203, 2217, 2241, 2242, 2353, 2354, 2359, 2363, 2368, 2373, 2374, 2375, 2378, 2384, 2385, 2395, 2397, 2410, 2412, 2413, 2472, 2476, 2506, 2527, 2549, 2550, 2555, 2559, 2562, 2564, 2565, 2566, 2567, 2569, 2570, 2571, 2574, 2580, 2581, 2590, 2591, 2593, 2595, 2609, 2633, 2634] +StringLegalActions() = ["wQ wA3\", "wQ wL-", "wA2 wQ-", "wA2 wQ\", "wA2 wA1/", "wA2 -wA1", "wA2 wA3/", "wA2 wA3-", "wA2 wA3\", "wA2 \wA3", "wA2 -wG1", "wA2 \wG1", "wA2 wG3/", "wA2 wG3-", "wA2 /wG3", "wA2 \wG3", "wA2 wS2\", "wA2 -wS2", "wA2 \wS2", "wA2 wL-", "wA2 wL\", "wA2 /wL", "wA2 /bQ", "wA2 bA3-", "wA2 \bA3", "wA2 bG1/", "wA2 bG1-", "wA2 bG1\", "wA2 /bG1", "wA2 -bG1", "wA2 bG2-", "wA2 /bG2", "wA2 -bG2", "wA2 bG3-", "wA2 bG3\", "wA2 /bG3", "wA2 -bG3", "wA2 \bG3", "wA2 -bS1", "wA2 bS2/", "wA2 bS2-", "wA2 bB1/", "wA2 bB1-", "wA2 bB1\", "wA2 bM/", "wA2 /bM", "wA2 -bM", "wA2 \bM", "wA2 bL\", "wA2 -bL", "wA2 \bL", "wA3 wQ-", "wA3 wQ\", "wA3 wA1/", "wA3 -wA1", "wA3 wA2/", "wA3 wA2\", "wA3 /wA2", "wA3 -wA2", "wA3 \wA2", "wA3 -wG1", "wA3 \wG1", "wA3 wG3/", "wA3 wG3-", "wA3 /wG3", "wA3 \wG3", "wA3 wS2\", "wA3 -wS2", "wA3 \wS2", "wA3 wL-", "wA3 wL\", "wA3 /wL", "wA3 /bQ", "wA3 bA3-", "wA3 \bA3", "wA3 bG1/", "wA3 bG1-", "wA3 bG1\", "wA3 /bG1", "wA3 -bG1", "wA3 bG2-", "wA3 /bG2", "wA3 -bG2", "wA3 bG3-", "wA3 bG3\", "wA3 /bG3", "wA3 -bG3", "wA3 \bG3", "wA3 -bS1", "wA3 bS2/", "wA3 bS2-", "wA3 bB1/", "wA3 bB1-", "wA3 bB1\", "wA3 bM/", "wA3 /bM", "wA3 -bM", "wA3 \bM", "wA3 bL\", "wA3 -bL", "wA3 \bL", "wG1 wQ-", "wG1 wA1/", "wG1 wA3\", "wG1 \wA3", "wG1 wG3-", "wG1 wL\", "wG1 /bG3", "wG2 wQ-", "wG2 wQ\", "wG2 wA1/", "wG2 -wA1", "wG2 wA2/", "wG2 wA2\", "wG2 /wA2", "wG2 -wA2", "wG2 \wA2", "wG2 wA3/", "wG2 wA3-", "wG2 wA3\", "wG2 \wA3", "wG2 -wG1", "wG2 \wG1", "wG2 wG3/", "wG2 wG3-", "wG2 /wG3", "wG2 \wG3", "wG2 \wS2", "wG2 wL-", "wG2 wL\", "wS1 wQ-", "wS1 wQ\", "wS1 wA1/", "wS1 -wA1", "wS1 wA2/", "wS1 wA2\", "wS1 /wA2", "wS1 -wA2", "wS1 \wA2", "wS1 wA3/", "wS1 wA3-", "wS1 wA3\", "wS1 \wA3", "wS1 -wG1", "wS1 \wG1", "wS1 wG3/", "wS1 wG3-", "wS1 /wG3", "wS1 \wG3", "wS1 \wS2", "wS1 wL-", "wS1 wL\", "wB1 wQ-", "wB1 wQ\", "wB1 wA1/", "wB1 -wA1", "wB1 wA2/", "wB1 wA2\", "wB1 /wA2", "wB1 -wA2", "wB1 \wA2", "wB1 wA3/", "wB1 wA3-", "wB1 wA3\", "wB1 \wA3", "wB1 -wG1", "wB1 \wG1", "wB1 wG3/", "wB1 wG3-", "wB1 /wG3", "wB1 \wG3", "wB1 \wS2", "wB1 wL-", "wB1 wL\", "wB2 wQ-", "wB2 wQ\", "wB2 wA1/", "wB2 -wA1", "wB2 wA2/", "wB2 wA2\", "wB2 /wA2", "wB2 -wA2", "wB2 \wA2", "wB2 wA3/", "wB2 wA3-", "wB2 wA3\", "wB2 \wA3", "wB2 -wG1", "wB2 \wG1", "wB2 wG3/", "wB2 wG3-", "wB2 /wG3", "wB2 \wG3", "wB2 \wS2", "wB2 wL-", "wB2 wL\", "wM wQ-", "wM wQ\", "wM wA1/", "wM -wA1", "wM wA2/", "wM wA2\", "wM /wA2", "wM -wA2", "wM \wA2", "wM wA3/", "wM wA3-", "wM wA3\", "wM \wA3", "wM -wG1", "wM \wG1", "wM wG3/", "wM wG3-", "wM /wG3", "wM \wG3", "wM \wS2", "wM wL-", "wM wL\", "wL wQ-", "wL wQ\", "wL wA1/", "wL -wA1", "wL wA2\", "wL wA3/", "wL wA3-", "wL wA3\", "wL \wA3", "wL -wG1", "wL \wG1", "wL wG3-", "wL /wG3", "wL wS2\", "wL -wS2", "wL \wS2", "wL bA3-", "wL \bA3", "wL bS2/", "wL bM/", "wP wQ-", "wP wQ\", "wP wA1/", "wP -wA1", "wP wA2/", "wP wA2\", "wP /wA2", "wP -wA2", "wP \wA2", "wP wA3/", "wP wA3-", "wP wA3\", "wP \wA3", "wP -wG1", "wP \wG1", "wP wG3/", "wP wG3-", "wP /wG3", "wP \wG3", "wP \wS2", "wP wL-", "wP wL\"] + +# Apply action "wA3 wL\" +action: 674 + +# State 21 +# Base+MLP;InProgress;Black[11];wS2;bA3 /wS2;wG1 wS2/;bS1 /bA3;wQ wG1-;bS2 bS1-;wL wG1\;bQ /bS2;wA3 wQ/;bL /bS1;wA1 -wA3;bG2 bQ\;wG3 \wA1;bG1 bG2\;wA2 \wS2;bM \bS1;wA2 wS2\;bB1 bQ-;wA2 -wG3;bG3 /bL;wA3 wL\ +IsTerminal() = False +History() = [1630, 3391, 840, 4238, 29, 4460, 2382, 2901, 588, 5246, 221, 3824, 1188, 3663, 453, 5052, 450, 4607, 438, 4105, 674] +HistoryString() = "1630, 3391, 840, 4238, 29, 4460, 2382, 2901, 588, 5246, 221, 3824, 1188, 3663, 453, 5052, 450, 4607, 438, 4105, 674" +IsChanceNode() = False +IsSimultaneousNode() = False +CurrentPlayer() = 1 +InformationStateString(0) = "1630, 3391, 840, 4238, 29, 4460, 2382, 2901, 588, 5246, 221, 3824, 1188, 3663, 453, 5052, 450, 4607, 438, 4105, 674" +InformationStateString(1) = "1630, 3391, 840, 4238, 29, 4460, 2382, 2901, 588, 5246, 221, 3824, 1188, 3663, 453, 5052, 450, 4607, 438, 4105, 674" +ObservationString(0) = "Base+MLP;InProgress;Black[11];wS2;bA3 /wS2;wG1 wS2/;bS1 /bA3;wQ wG1-;bS2 bS1-;wL wG1\\;bQ /bS2;wA3 wQ/;bL /bS1;wA1 -wA3;bG2 bQ\\;wG3 \\wA1;bG1 bG2\\;wA2 \\wS2;bM \\bS1;wA2 wS2\\;bB1 bQ-;wA2 -wG3;bG3 /bL;wA3 wL\\" +ObservationString(1) = "Base+MLP;InProgress;Black[11];wS2;bA3 /wS2;wG1 wS2/;bS1 /bA3;wQ wG1-;bS2 bS1-;wL wG1\\;bQ /bS2;wA3 wQ/;bL /bS1;wA1 -wA3;bG2 bQ\\;wG3 \\wA1;bG1 bG2\\;wA2 \\wS2;bM \\bS1;wA2 wS2\\;bB1 bQ-;wA2 -wG3;bG3 /bL;wA3 wL\\" +ObservationTensor(0): +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◉◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◉◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◉◉◉◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◉◯◯◉◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◉◉◯◉◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◉◯◯◉◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◉◯◯◯◉◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◉◯◉◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◉◉◉◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◉◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +ObservationTensor(1): +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◉◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◉◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◉◉◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◯◉◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◉◯◉◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◯◉◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◉◯◯◯◉◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◉◯◉◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◉◉◉◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◉◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉◉ +Rewards() = [0, 0] +Returns() = [0, 0] +LegalActions() = [3041, 3066, 3067, 3068, 3069, 3070, 3074, 3076, 3077, 3081, 3082, 3083, 3084, 3085, 3091, 3102, 3103, 3118, 3119, 3120, 3124, 3126, 3127, 3237, 3262, 3263, 3264, 3265, 3266, 3270, 3272, 3273, 3277, 3278, 3279, 3280, 3281, 3287, 3298, 3299, 3314, 3315, 3316, 3320, 3322, 3323, 3708, 3927, 3963, 4334, 4335, 4438, 4446, 4474, 4475, 4532, 4612, 4634, 4642, 4647, 4663, 4668, 4805, 4830, 4831, 4832, 4833, 4834, 4838, 4840, 4841, 4845, 4846, 4847, 4848, 4849, 4855, 4866, 4867, 4882, 4883, 4884, 4888, 4890, 4891, 4900, 4901, 4902, 4907, 4908, 4911, 4914, 4916, 4917, 4918, 4919, 4921, 4922, 4923, 4924, 4932, 4933, 4942, 4943, 4945, 4947, 4960, 4961, 4985, 5001, 5024, 5026, 5027, 5028, 5029, 5030, 5034, 5036, 5037, 5041, 5042, 5043, 5044, 5045, 5051, 5055, 5061, 5062, 5063, 5084, 5086, 5087, 5393, 5418, 5419, 5420, 5421, 5422, 5426, 5428, 5429, 5433, 5434, 5435, 5436, 5437, 5443, 5454, 5455, 5470, 5471, 5472, 5476, 5478, 5479] +StringLegalActions() = ["bA1 /bQ", "bA1 bG1/", "bA1 bG1-", "bA1 bG1\", "bA1 /bG1", "bA1 -bG1", "bA1 bG2-", "bA1 /bG2", "bA1 -bG2", "bA1 bG3-", "bA1 bG3\", "bA1 /bG3", "bA1 -bG3", "bA1 \bG3", "bA1 -bS1", "bA1 bB1-", "bA1 bB1\", "bA1 /bM", "bA1 -bM", "bA1 \bM", "bA1 bL\", "bA1 -bL", "bA1 \bL", "bA2 /bQ", "bA2 bG1/", "bA2 bG1-", "bA2 bG1\", "bA2 /bG1", "bA2 -bG1", "bA2 bG2-", "bA2 /bG2", "bA2 -bG2", "bA2 bG3-", "bA2 bG3\", "bA2 /bG3", "bA2 -bG3", "bA2 \bG3", "bA2 -bS1", "bA2 bB1-", "bA2 bB1\", "bA2 /bM", "bA2 -bM", "bA2 \bM", "bA2 bL\", "bA2 -bL", "bA2 \bL", "bG1 \bM", "bG3 wA1/", "bG3 wG3-", "bS2 wA3-", "bS2 wA3\", "bS2 bG1/", "bS2 bG2-", "bS2 bB1-", "bS2 bB1\", "bB1 /wA3", "bB1 bQ", "bB1 bG1/", "bB1 bG2-", "bB1 bG2", "bB1 bS2-", "bB1 bS2", "bB2 /bQ", "bB2 bG1/", "bB2 bG1-", "bB2 bG1\", "bB2 /bG1", "bB2 -bG1", "bB2 bG2-", "bB2 /bG2", "bB2 -bG2", "bB2 bG3-", "bB2 bG3\", "bB2 /bG3", "bB2 -bG3", "bB2 \bG3", "bB2 -bS1", "bB2 bB1-", "bB2 bB1\", "bB2 /bM", "bB2 -bM", "bB2 \bM", "bB2 bL\", "bB2 -bL", "bB2 \bL", "bM wQ/", "bM wQ-", "bM wQ\", "bM wA1/", "bM wA1-", "bM -wA1", "bM wA2/", "bM wA2\", "bM /wA2", "bM -wA2", "bM \wA2", "bM wA3/", "bM wA3-", "bM wA3\", "bM /wA3", "bM -wG1", "bM \wG1", "bM wG3/", "bM wG3-", "bM /wG3", "bM \wG3", "bM -wS2", "bM \wS2", "bM wL-", "bM /bQ", "bM \bA3", "bM bG1/", "bM bG1-", "bM bG1\", "bM /bG1", "bM -bG1", "bM bG2-", "bM /bG2", "bM -bG2", "bM bG3-", "bM bG3\", "bM /bG3", "bM -bG3", "bM \bG3", "bM -bS1", "bM bS2-", "bM bB1/", "bM bB1-", "bM bB1\", "bM bL\", "bM -bL", "bM \bL", "bP /bQ", "bP bG1/", "bP bG1-", "bP bG1\", "bP /bG1", "bP -bG1", "bP bG2-", "bP /bG2", "bP -bG2", "bP bG3-", "bP bG3\", "bP /bG3", "bP -bG3", "bP \bG3", "bP -bS1", "bP bB1-", "bP bB1\", "bP /bM", "bP -bM", "bP \bM", "bP bL\", "bP -bL", "bP \bL"] + +# Apply action "bG3 wA1/" +action: 3927 + +# State 22 +# Apply action "wB1 -wG1" +action: 1796 + +# State 23 +# Apply action "bB1 /wA3" +action: 4532 + +# State 24 +# Apply action "wA3 /bG1" +action: 717 + +# State 25 +# Apply action "bL /wL" +action: 5183 + +# State 26 +# Apply action "wM wA2/" +action: 2170 + +# State 27 +# Apply action "bB1 wL\" +action: 4594 + +# State 28 +# Apply action "wA2 \bM" +action: 572 + +# State 29 +# Apply action "bL -bQ" +action: 5198 + +# State 30 +# Apply action "wA2 bQ-" +action: 491 + +# State 31 +# Apply action "bA1 bL\" +action: 3124 + +# State 32 +# Base+MLP;WhiteWins;White[17];wS2;bA3 /wS2;wG1 wS2/;bS1 /bA3;wQ wG1-;bS2 bS1-;wL wG1\;bQ /bS2;wA3 wQ/;bL /bS1;wA1 -wA3;bG2 bQ\;wG3 \wA1;bG1 bG2\;wA2 \wS2;bM \bS1;wA2 wS2\;bB1 bQ-;wA2 -wG3;bG3 /bL;wA3 wL\;bG3 wA1/;wB1 -wG1;bB1 /wA3;wA3 /bG1;bL /wL;wM wA2/;bB1 wL\;wA2 \bM;bL -bQ;wA2 bQ-;bA1 bL\ +IsTerminal() = True +History() = [1630, 3391, 840, 4238, 29, 4460, 2382, 2901, 588, 5246, 221, 3824, 1188, 3663, 453, 5052, 450, 4607, 438, 4105, 674, 3927, 1796, 4532, 717, 5183, 2170, 4594, 572, 5198, 491, 3124] +HistoryString() = "1630, 3391, 840, 4238, 29, 4460, 2382, 2901, 588, 5246, 221, 3824, 1188, 3663, 453, 5052, 450, 4607, 438, 4105, 674, 3927, 1796, 4532, 717, 5183, 2170, 4594, 572, 5198, 491, 3124" +IsChanceNode() = False +IsSimultaneousNode() = False +CurrentPlayer() = -4 +InformationStateString(0) = "1630, 3391, 840, 4238, 29, 4460, 2382, 2901, 588, 5246, 221, 3824, 1188, 3663, 453, 5052, 450, 4607, 438, 4105, 674, 3927, 1796, 4532, 717, 5183, 2170, 4594, 572, 5198, 491, 3124" +InformationStateString(1) = "1630, 3391, 840, 4238, 29, 4460, 2382, 2901, 588, 5246, 221, 3824, 1188, 3663, 453, 5052, 450, 4607, 438, 4105, 674, 3927, 1796, 4532, 717, 5183, 2170, 4594, 572, 5198, 491, 3124" +ObservationString(0) = "Base+MLP;WhiteWins;White[17];wS2;bA3 /wS2;wG1 wS2/;bS1 /bA3;wQ wG1-;bS2 bS1-;wL wG1\\;bQ /bS2;wA3 wQ/;bL /bS1;wA1 -wA3;bG2 bQ\\;wG3 \\wA1;bG1 bG2\\;wA2 \\wS2;bM \\bS1;wA2 wS2\\;bB1 bQ-;wA2 -wG3;bG3 /bL;wA3 wL\\;bG3 wA1/;wB1 -wG1;bB1 /wA3;wA3 /bG1;bL /wL;wM wA2/;bB1 wL\\;wA2 \\bM;bL -bQ;wA2 bQ-;bA1 bL\\" +ObservationString(1) = "Base+MLP;WhiteWins;White[17];wS2;bA3 /wS2;wG1 wS2/;bS1 /bA3;wQ wG1-;bS2 bS1-;wL wG1\\;bQ /bS2;wA3 wQ/;bL /bS1;wA1 -wA3;bG2 bQ\\;wG3 \\wA1;bG1 bG2\\;wA2 \\wS2;bM \\bS1;wA2 wS2\\;bB1 bQ-;wA2 -wG3;bG3 /bL;wA3 wL\\;bG3 wA1/;wB1 -wG1;bB1 /wA3;wA3 /bG1;bL /wL;wM wA2/;bB1 wL\\;wA2 \\bM;bL -bQ;wA2 bQ-;bA1 bL\\" +ObservationTensor(0): +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◉◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◉◉◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◉◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◉◯◯◯◉◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◉◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◉◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯ ◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◉◯◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◉◉◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +ObservationTensor(1): +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◉◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ + +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◉◉◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◉◯◯◯◯ ◯◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◉◯◯◯◉◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◉◯◯◯◯◉◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◉◯◯◯◉◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◉◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◉◯◯◉◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◉◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◉◉◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ ◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯◯ +Rewards() = [1, -1] +Returns() = [1, -1] diff --git a/open_spiel/python/tests/pyspiel_test.py b/open_spiel/python/tests/pyspiel_test.py index eb5fba42b0..ded7b3a61c 100644 --- a/open_spiel/python/tests/pyspiel_test.py +++ b/open_spiel/python/tests/pyspiel_test.py @@ -63,6 +63,7 @@ "havannah", "hex", "hearts", + "hive", "kriegspiel", "kuhn_poker", "laser_tag",