The Free Meteor Association (FMA) has got a problem: as meteors are moving, the Universal Cosmic Descriptive Humorous Program (UCDHP) needs to add a special module that would analyze this movement. 

UCDHP stores some secret information about meteors as an n × m table with integers in its cells. The order of meteors in the Universe is changing. That's why the main UCDHP module receives the following queries:

  * The query to swap two table rows; 
  * The query to swap two table columns; 
  * The query to obtain a secret number in a particular table cell. 



As the main UCDHP module is critical, writing the functional of working with the table has been commissioned to you.

Input

The first line contains three space-separated integers n, m and k (1 ≤ n, m ≤ 1000, 1 ≤ k ≤ 500000) — the number of table columns and rows and the number of queries, correspondingly.

Next n lines contain m space-separated numbers each — the initial state of the table. Each number p in the table is an integer and satisfies the inequality 0 ≤ p ≤ 106.

Next k lines contain queries in the format "si xi yi", where si is one of the characters "с", "r" or "g", and xi, yi are two integers.

  * If si = "c", then the current query is the query to swap columns with indexes xi and yi (1 ≤ x, y ≤ m, x ≠ y); 
  * If si = "r", then the current query is the query to swap rows with indexes xi and yi (1 ≤ x, y ≤ n, x ≠ y); 
  * If si = "g", then the current query is the query to obtain the number that located in the xi-th row and in the yi-th column (1 ≤ x ≤ n, 1 ≤ y ≤ m). 



The table rows are considered to be indexed from top to bottom from 1 to n, and the table columns — from left to right from 1 to m.

Output

For each query to obtain a number (si = "g") print the required number. Print the answers to the queries in the order of the queries in the input.

Examples

Input

3 3 5
1 2 3
4 5 6
7 8 9
g 3 2
r 3 2
c 2 3
g 2 2
g 3 2


Output

8
9
6


Input

2 3 3
1 2 4
3 1 5
c 2 1
r 1 2
g 1 3


Output

5

Note

Let's see how the table changes in the second test case.

After the first operation is fulfilled, the table looks like that:

2 1 4

1 3 5

After the second operation is fulfilled, the table looks like that:

1 3 5

2 1 4

So the answer to the third query (the number located in the first row and in the third column) will be 5.
import java.io.IOException;
import java.io.InputStream;
import java.util.InputMismatchException;

public class P222B_CosmicTables {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		InputReader inputReader = new InputReader(System.in);
		int n = inputReader.nextInt();
		int m = inputReader.nextInt();
		int k = inputReader.nextInt();

		int[][] numbers = inputReader.next2DIntArray(n, m);
		int[] rows = new int[n + 1];
		int[] columns = new int[m + 1];

		for (int i = 1; i <= n; i++) {
			rows[i] = i;
		}

		for (int i = 1; i <= m; i++) {
			columns[i] = i;
		}

		StringBuilder stringBuilder = new StringBuilder();
		int x = 0, y = 0, temp = 0;

		for (int i = 0; i < k; i++) {
			char command = inputReader.nextChar();
			x = inputReader.nextInt();
			y = inputReader.nextInt();

			if (command == 'c') {
				temp = columns[x];
				columns[x] = columns[y];
				columns[y] = temp;
			} else if (command == 'r') {
				temp = rows[x];
				rows[x] = rows[y];
				rows[y] = temp;
			} else if (command == 'g') {
				stringBuilder.append(numbers[rows[x]][columns[y]]);
				stringBuilder.append('\n');
			}
		}

		System.out.println(stringBuilder.toString().trim());
	}
}

class InputReader {

	private InputStream stream;
	private byte[] buf = new byte[1 << 16];
	private int curChar;
	private int numChars;

	public InputReader(InputStream stream) {
		this.stream = stream;
	}

	public int read() {
		if (numChars == -1)
			throw new InputMismatchException();
		if (curChar >= numChars) {
			curChar = 0;
			try {
				numChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (numChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	public int nextInt() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c & 15;
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public static boolean isSpaceChar(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	public char nextChar() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		return (char) c;
	}

	public int[] nextIntArray(int count) {
		int[] result = new int[count + 1];

		for (int i = 1; i <= count; i++) {
			result[i] = nextInt();
		}

		return result;
	}

	public int[][] next2DIntArray(int n, int m) {
		int[][] result = new int[n + 1][];

		for (int i = 1; i <= n; i++) {
			result[i] = nextIntArray(m);
		}

		return result;
	}

}