#!/usr/bin/env python3
from __future__ import annotations
from typing import Callable, Iterable, Optional, List, Set
import collections
import enum
import json
import sys


# Třídy reprezentující hru

class Direction(enum.Enum):
    UP = 0
    LEFT = 1
    DOWN = 2
    RIGHT = 3
    STAY = None

    def combine(self, other) -> Direction:
        return Direction((self.value + other.value)%4)

    def invert(self) -> Direction:
        if self == Direction.STAY:
            return self
        return self.combine(Direction.DOWN)

    def __str__(self) -> str:
        return self.name.lower()


class Team:
    home: 'Field'

    def __init__(self, id: int, is_me: bool) -> None:
        self.id: int = id
        self.is_me = is_me
        self.protected_fields: List[Field] = []
        self.occupied: List[Field] = []
        self.members: List[Member] = []

    def __eq__(self, other: Field) -> bool:
        return (self.id) == (other.id)

    def __hash__(self) -> int:
        return hash(self.id)


class Member:
    def __init__(self, field: Field, team: int, id: int) -> None:
        self.field = field
        self.team = team
        self.id = id
        self.action = Direction.STAY


class Field:
    members: List[Member]

    def __init__(self, i: int, j: int, hill: bool,
                 home_for_team: Optional[Team],
                 occupied_by_team: Optional[Team],
                 protected_for_team: Optional[Team],) -> None:
        self.i: int = i
        self.j: int = j
        self.hill: bool = hill
        self.home_for_team: Optional[Team] = home_for_team
        self.occupied_by_team: Optional[Team] = occupied_by_team
        self.protected_for_team: Optional[Team] = protected_for_team

    def __eq__(self, other: Field) -> bool:
        return (self.i, self.j) == (other.i, other.j)

    def __hash__(self) -> int:
        return hash((self.i, self.j))

    def get_neighbour_field(self, action: Direction) -> Field:
        if action == Direction.UP:
            neighbour_i = self.i - 1
            neighbour_j = self.j
        elif action == Direction.DOWN:
            neighbour_i = self.i + 1
            neighbour_j = self.j
        elif action == Direction.LEFT:
            neighbour_i = self.i
            neighbour_j = self.j - 1
        elif action == Direction.RIGHT:
            neighbour_i = self.i
            neighbour_j = self.j + 1
        else:
            neighbour_i = self.i
            neighbour_j = self.j
        # ensure coords are in bounds
        neighbour_i %= len(state.world)
        neighbour_j %= len(state.world[0])
        return state.world[neighbour_i][neighbour_j]

    def is_accessible(self, team: Team) -> bool:
        """If this field is accessible for the given team."""

        if self.hill:
            return False
        if (self.protected_for_team is not None and
            self.protected_for_team != team):
            return False
        return True

# Celý stav hry včetně parsování a vypisování

class State:
    def __init__(self, state: dict) -> None:
        self.teams = [Team(i, i==state["team_id"]) for i in range(state["teams_count"])]
        self.world = self._parse_world(state["state"]["world"])
        self.my_team: Team = self.teams[state["team_id"]]
        self.round_number: int = state["round"]
        self.time_to_response: Optional[int] = state["time_to_response"]

    def _parse_world(self, world: dict) -> List[List[Field]]:
        def get_team(team_id):
            return None if team_id is None else self.teams[team_id]

        fields = []
        for i, row in enumerate(world):
            fields_row = []
            for j, field in enumerate(row):
                parsed_field = Field(
                    i, j,
                    field["hill"],
                    get_team(field["home_for_team"]),
                    get_team(field["occupied_by_team"]),
                    get_team(field["protected_for_team"]),
                )
                if parsed_field.home_for_team:
                    parsed_field.home_for_team.home = parsed_field
                if parsed_field.occupied_by_team:
                    parsed_field.occupied_by_team.occupied.append(parsed_field)
                if parsed_field.protected_for_team:
                    parsed_field.protected_for_team.protected_fields.append(parsed_field)
                members = []
                for member in field["members"]:
                    m = Member(
                        parsed_field,
                        self.teams[member["team"]],
                        member["id"],
                    )
                    members.append(m)
                    m.team.members.append(m)
                parsed_field.members = members
                fields_row.append(parsed_field)

            fields.append(fields_row)
        return fields


    def build_turn(self) -> dict:
        for team in self.teams:
            if not team.is_me:
                for member in team.members:
                    if member.action is not Direction.STAY:
                        raise Exception("Akce přiřazena cizímu týmu")
        return {
            "members": [
                {"id": member.id, "action": str(member.action)}
                for member in self.my_team.members
            ]
        }

state: State

# Algoritmy

def find_fields(predicate: Callable[[Field], bool]) -> List[Field]:
    """Find all fields that satisfy the given predicate."""

    result = []
    for row in state.world:
        for field in row:
            if predicate(field):
                result.append(field)
    return result


def pathfind(member: Member, goal: Field) -> Direction:
    """Find the shortest path from member position to goal.

    Returns the first action to take.
    If there is no path, returns Action.STAY.
    """

    # BFS from goal to member
    # this direction makes it easier to realize that no path exists
    explored: Set[Field] = set()
    queue = collections.deque([goal])
    while queue:
        field = queue.popleft()
        for action in Direction:
            neighbour = field.get_neighbour_field(action)
            if (neighbour in explored or
                not neighbour.is_accessible(member.team)):
                continue
            if neighbour == member.field:
                return action.invert()
            queue.append(neighbour)
            explored.add(neighbour)
    return Direction.STAY

# main (zde doplňte kód)

def main() -> None:
    global state
    state = State(json.loads(sys.stdin.read()))

    # TODO: set actions for all yours members
    # example: all members go up
    for member in state.teams[1].members:
        member.action = Direction.UP

    print(json.dumps(state.build_turn()))

if __name__ == '__main__':
    main()