description: Casimir has a rectangular piece of paper with a checkered field of size n × m. Initially, all cells of the field are white.
  
  Let us denote the cell with coordinates i vertically and j horizontally by (i, j). The upper left cell will be referred to as (1, 1) and the lower right cell as (n, m).
  
  Casimir draws ticks of different sizes on the field. A tick of size d (d > 0) with its center in cell (i, j) is drawn as follows: 
  
    1. First, the center cell (i, j) is painted black. 
    2. Then exactly d cells on the top-left diagonally to the center and exactly d cells on the top-right diagonally to the center are also painted black. 
    3. That is all the cells with coordinates (i - h, j ± h) for all h between 0 and d are painted. In particular, a tick consists of 2d + 1 black cells. 
  
  
  
  An already painted cell will remain black if painted again. Below you can find an example of the 4 × 9 box, with two ticks of sizes 2 and 3.
  
  <image>
  
  You are given a description of a checkered field of size n × m. Casimir claims that this field came about after he drew some (possibly 0) ticks on it. The ticks could be of different sizes, but the size of each tick is at least k (that is, d ≥ k for all the ticks).
  
  Determine whether this field can indeed be obtained by drawing some (possibly none) ticks of sizes d ≥ k or not.
  
  Input
  
  The first line contains an integer t (1 ≤ t ≤ 100) — the number test cases.
  
  The following lines contain the descriptions of the test cases. 
  
  The first line of the test case description contains the integers n, m, and k (1 ≤ k ≤ n ≤ 10; 1 ≤ m ≤ 19) — the field size and the minimum size of the ticks that Casimir drew. The following n lines describe the field: each line consists of m characters either being '.' if the corresponding cell is not yet painted or '*' otherwise.
  
  Output
  
  Print t lines, each line containing the answer to the corresponding test case. The answer to a test case should be YES if the given field can be obtained by drawing ticks of at least the given size and NO otherwise.
  
  You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes, and YES will all be recognized as positive answers).
  
  Example
  
  Input
  
  
  8
  2 3 1
  *.*
  ...
  4 9 2
  *.*.*...*
  .*.*...*.
  ..*.*.*..
  .....*...
  4 4 1
  *.*.
  ****
  .**.
  ....
  5 5 1
  .....
  *...*
  .*.*.
  ..*.*
  ...*.
  5 5 2
  .....
  *...*
  .*.*.
  ..*.*
  ...*.
  4 7 1
  *.....*
  .....*.
  ..*.*..
  ...*...
  3 3 1
  ***
  ***
  ***
  3 5 1
  *...*
  .***.
  .**..
  
  
  Output
  
  
  NO
  YES
  YES
  YES
  NO
  NO
  NO
  NO
  
  Note
  
  The first sample test case consists of two asterisks neither of which can be independent ticks since ticks of size 0 don't exist.
  
  The second sample test case is already described in the statement (check the picture in the statement). This field can be obtained by drawing ticks of sizes 2 and 3, as shown in the figure.
  
  The field in the third sample test case corresponds to three ticks of size 1. Their center cells are marked with \color{blue}{blue}, \color{red}{red} and \color{green}{green} colors: *.*.  
  ---  
  *\color{blue}{*}**  
  .\color{green}{*}\color{red}{*}.  
  ....  
    
  The field in the fourth sample test case could have been obtained by drawing two ticks of sizes 1 and 2. Their vertices are marked below with \color{blue}{blue} and \color{red}{red} colors respectively: .....  
  ---  
  *...*  
  .*.*.  
  ..\color{red}{*}.*  
  ...\color{blue}{*}.  
    
  The field in the fifth sample test case can not be obtained because k = 2, and the last asterisk in the fourth row from the top with coordinates (4, 5) can only be a part of a tick of size 1.
  
  The field in the sixth sample test case can not be obtained because the top left asterisk (1, 1) can't be an independent tick, since the sizes of the ticks must be positive, and cannot be part of a tick with the center cell in the last row, since it is separated from it by a gap (a point, '.') in (2, 2).
  
  In the seventh sample test case, similarly, the field can not be obtained by the described process because the asterisks with coordinates (1, 2) (second cell in the first row), (3, 1) and (3, 3) (leftmost and rightmost cells in the bottom) can not be parts of any ticks.
solution: import static java.lang.Math.max;
  import static java.lang.Math.min;
  import static java.lang.Math.abs;
  import static java.lang.System.out;
  import java.util.*;
  import java.io.*;
  import java.math.*;
  /*
  -> Give your 100%, that's it!
  -> Rules To Solve Any Problem:
      1. Read the problem.
      2. Think About It.
      3. Solve it!
  */
  
  public class Template {
      
  	static int mod = 1000000007;
  
  	public static void main(String[] args){
          FastScanner sc = new FastScanner();
          PrintWriter out = new PrintWriter(System.out);
          int yo = sc.nextInt();
          while (yo-- > 0) {
              int n = sc.nextInt();
              int m = sc.nextInt();
              int k = sc.nextInt();
              
              int[][] dp = new int[n][m];
              
              int[][] arr = new int[n][m];
              
              for(int i = 0; i < n; i++){
                  String s = sc.next();
                  for(int j = 0; j < m; j++){
                      arr[i][j] = s.charAt(j) == '*' ? 1 : 0;
                  }
              }
              
              for(int i = 0; i < n; i++){
                  for(int j = 0; j < m; j++){
                      if(arr[i][j] == 1){
                          dfs(i,j,n,m,dp,arr);    
                      }
                  }
              }
              
              boolean ok = true;
              for(int i = 0; i < n; i++){
                  for(int j = 0; j < m; j++){
                      if(arr[i][j] == 1 && dp[i][j] < k){
                          ok = false;
                      }
                  }
              }
              if(ok){
                  out.println("YES");
              }
              else {
                  out.println("NO");
              }
          }
          out.close();
  	}
      
      
      static void dfs(int i, int j, int n, int m, int[][] dp, int[][] arr){
          
          int count = 0;
          int lr = i-1;
          int lc = j-1;
          int rr = i-1;
          int rc = j+1;
          
          while(lr >= 0 && lc >= 0 && rr >= 0 && rc >= 0 && rc < m){
              if(arr[lr][lc] == 1 && arr[rr][rc] == 1){
                  count++;
                  lr--;
                  lc--;
                  rr--;
                  rc++;
              }
              else {
                  break;
              }
          }
          
          
          lr = i-1;
          lc = j-1;
          rr = i-1;
          rc = j+1;
          dp[i][j] = Math.max(dp[i][j],count);
          while(lr >= 0 && lc >= 0 && rr >= 0 && rc >= 0 && rc < m){
              if(arr[lr][lc] == 1 && arr[rr][rc] == 1){
                  dp[lr][lc] = Math.max(dp[lr][lc],count);
                  dp[rr][rc] = Math.max(dp[rr][rc],count);
              }
              else {
                  break;
              }
              lr--;
              lc--;
              rr--;
              rc++;
          }
              
      }
     
      
      
      /*
      Source: hu_tao
           Random stuff to try when stuck:
              -if it's 2C then it's dp
              -for combo/probability problems, expand the given form we're interested in
              -make everything the same then build an answer (constructive, make everything 0 then do something)
              -something appears in parts of 2 --> model as graph
              -assume a greedy then try to show why it works
              -find way to simplify into one variable if multiple exist
              -treat it like fmc (note any passing thoughts/algo that could be used so you can revisit them)
              -find lower and upper bounds on answer
              -figure out what ur trying to find and isolate it
              -see what observations you have and come up with more continuations
              -work backwards (in constructive, go from the goal to the start)
              -turn into prefix/suffix sum argument (often works if problem revolves around adjacent array elements)
              -instead of solving for answer, try solving for complement (ex, find n-(min) instead of max)
              -draw something
              -simulate a process
              -dont implement something unless if ur fairly confident its correct
              -after 3 bad submissions move on to next problem if applicable
              -do something instead of nothing and stay organized
              -write stuff down
           Random stuff to check when wa:
              -if code is way too long/cancer then reassess
              -switched N/M
              -int overflow
              -switched variables
              -wrong MOD
              -hardcoded edge case incorrectly
           Random stuff to check when tle:
              -continue instead of break
              -condition in for/while loop bad
           Random stuff to check when rte:
              -switched N/M
              -long to int/int overflow
              -division by 0
              -edge case for empty list/data structure/N=1
        */
  
  	public static class Pair {
  		int x;
  		int y;
  
  		public Pair(int x, int y) {
  			this.x = x;
  			this.y = y;
  		}
  	}
  
  	public static void sort(int[] arr) {
  		ArrayList<Integer> ls = new ArrayList<Integer>();
  		for (int x : arr)
  			ls.add(x);
  		Collections.sort(ls);
  		for (int i = 0; i < arr.length; i++)
  			arr[i] = ls.get(i);
  	}
  
  	public static long gcd(long a, long b) {
  		if (b == 0)
  			return a;
  		return gcd(b, a % b);
  	}
  
  	static boolean[] sieve(int N) {
  		boolean[] sieve = new boolean[N + 1];
  		for (int i = 2; i <= N; i++)
  			sieve[i] = true;
  
  		for (int i = 2; i <= N; i++) {
  			if (sieve[i]) {
  				for (int j = 2 * i; j <= N; j += i) {
  					sieve[j] = false;
  				}
  			}
  		}
  		return sieve;
  	}
  
  	public static long power(long x, long y, long p) {
  		long res = 1L;
  		x = x % p;
  		while (y > 0) {
  			if ((y & 1) == 1)
  				res = (res * x) % p;
  			y >>= 1;
  			x = (x * x) % p;
  		}
  		return res;
  	}
  
  	public static void print(int[] arr, PrintWriter out) {
  		//for debugging only
  		for (int x : arr)
  			out.print(x + " ");
  		out.println();
  	}
  
  	static class FastScanner {
  		private int BS = 1 << 16;
  		private char NC = (char) 0;
  		private byte[] buf = new byte[BS];
  		private int bId = 0, size = 0;
  		private char c = NC;
  		private double cnt = 1;
  		private BufferedInputStream in;
  
  		public FastScanner() {
  			in = new BufferedInputStream(System.in, BS);
  		}
  
  		public FastScanner(String s) {
  			try {
  				in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
  			} catch (Exception e) {
  				in = new BufferedInputStream(System.in, BS);
  			}
  		}
  
  		private char getChar() {
  			while (bId == size) {
  				try {
  					size = in.read(buf);
  				} catch (Exception e) {
  					return NC;
  				}
  				if (size == -1)
  					return NC;
  				bId = 0;
  			}
  			return (char) buf[bId++];
  		}
  
  		public int nextInt() {
  			return (int) nextLong();
  		}
  
  		public int[] readInts(int N) {
  			int[] res = new int[N];
  			for (int i = 0; i < N; i++) {
  				res[i] = (int) nextLong();
  			}
  			return res;
  		}
  
  		public long[] readLongs(int N) {
  			long[] res = new long[N];
  			for (int i = 0; i < N; i++) {
  				res[i] = nextLong();
  			}
  			return res;
  		}
  
  		public long nextLong() {
  			cnt = 1;
  			boolean neg = false;
  			if (c == NC)
  				c = getChar();
  			for (; (c < '0' || c > '9'); c = getChar()) {
  				if (c == '-')
  					neg = true;
  			}
  			long res = 0;
  			for (; c >= '0' && c <= '9'; c = getChar()) {
  				res = (res << 3) + (res << 1) + c - '0';
  				cnt *= 10;
  			}
  			return neg ? -res : res;
  		}
  
  		public double nextDouble() {
  			double cur = nextLong();
  			return c != '.' ? cur : cur + nextLong() / cnt;
  		}
  
  		public double[] readDoubles(int N) {
  			double[] res = new double[N];
  			for (int i = 0; i < N; i++) {
  				res[i] = nextDouble();
  			}
  			return res;
  		}
  
  		public String next() {
  			StringBuilder res = new StringBuilder();
  			while (c <= 32)
  				c = getChar();
  			while (c > 32) {
  				res.append(c);
  				c = getChar();
  			}
  			return res.toString();
  		}
  
  		public String nextLine() {
  			StringBuilder res = new StringBuilder();
  			while (c <= 32)
  				c = getChar();
  			while (c != '\n') {
  				res.append(c);
  				c = getChar();
  			}
  			return res.toString();
  		}
  
  		public boolean hasNext() {
  			if (c > 32)
  				return true;
  			while (true) {
  				c = getChar();
  				if (c == NC)
  					return false;
  				else if (c > 32)
  					return true;
  			}
  		}
  	}
  
  	//	For Input.txt and Output.txt	
  	//	FileInputStream in = new FileInputStream("input.txt");
  	//	FileOutputStream out = new FileOutputStream("output.txt");
  	//	PrintWriter pw = new PrintWriter(out);
  	//	Scanner sc = new Scanner(in);
  }