using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;

namespace Codingame {
    public class FallChallenge2022 {
        public static string ReadInput() => Console.ReadLine() ?? throw new InvalidProgramException("No input available!");

        public static void Main(string[] args) {
            string[] inputs;
            inputs = ReadInput().Split(' ');
            var width = int.Parse(inputs[0]);
            var height = int.Parse(inputs[1]);
            var state = new GameState(width, height, new FieldState[width, height]);

            // game loop
            while (true) {
                inputs = ReadInput().Split(' ');
                state.MyMatter = int.Parse(inputs[0]);
                state.OppMatter = int.Parse(inputs[1]);
                for (var i = 0; i < height; i++) for (var j = 0; j < width; j++) {
                        Coordinate2D coord = new(j, i);
                        ref var field = ref state[coord];
                        field.Coordinates = coord;
                        inputs = ReadInput().Split(' ');
                        field.ScrapAmount = int.Parse(inputs[0]);
                        field.Owner = (Owner)int.Parse(inputs[1]);
                        if (!Enum.IsDefined(field.Owner)) throw new InvalidProgramException("Invalid owner!");
                        field.Units = int.Parse(inputs[2]);
                        field.Recycler = int.Parse(inputs[3]) == 1;
                        field.CanBuild = int.Parse(inputs[4]) == 1;
                        field.CanSpawn = int.Parse(inputs[5]) == 1;
                        field.InRangeOfRecycler = int.Parse(inputs[6]) == 1;
                    }

                // Write an action using Console.WriteLine()
                // To debug: Console.Error.WriteLine("Debug messages...");

                var commands = GetCommands(state).ToList() is { Count: > 0 } cmds ? cmds : Command.Empty;
                Console.WriteLine(string.Join(';', commands.Select(i => i.GetCommandString())));
            }
        }

        public static IEnumerable<Command> GetCommands(GameState state) {
            var units = state.FindUnits();
            var enemies = state.FindUnits(Owner.Enemy);
            var neutral = state.FindFields(Owner.Neutral);
            var recyclers = state.FindFields(i => i.Recycler).Keys.ToList();
            var possibleBuilds = state.PossibleRecyclerSpots(recyclers).OrderByDescending(i => i.Value).Take(1).ToList();
            while (possibleBuilds.Count > 0) {
                Console.Error.WriteLine(string.Join("\n", state.PossibleRecyclerSpots(recyclers).OrderByDescending(i => i.Value).Select(i => $"Recycler at {i.Key} yields {i.Value} resources!")));
                var possibleBuild = possibleBuilds.First();
                if (state.MyMatter < GameState.RecyclerCost) break;
                state.MyMatter -= GameState.RecyclerCost;
                Console.Error.WriteLine($"Building recycler at {possibleBuild.Key} for {possibleBuild.Value} amount");
                yield return new Build(possibleBuild.Key);
                recyclers.Add(possibleBuild.Key);
                possibleBuilds = state.PossibleRecyclerSpots(recyclers).OrderByDescending(i => i.Value).Take(1).ToList();
            }
            while (state.MyMatter >= GameState.RobotCost) {
                var maxRobots = state.MyMatter / GameState.RobotCost;
                var cost = maxRobots * GameState.RobotCost;
                yield return new Spawn(maxRobots, units.First().Key);
                state.MyMatter -= cost;
            }
            foreach (var (position, amount) in units) {
                var (enemyPosition, enemyAmount) = enemies.MinBy(i => (i.Key - position).ManhattanDistance);
                yield return new Move(amount, position, enemyPosition);
            }
        }
    }

    public abstract record class Command {
        public virtual string GetCommandString() => $"{Name} {string.Join(' ', Args.Select(i => i.ToString()))}";
        protected virtual IEnumerable<object> Args { get; } = Enumerable.Empty<object>();
        public virtual string Name => GetType().Name.ToUpper();
        public static List<Command> Empty { get; } = new() { new Wait() };
    }
    public abstract record class CoordinateCommand(int X, int Y) : Command {
        public CoordinateCommand(Coordinate2D Coord) : this(Coord.X, Coord.Y) { }
        protected override IEnumerable<object> Args {
            get {
                yield return X;
                yield return Y;
            }
        }
    }
    public record class Move(int Amount, int FromX, int FromY, int ToX, int ToY) : Command {
        public Move(int Amount, Coordinate2D From, Coordinate2D To) : this(Amount, From.X, From.Y, To.X, To.Y) { }
        protected override IEnumerable<object> Args {
            get {
                yield return Amount;
                yield return FromX;
                yield return FromY;
                yield return ToX;
                yield return ToY;
            }
        }
    }
    public record class Build(int X, int Y) : CoordinateCommand(X, Y) {
        public Build(Coordinate2D coord) : this(coord.X, coord.Y) { }
    }
    public record class Spawn(int Amount, int X, int Y) : CoordinateCommand(X, Y) {
        public Spawn(int Amount, Coordinate2D Coord) : this(Amount, Coord.X, Coord.Y) { }
        protected override IEnumerable<object> Args => base.Args.Prepend(Amount);
    }
    public record class Wait : Command;
    public record class Message : Command;
    public enum Owner {
        Player = 1,
        Enemy = 0,
        Neutral = -1
    }
    public record struct GameState(int Width, int Height, FieldState[,] Fields, int MyMatter = 0, int OppMatter = 0) {
        public const int RecyclerCost = 10;
        public const int RobotCost = 10;
        public FieldState FieldAt(Coordinate2D coord) => this[coord];
        public ref FieldState this[Coordinate2D coord] => ref Fields[coord.X, coord.Y];
        public Dictionary<Coordinate2D, int> PossibleRecyclerSpots(IReadOnlyCollection<Coordinate2D> recyclers) {
            Dictionary<Coordinate2D, int> found = new();
            for (int y = 0; y < Height; y++)
                for (int x = 0; x < Width; x++) {
                    Coordinate2D coord = new(x, y);
                    var field = this[coord];
                    if (!field.CanBuild || field.InRangeOfRecycler) continue;
                    var potentialMaterial = coord.Neighbors().Append(coord)
                        .Where(WithinBounds)
                        .Select(FieldAt)
                        .Where(i => !i.InRangeOfRecycler && !NearRecycler(recyclers, i.Coordinates))
                        .Sum(i => i.ScrapAmount);
                    if (potentialMaterial != 0)
                        found[coord] = potentialMaterial;
                }
            return found;
        }
        public static bool NearRecycler(IReadOnlyCollection<Coordinate2D> recyclers, Coordinate2D coord)
            => recyclers.Any(i => (i - coord).ManhattanDistance <= 1);
        public Dictionary<Coordinate2D, int> FindWhere(Func<FieldState, int> find) {
            Dictionary<Coordinate2D, int> found = new();
            for (int y = 0; y < Height; y++)
                for (int x = 0; x < Width; x++) {
                    Coordinate2D coord = new(x, y);
                    var amount = find(this[coord]);
                    if (amount != 0) found[coord] = found.GetValueOrDefault(coord, 0) + amount;
                }
            return found;
        }
        public bool WithinBounds(Coordinate2D coord) => coord.X >= 0 && coord.X < Width && coord.Y >= 0 && coord.Y < Height;
        public Dictionary<Coordinate2D, FieldState> FindFields(Func<FieldState, bool> prediate) {
            Dictionary<Coordinate2D, FieldState> found = new();
            for (int y = 0; y < Height; y++)
                for (int x = 0; x < Width; x++) {
                    Coordinate2D coord = new(x, y);
                    var field = this[coord];
                    if (prediate(field)) found[coord] = field;
                }
            return found;
        }
        public Dictionary<Coordinate2D, FieldState> FindFields(Owner owner)
            => FindFields(i => i.Owner == owner);
        public Dictionary<Coordinate2D, int> FindUnits(Owner owner = Owner.Player)
            => FindWhere(i => i.Owner == owner && i is { Units: > 0 and var amount } ? amount : 0);

    }
    public record struct Coordinate2D(int X, int Y) {
        public override string ToString() => $"{X},{Y}";
        public IEnumerable<Coordinate2D> Neighbors() {
            yield return this with { X = X + 1 };
            yield return this with { X = X - 1 };
            yield return this with { Y = Y + 1 };
            yield return this with { Y = Y - 1 };
        }
        public static Coordinate2D operator -(Coordinate2D left, Coordinate2D right) => new(left.X - right.X, left.Y - right.Y);
        public static Coordinate2D operator +(Coordinate2D left, Coordinate2D right) => new(left.X + right.X, left.Y + right.Y);
        public int ManhattanDistance => Math.Abs(X) + Math.Abs(Y);
    }
    public record struct FieldState(int ScrapAmount, Owner Owner, int Units, bool Recycler, bool CanBuild, bool CanSpawn, bool InRangeOfRecycler, Coordinate2D Coordinates);
}