Sneaking

using System;


class Sneaking
{
    static void Main()
    {
        int rows = int.Parse(Console.ReadLine());

        char[][] matrix = FillTheMatrix(rows);

        string turns = Console.ReadLine();

        int[] samDimensions = FindSamOrNikoladze(matrix, 'S');
        int[] nikoladzeDimensions = FindSamOrNikoladze(matrix, 'N');

        bool isSamDead = false;

        for (int i = 0; i < turns.Length; i++)
        {
            isSamDead = EnemiesMove(matrix, samDimensions);

            if (isSamDead) { break; }

            if (turns[i] != 'W')
            {
                samDimensions = SamMove(matrix, samDimensions, turns[i], nikoladzeDimensions);
            }

            if (matrix[nikoladzeDimensions[0]][nikoladzeDimensions[1]] == 'X')
            {
                Console.WriteLine("Nikoladze killed!");
                break;
            }

            //Console.WriteLine();
            //PrintTheMatrix(matrix);
        }

        if (matrix[samDimensions[0]][samDimensions[1]] == 'X')
        {
            Console.WriteLine($"Sam died at {samDimensions[0]}, {samDimensions[1]}");
        }

        //Console.WriteLine();
        PrintTheMatrix(matrix);
    }

    private static int[] SamMove(char[][] matrix, int[] samDimensions, char turn, int[] nikoladzeDimensions)
    {
        int samRow = samDimensions[0];
        int samCol = samDimensions[1];

        int nikoladzeRow = nikoladzeDimensions[0];
        int nikoladzeCol = nikoladzeDimensions[1];

        switch (turn)
        {
            case 'U':
                if (samRow > 0)
                {
                    matrix[samRow - 1][samCol] = 'S';
                    matrix[samRow][samCol] = '.';
                    samDimensions[0] = samRow - 1;
                }
                break;
            case 'D':
                if (samRow < matrix.Length - 1)
                {
                    matrix[samRow + 1][samCol] = 'S';
                    matrix[samRow][samCol] = '.';
                    samDimensions[0] = samRow + 1;
                }
                break;
            case 'R':
                if (samCol < matrix[0].Length - 1)
                {
                    matrix[samRow][samCol + 1] = 'S';
                    matrix[samRow][samCol] = '.';
                    samDimensions[1] = samCol + 1;
                }
                break;
            case 'L':
                if (samCol > 0)
                {
                    matrix[samRow][samCol - 1] = 'S';
                    matrix[samRow][samCol] = '.';
                    samDimensions[1] = samCol - 1;
                }
                break;
            default:
                break;
        }

        samRow = samDimensions[0];

        if (samRow == nikoladzeRow)
        {
            matrix[nikoladzeRow][nikoladzeCol] = 'X';
            return samDimensions;
        }

        return samDimensions;
    }

    private static int[] FindSamOrNikoladze(char[][] matrix, char ch)
    {
        int[] rowAndCol = new int[2];

        for (int row = 0; row < matrix.Length; row++)
        {
            for (int col = 0; col < matrix[row].Length; col++)
            {
                if (matrix[row][col] == ch)
                {
                    rowAndCol[0] = row;
                    rowAndCol[1] = col;
                }
            }
        }

        return rowAndCol;
    }



    private static bool EnemiesMove(char[][] matrix, int[] samDimensions)
    {
        bool samIsDead = false;
        char enemy = ' ';

        int enemyRow = 0;
        int enemyCol = 0;

        for (int row = 0; row < matrix.Length; row++)
        {
            for (int col = 0; col < matrix[row].Length; col++)
            {
                if (matrix[row][col] == 'b')
                {
                    if (col == matrix[row].Length - 1)
                    {
                        matrix[row][col] = 'd';
                        enemyRow = row;
                        enemyCol = col;
                        enemy = 'd';
                    }
                    else
                    {
                        matrix[row][col + 1] = 'b';
                        matrix[row][col] = '.';
                        enemyRow = row;
                        enemyCol = col + 1;
                        enemy = 'b';
                    }
                    break;
                }
                else if (matrix[row][col] == 'd')
                {
                    if (col == 0)
                    {
                        matrix[row][col] = 'b';
                        enemyRow = row;
                        enemyCol = col;
                        enemy = 'b';
                    }
                    else
                    {
                        matrix[row][col - 1] = 'd';
                        matrix[row][col] = '.';
                        enemyRow = row;
                        enemyCol = col - 1;
                        enemy = 'd';
                    }
                    break;
                }
            }
        }

        samIsDead = KillSam(matrix, enemyRow, enemyCol, enemy);

        return samIsDead;
    }

    private static bool KillSam(char[][] matrix, int row, int col, char ch)
    {
        bool isHeDead = false;

        if (ch == 'b')
        {
            for (int i = col + 1; i < matrix[row].Length; i++)
            {
                if (matrix[row][i] == 'S')
                {
                    matrix[row][i] = 'X';
                    isHeDead = true;
                    break;
                }
            }
        }
        else if (ch == 'd')
        {
            for (int i = col - 1; i >= 0; i--)
            {
                if (matrix[row][i] == 'S')
                {
                    matrix[row][i] = 'X';
                    isHeDead = true;
                    break;
                }
            }
        }

        return isHeDead;
    }

    private static void PrintTheMatrix(char[][] matrix)
    {
        for (int row = 0; row < matrix.Length; row++)
        {
            Console.WriteLine(matrix[row]);
        }
    }

    private static char[][] FillTheMatrix(int rows)
    {
        char[][] matrix = new char[rows][];

        for (int row = 0; row < rows; row++)
        {
            string nextRow = Console.ReadLine();

            matrix[row] = nextRow.ToCharArray();
        }

        return matrix;
    }
}