MatrixOperator

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

public class MatrixOperator1
{
    #region  ReadMatrix
    private static void ReadMatrix(int rows, int[][] matrix)
    {
        for (int row = 0; row < rows; row++)
        {
            matrix[row] = Console.ReadLine().Split().Select(int.Parse).ToArray();
        }
    }
    #endregion
    #region PrintMatrix
    private static void PrintMatrix(int rows, int[][] matrix)
    {
        for (int row = 0; row < rows; row++)
        {
            Console.WriteLine(string.Join(" ", matrix[row]));
        }
    }
    #endregion
    static void Main()
    {
        int rows = int.Parse(Console.ReadLine());
        int[][] matrix = new int[rows][];
        ReadMatrix(rows, matrix);
        while (true)
        {
            string[] inputCommands = Console.ReadLine().Split().ToArray();
            #region StopProgram
            if (inputCommands[0] == "end")
            {
                break;
            }
            #endregion
            switch (inputCommands[0])
            {
                case "remove":
                    RemoveCommand(rows, inputCommands[1], matrix, inputCommands[2], int.Parse(inputCommands[3]));
                    break;
                case "swap":
                    SwapCommand(rows, int.Parse(inputCommands[1]), matrix, int.Parse(inputCommands[2]));
                    break;
                case "insert":
                    InsertCommand(rows, int.Parse(inputCommands[1]), matrix, int.Parse(inputCommands[2]));
                    break;
            }
        }
        PrintMatrix(rows, matrix);
    }

    private static void SwapCommand(int rows, int firstRow, int[][] matrix, int secondRow)
    {
        var temp = matrix[firstRow];
        matrix[firstRow] = matrix[secondRow];
        matrix[secondRow] = temp;
    }

    private static void InsertCommand(int rows, int inputCommand, int[][] matrix, int element)
    {
        for (int row = 0; row < rows; row++)
        {
            if (row == inputCommand)
            {
                List<int> insertCom = matrix[row].ToList();
                insertCom.Insert(0, element);
                matrix[row] = insertCom.ToArray();
            }
        }
    }

    private static void RemoveCommand(int rows, string inputCommand, int[][] matrix, string rowOrCol, int position)
    {
        switch (inputCommand)
        {
            case "positive":

                switch (rowOrCol)
                {
                    case "row":
                        RemovePositiveValueRow(rows, matrix, position);
                        break;
                    case "col":
                        RemovePositiveValueCol(rows, matrix, position);
                        break;
                }
                break;
            case "negative":
                switch (rowOrCol)
                {
                    case "row":
                        RemoveNegativeValueRow(rows, matrix, position);
                        break;
                    case "col":
                        RemoveNegativeValueCol(rows, matrix, position);
                        break;
                }
                break;

            case "odd":
                switch (rowOrCol)
                {
                    case "row":
                        RemoveOddValueRow(rows, matrix, position);
                        break;
                    case "col":
                        RemoveOddValueCol(rows, matrix, position);
                        break;
                }
                break;
            case "even":
                switch (rowOrCol)
                {
                    case "row":
                        RemoveEvenValueRow(rows, matrix, position);
                        break;
                    case "col":
                        RemoveEvenValueCol(rows, matrix, position);
                        break;
                }
                break;
        }
    }

    private static void RemoveEvenValueCol(int rows, int[][] matrix, int position)
    {
        int indexOfCol = position;
        for (int row = 0; row < rows; row++)
        {
            for (int col = 0; col < matrix[row].Length; col++)
            {
                if (indexOfCol > matrix[row].Length)
                {
                    continue;
                }

                if (col == indexOfCol)
                {
                    int valueOfIndex = matrix[row][col];
                    if (valueOfIndex % 2 == 0)
                    {
                        matrix[row] = matrix[row].Where(n => n != valueOfIndex).ToArray().ToArray();
                    }
                }
            }
        }
    }

    private static void RemoveOddValueCol(int rows, int[][] matrix, int position)
    {
        int indexOfCol = position;
        for (int row = 0; row < rows; row++)
        {
            for (int col = 0; col < matrix[row].Length; col++)
            {
                if (indexOfCol > matrix[row].Length)
                {
                    continue;
                }

                if (col == indexOfCol)
                {
                    int valueOfIndex = matrix[row][col];
                    if (valueOfIndex % 2 != 0)
                    {
                        matrix[row] = matrix[row].Where(n => n != valueOfIndex).ToArray().ToArray();
                    }
                }
            }
        }
    }

    private static void RemoveNegativeValueCol(int rows, int[][] matrix, int position)
    {
        int indexOfCol = position;
        for (int row = 0; row < rows; row++)
        {
            for (int col = 0; col < matrix[row].Length; col++)
            {
                if (indexOfCol > matrix[row].Length)
                {
                    continue;
                }

                if (col == indexOfCol)
                {
                    int valueOfIndex = matrix[row][col];
                    if (valueOfIndex < 0)
                    {
                        matrix[row] = matrix[row].Where(n => n != valueOfIndex).ToArray().ToArray();
                    }
                }
            }
        }
    }

    private static void RemovePositiveValueCol(int rows, int[][] matrix, int position)
    {
        int indexOfCol = position;
        for (int row = 0; row < rows; row++)
        {
            for (int col = 0; col < matrix[row].Length; col++)
            {
                if (indexOfCol > matrix[row].Length)
                {
                    continue;
                }

                if (col == indexOfCol)
                {
                    int valueOfIndex = matrix[row][col];
                    if (valueOfIndex >= 0)
                    {
                        matrix[row] = matrix[row].Where(n => n != valueOfIndex).ToArray().ToArray();
                    }
                }
            }
        }
    }

    private static void RemovePositiveValueRow(int rows, int[][] matrix, int position)
    {
        int indexOfRow = position;
        for (int row = 0; row < rows; row++)
        {
            if (row == indexOfRow)
            {
                matrix[row] = matrix[row].Where(r => r < 0).ToArray();
            }
        }
    }

    private static void RemoveNegativeValueRow(int rows, int[][] matrix, int position)
    {
        int indexOfRow = position;
        for (int row = 0; row < rows; row++)
        {
            if (row == indexOfRow)
            {
                matrix[row] = matrix[row].Where(r => r > 0).ToArray();
            }
        }
    }

    private static void RemoveOddValueRow(int rows, int[][] matrix, int position)
    {
        int indexOfRow = position;
        for (int row = 0; row < rows; row++)
        {
            if (row == indexOfRow)
            {
                matrix[row] = matrix[row].Where(r => r % 2 == 0).ToArray();
            }
        }
    }

    private static void RemoveEvenValueRow(int rows, int[][] matrix, int position)
    {
        int indexOfRow = position;
        for (int row = 0; row < rows; row++)
        {
            if (row == indexOfRow)
            {
                matrix[row] = matrix[row].Where(r => r % 2 != 0).ToArray();
            }
        }
    }
}