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.awt.*;
    import java.io.*;

    import java.math.BigInteger;
    import java.util.*;

    public class TaskC {

        static Long[][]dp;
        static int n, m, ans;
        static StringBuilder[]s1,s2;
        static int[]arr;



        public static void main(String[] args) throws Exception {

            Scanner sc = new Scanner(System.in);
            PrintWriter pw = new PrintWriter(System.out);

            int n = sc.nextInt();
            int m = sc.nextInt();
            int q = sc.nextInt();

            int[][]arr = new int[n][m];
            int[]row = new int[n];
            int[]col = new int[m];

            for (int i = 0 ; i < n ; i++)
                row[i] = i;

            for (int i = 0 ; i < m ; i++)
                col[i] = i;

            for (int i  = 0 ; i < n ; i++) {
                for (int j = 0; j < m; j++)
                    arr[i][j] = sc.nextInt();
           //     System.out.println(Arrays.toString(arr[i]));
            }
            while (q-- >0)
            {

                StringTokenizer st = new StringTokenizer(sc.nextLine());
                char t = st.nextToken().charAt(0);
                int i = Integer.parseInt(st.nextToken()) - 1;
                int j = Integer.parseInt(st.nextToken()) - 1;

                if( t == 'c')
                {
                    int tmp = col[i];
                    col[i] = col[j];
                    col[j] = tmp;
                }else if( t == 'r')
                {
                    int tmp = row[i];
                    row[i] = row[j];
                    row[j] = tmp;
                }else
                {
                    pw.println(arr[row[i]][col[j]]);
                }
              /*  System.out.println(Arrays.toString(row));
                System.out.println(Arrays.toString(col));*/
            }
            pw.close();

        }

        private static long gcd(long a, long b) {
            if( b == 0)
                return a;
            return gcd(b  , a%b);
        }

        static long lcm(int a, int b)
        {
            return (a*b)/gcd(a, b);
        }


        private  static int dis(int xa , int ya , int xb , int yb)
        {
            return (xa-xb)*(xa - xb) + (ya- yb)*(ya-yb);
        }


        static class Pair implements Comparable<Pair> {
            int x,y;


            public Pair(int x, int y) {
                this.x = x;
                this.y = y;
            }

            public int compareTo(Pair o) {
                if (y  == o.y)
                    return o.x - x;
                return y - o.y;

            }
            public double dis(Pair a){

                return (a.x - x)*(a.x - x) + (a.y-y)*(a.y-y);
            }

            public String toString() {
                return  x+" "+ y;
            }
            public boolean overlap(Pair a)
            {
            if((this.x >= a.x && this.x <= a.y) || (a.x >= this.x && a.x <= this.y)) return true;
                return false;

            }
        }

        static class Scanner {
            StringTokenizer st;
            BufferedReader br;

            public Scanner(FileReader r) {
                br = new BufferedReader(r);
            }

            public Scanner(InputStream s) {
                br = new BufferedReader(new InputStreamReader(s));
            }

            public String next() {
                while (st == null || !st.hasMoreTokens()) {
                    try {
                        st = new StringTokenizer(br.readLine());
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                }
                return st.nextToken();
            }

            public boolean check() {
                if (!st.hasMoreTokens())
                    return false;
                return true;
            }

            public int nextInt() {
                return Integer.parseInt(next());
            }

            public long nextLong() {
                return Long.parseLong(next());
            }

            public String nextLine() {
                try {
                    return br.readLine();
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }

            public double nextDouble() {
                String x = next();
                StringBuilder sb = new StringBuilder("0");
                double res = 0, f = 1;
                boolean dec = false, neg = false;
                int start = 0;
                if (x.charAt(0) == '-') {
                    neg = true;
                    start++;
                }
                for (int i = start; i < x.length(); i++)
                    if (x.charAt(i) == '.') {
                        res = Long.parseLong(sb.toString());
                        sb = new StringBuilder("0");
                        dec = true;
                    } else {
                        sb.append(x.charAt(i));
                        if (dec)
                            f *= 10;
                    }
                res += Long.parseLong(sb.toString()) / f;
                return res * (neg ? -1 : 1);
            }

            public boolean ready() {
                try {
                    return br.ready();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }