Untitled

using System;
using System.Collections.Generic;
using System.Linq;

namespace Rubiks_Matrix
{
    class Program
    {

        static void Main(string[] args)
        {
            var size = Console.ReadLine().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Select(int.Parse).ToArray();

            var commandsCount = int.Parse(Console.ReadLine());

            var matrix = new int[size[0], size[1]];


            var counter = 1;
            for (int row = 0; row < matrix.GetLength(0); row++)
            {

                for (int col = 0; col < matrix.GetLength(1); col++)
                {
                    matrix[row, col] = counter;
                    counter++;
                }
            }

            for (int i = 0; i < commandsCount; i++)
            {
                var command = Console.ReadLine().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).ToArray();

                var rowOrCol = int.Parse(command[0]);
                var direction = command[1];
                var moves = int.Parse(command[2]);

                switch (command[1])
                {
                    case "left":
                        var colsLeft = matrix.GetLength(1);
                        var restLeft = moves % colsLeft;
                        var rowLeft = new Queue<int>();
                        for (int h = 0; h < colsLeft; h++)
                        {
                            rowLeft.Enqueue(matrix[rowOrCol, h]);
                        }
                        for (int c = 0; c < restLeft; c++)
                        {
                            rowLeft.Enqueue(rowLeft.Dequeue());
                        }
                        for (int d = 0; d < colsLeft; d++)
                        {
                            matrix[rowOrCol, d] = rowLeft.Dequeue();
                        }
                        break;
                    case "right":
                        var colsRight = matrix.GetLength(1);
                        var restRight = moves % colsRight;
                        var rowRight = new Queue<int>();
                        for (int f = colsRight - 1; f >= 0; f--)
                        {
                            rowRight.Enqueue(matrix[rowOrCol, f]);
                        }
                        for (int g = 0; g < restRight; g++)
                        {
                            rowRight.Enqueue(rowRight.Dequeue());
                        }
                        for (int e = colsRight - 1; e >= 0; e--)
                        {
                            matrix[rowOrCol, e] = rowRight.Dequeue();
                        }
                        break;
                    case "down":
                        int rowsDown = matrix.GetLength(0);
                        int restDown = moves % rowsDown;
                        Queue<int> columnDown = new Queue<int>();
                        for (int row = (rowsDown - 1); row >= 0; row--)
                        {
                                columnDown.Enqueue(matrix[row, rowOrCol]);
                        }
                        for (int j = 0; j < restDown; j++)
                        {
                            columnDown.Enqueue(columnDown.Dequeue());
                        }
                        for (int k = (rowsDown - 1); k >= 0; k--)
                        {
                            matrix[k, rowOrCol] = columnDown.Dequeue();
                        }
                        break;
                    case "up":
                        int rowsUp = matrix.GetLength(0);
                        int restUp = moves % rowsUp;
                        Queue<int> columnUp = new Queue<int>();
                        for (int row = 0; row < rowsUp; row++)
                        {
                                columnUp.Enqueue(matrix[row, rowOrCol]);
                        }
                        for (int j = 0; j < restUp; j++)
                        {
                            columnUp.Enqueue(columnUp.Dequeue());
                        }
                        for (int k = 0; k < matrix.GetLength(0); k++)
                        {
                            matrix[k, rowOrCol] = columnUp.Dequeue();
                        }
                        break;
                }
            }
            var expected = 1;
            for (int row = 0; row < matrix.GetLength(0); row++)
            {
                for (int col = 0; col < matrix.GetLength(1); col++)
                {
                    if (matrix[row,col]==expected)
                    {
                        Console.WriteLine("No swap required");
                        expected++;
                        continue;
                    }
                    for (int r = 0; r < matrix.GetLength(0); r++)
                    {
                        for (int c = 0; c < matrix.GetLength(1); c++)
                        {
                            if (matrix[r, c] == expected)
                            {
                                var temp = matrix[row, col];
                                matrix[row,col]=matrix[r,c];
                                matrix[r, c] = temp;
                                Console.WriteLine($"Swap ({row}, {col}) with ({r}, {c})");

                                break;
                            }
                        }
                    }
                    expected++;
                }
            }
        }
    }
}