description: Mr. Chanek has a new game called Dropping Balls. Initially, Mr. Chanek has a grid a of size n × m
  
  Each cell (x,y) contains an integer a_{x,y} denoting the direction of how the ball will move.
  
    * a_{x,y}=1 — the ball will move to the right (the next cell is (x, y + 1)); 
    * a_{x,y}=2 — the ball will move to the bottom (the next cell is (x + 1, y)); 
    * a_{x,y}=3 — the ball will move to the left (the next cell is (x, y - 1)). 
  
  
  
  Every time a ball leaves a cell (x,y), the integer a_{x,y} will change to 2. Mr. Chanek will drop k balls sequentially, each starting from the first row, and on the c_1, c_2, ..., c_k-th (1 ≤ c_i ≤ m) columns.
  
  Determine in which column each ball will end up in (position of the ball after leaving the grid).
  
  Input
  
  The first line contains three integers n, m, and k (1 ≤ n, m ≤ 1000, 1 ≤ k ≤ 10^5) — the size of the grid and the number of balls dropped by Mr. Chanek.
  
  The i-th of the next n lines contains m integers a_{i,1},a_{i,2},…,a_{i,m} (1 ≤ a_{i,j} ≤ 3). It will satisfy a_{i, 1} ≠ 3 and a_{i, m} ≠ 1.
  
  The next line contains k integers c_1, c_2, …, c_k (1 ≤ c_i ≤ m) — the balls' column positions dropped by Mr. Chanek sequentially.
  
  Output
  
  Output k integers — the i-th integer denoting the column where the i-th ball will end.
  
  Examples
  
  Input
  
  
  5 5 3
  1 2 3 3 3
  2 2 2 2 2
  2 2 2 2 2
  2 2 2 2 2
  2 2 2 2 2
  1 2 1
  
  
  Output
  
  
  2 2 1 
  
  
  Input
  
  
  1 2 2
  1 3
  1 2
  
  
  Output
  
  
  1 2 
  
  Note
  
  In the first example, the first ball will drop as follows. Note that the cell (1, 1) will change direction to the bottom direction.
  
  <image>
  
  The second and third balls will drop as follows. 
  
  <image>
  
  All balls will be dropped from the first row and on the c_1, c_2, ..., c_k-th columns respectively. A ball will stop dropping once it leaves the grid.
solution: // 😀 
  
  import java.util.*;
  import java.io.*;
  
  public class J {
      static InputReader in;
      static PrintWriter out;
      static int mod = 1000_000_007;
  
      public static void main(String args[]) {
          new Thread(null, new Runnable() {
              public void run() {
                  try {
                      solve();
                      out.flush();
                      out.close();
                  } catch (Exception e) {
                      e.printStackTrace();
                  }
              }
          }, "1", 1 << 26).start();
      }
  
      public static void solve() {
          in = new InputReader(System.in);
          out = new PrintWriter(System.out);
  
  
              int n = in.nextInt();
              int m = in.nextInt();
              int k = in.nextInt();
              int a[][] = new int[n][m];
              for (int i = 0; i < n; i++) {
                  a[i] = in.nextIntArray(m);
              }
  
              int c[] = in.nextIntArray(k);
  
              for (int i = 0; i < k; i++) {
                  int ii = 0, jj = c[i]-1;
                  while (ii>=0 && ii <n && jj >= 0 && jj <m)
                  {
                      int prev_i = ii,prev_j = jj;
                      if(a[ii][jj] == 1)
                      {
                          jj++;
                      }
                      else if(a[ii][jj] == 2)
                      {
                          ii++;
                      }
                      else
                          jj--;
                      a[prev_i][prev_j]=2;
                  }
                  out.print((jj+1)+" ");
              }
              out.println();
  
  
      }
  
      static class InputReader {
          private final InputStream stream;
          private final byte[] buf = new byte[8192];
          private int curChar, numChars;
          private SpaceCharFilter filter;
  
          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 String nextLine() {
              int c = read();
              while (isSpaceChar(c)) {
                  c = read();
              }
              StringBuilder res = new StringBuilder();
              do {
                  res.appendCodePoint(c);
                  c = read();
              } while (!isEndOfLine(c));
              return res.toString();
          }
  
          public String readString() {
              int c = read();
              while (isSpaceChar(c)) {
                  c = read();
              }
              StringBuilder res = new StringBuilder();
              do {
                  res.appendCodePoint(c);
                  c = read();
              } while (!isSpaceChar(c));
              return res.toString();
          }
  
          public long nextLong() {
              int c = read();
              while (isSpaceChar(c)) {
                  c = read();
              }
              int sgn = 1;
              if (c == '-') {
                  sgn = -1;
                  c = read();
              }
              long res = 0;
              do {
                  if (c < '0' || c > '9') {
                      throw new InputMismatchException();
                  }
                  res *= 10;
                  res += c - '0';
                  c = read();
              } while (!isSpaceChar(c));
              return res * sgn;
          }
  
          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 - '0';
                  c = read();
              } while (!isSpaceChar(c));
              return res * sgn;
          }
  
          public int[] nextIntArray(int n) {
              int[] arr = new int[n];
              for (int i = 0; i < n; i++) {
                  arr[i] = nextInt();
              }
              return arr;
          }
  
          public long[] nextLongArray(int n) {
              long[] arr = new long[n];
              for (int i = 0; i < n; i++) {
                  arr[i] = nextLong();
              }
              return arr;
          }
  
          public boolean isSpaceChar(int c) {
              if (filter != null)
                  return filter.isSpaceChar(c);
              return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
          }
  
          private boolean isEndOfLine(int c) {
              return c == '\n' || c == '\r' || c == -1;
          }
  
          public interface SpaceCharFilter {
              public boolean isSpaceChar(int ch);
          }
      }
  
      public static long inv(long a, long b) {
          return 1 < a ? b - inv(b % a, a) * b / a : 1;
      }
  
      public static int[] sort(int[] arr) {
          List<Integer> temp = new ArrayList();
          for (int i : arr) temp.add(i);
          Collections.sort(temp);
          int start = 0;
          for (int i : temp) arr[start++] = i;
          return arr;
      }
  
      public static long[] sort(long[] arr) {
          List<Long> temp = new ArrayList();
          for (long i : arr) temp.add(i);
          Collections.sort(temp);
          int start = 0;
          for (long i : temp) arr[start++] = i;
          return arr;
      }
  
  }
  