Long is a huge fan of CFC (Codeforces Fried Chicken). But the price of CFC is increasing, so he decides to breed the chicken on his own farm.

His farm is presented by a rectangle grid with r rows and c columns. Some of these cells contain rice, others are empty. k chickens are living on his farm. The number of chickens is not greater than the number of cells with rice on the farm.

Long wants to give his chicken playgrounds by assigning these farm cells to his chickens. He would like to satisfy the following requirements:

  * Each cell of the farm is assigned to exactly one chicken. 
  * Each chicken is assigned at least one cell. 
  * The set of cells assigned to every chicken forms a connected area. More precisely, if two cells (x, y) and (u, v) are assigned to the same chicken, this chicken is able to walk from (x, y) to (u, v) by passing only its cells and moving from each cell to another cell sharing a side. 



Long also wants to prevent his chickens from fighting for food. Hence he wants the difference between the maximum and the minimum number of cells with rice assigned to a chicken to be as small as possible. Please help him.

Input

Each test contains multiple test cases. The first line contains the number of test cases T (1 ≤ T ≤ 2 ⋅ 10^4). Description of the test cases follows.

The first line of each test case contains three integers r, c and k (1 ≤ r, c ≤ 100, 1 ≤ k ≤ 62), representing the size of Long's farm and the number of chickens Long has. 

Each of the next r lines contains c characters, each is either "." or "R", representing an empty cell or a cell with rice. It is guaranteed that the number of chickens is not greater than the number of cells with rice on the farm.

It is guaranteed that the sum of r ⋅ c over all test cases does not exceed 2 ⋅ 10^4.

Output

For each test case, print r lines with c characters on each line. Each character should be either a lowercase English character, an uppercase English character, or a digit. Two characters should be equal if and only if the two corresponding cells are assigned to the same chicken. Uppercase and lowercase characters are considered different, so "A" and "a" belong to two different chickens.

If there are multiple optimal answers, print any.

Example

Input


4
3 5 3
..R..
...R.
....R
6 4 6
R..R
R..R
RRRR
RRRR
R..R
R..R
5 5 4
RRR..
R.R..
RRR..
R..R.
R...R
2 31 62
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR


Output


11122
22223
33333
aacc
aBBc
aBBc
CbbA
CbbA
CCAA
11114
22244
32444
33344
33334
abcdefghijklmnopqrstuvwxyzABCDE
FGHIJKLMNOPQRSTUVWXYZ0123456789

Note

These pictures explain the sample output. Each color represents one chicken. Cells filled with patterns (not solid colors) contain rice.

In the first test case, each chicken has one cell with rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 0.

<image>

In the second test case, there are 4 chickens with 3 cells of rice, and 2 chickens with 2 cells of rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 3 - 2 = 1.

<image>

In the third test case, each chicken has 3 cells with rice. <image>

In the last test case, since there are 62 chicken with exactly 62 cells of rice, each chicken must be assigned to exactly one cell. The sample output is one of the possible way.
import java.util.*;
import java.io.*;
import java.io.FileWriter; 

// Solution

public class Main 
{    
  public static void main (String[] argv) 
  {
	  new Main();
  } 
     
  
  boolean test = false;  
  
  final int MOD = 998244353;  //1000000007;  
  
  
  final int S = 100000;
  final int N = 200001;
  
  //final int S = 0;
  //final int N = 32;
  int[] tree = new int[4*N];
  int[] lazy = new int[4*N];
  final int INF = Integer.MAX_VALUE;
  int[][] ts;
  int r = 0, c = 0, dir = 0;
  int n = 0, m = 0;
  char[][] a;
  
  public Main()   {
	FastReader in = new FastReader(new BufferedReader(new InputStreamReader(System.in)));
	
     
   // FastReader in = new FastReader(new BufferedReader(new FileReader("Main.in")));   
    
    int nt = in.nextInt();    
    //int nt = 1;
    StringBuilder sb = new StringBuilder();
    
    
    for (int it = 0; it < nt; it++) 
    {
       n = in.nextInt();
       
       m = in.nextInt();
       int k = in.nextInt();
       a = new char[n][m];
       int cnt=0, len=0, nlo=0, nhi=0;
       for (int i = 0; i < n; i++)
       {
           String line = in.next();
           for (int j = 0; j < m; j++) {
               a[i][j] = line.charAt(j);
               if (a[i][j] == 'R')
                   cnt++;
           }
       }
       
       len = cnt / k;
       nlo = cnt % k;
       nhi = k - nlo;
       
       int curChick = 1;       
       int req = len;
       char lastMark = '0';
       r = 0;
       c = 0;
       dir = 0;
       
//System.out.println(cnt + " " + len + " " + nlo + " " + n + " " + m + " " + k);
       for (; curChick <= k; curChick++)
       {
           if (curChick <= nlo) {
               req = len + 1;
           }else 
               req = len;
//System.out.println(curChick + " req = " + req);
           char mark = getMark(curChick-1);
           lastMark = mark;
           
           while (req > 0)
           {
               req -= paint(mark);               
           }
       }
       
       for (int i = 0; i < n; i++) {
           for(int j = 0; j < m; j++)
           {
               if (a[i][j] == '.') a[i][j] = lastMark;
               
               sb.append(a[i][j]);
           }
           sb.append("\n");
       }
       
       //sb.append("\n");
    }
    System.out.print(sb);
  }
  
  private char getMark(int i) {
      if (i <= 9) return (char)(i + '0');
      i -= 10;
      
      if (i < 26) return (char)(i + 'a');
      
      i -= 26;
      return (char)(i + 'A');
  }
  
  private int paint(char mark)
  {
      int cnt = 0;
      if (a[r][c] == 'R')
          cnt = 1;
      a[r][c] = mark;
      if (dir == 0) {
          c++;
          if (c == m) {
              r++;
              c = m - 1;
              dir = 1;
          }          
      }else {
          c--;
          if (c < 0){
              c = 0;
              r++;
              dir = 0;
          }
      }
                 
      return cnt;
               
  }
  private int f(int fr, int to)
  {
      if (fr == to) return 0;
      
      if (fr > to) return f(to, fr);
      
      int d = to - fr;
      int c = d / 5;
      d = d % 5;
      if (d == 1 || d == 2) return c + 1;
      if (d == 4 || d == 3) return c + 2;
      return c;      
  }
  
  private void rangeUpdate(int node, int lo, int hi, int fr, int to, int val)
  {
      pushDown(node, lo, hi);
      
      if (lo == fr && hi == to)
      {
          lazy[node] = val;
          tree[node] = val;
          return;
      }
      
      int mid = (lo + hi) / 2;
      
      if (to <= mid) {
          rangeUpdate(node * 2, lo, mid, fr, to, val);
      }else if (fr > mid) {
          rangeUpdate(node * 2 + 1, mid + 1, hi, fr, to, val);
      }else {
          rangeUpdate(node * 2, lo, mid, fr, mid, val);
          rangeUpdate(node * 2 + 1, mid + 1, hi, mid + 1, to, val);
      }
      
      //combine
      combine(node, lo, hi);
  }
  
  private int query(int node, int lo, int hi, int fr, int to)
  {   
     if (lazy[node] != -1)
          return tree[node];
      
     if (lo == fr && hi == to) {
          //System.out.println("found " + tree[node]);
          return tree[node];
      }
      
      int mid = (lo + hi) / 2;
      
      if (to <= mid) return query(node * 2, lo, mid, fr, to);
      if (mid < fr) return query(node * 2 + 1, mid + 1, hi, fr, to);
      
      return Math.min(query(node * 2, lo, mid, fr, mid),
                      query(node * 2 + 1, mid + 1, hi, mid + 1, to)); 
      
  }
  
  private void pushDown(int node, int lo, int hi)
  {
      if (lo >= hi || lazy[node] == -1) return;
      
      lazy[node * 2] = lazy[node];
      lazy[node * 2 + 1] = lazy[node];
      tree[node * 2] = lazy[node];
      tree[node * 2 + 1] = lazy[node];
      
      /* clear lazy of node */
      lazy[node] = -1;
  }
  
  private void combine(int node, int lo, int hi)
  {
      if (lo >= hi) return;
      
      tree[node] = Math.min(tree[node * 2], tree[node * 2 + 1]);
  }
  
  
  private int inv(int v)
  {
      return pow(v, MOD-2);
  }
  
  private int pow(long v, int p)
  {
      long ans = 1;
      while (p > 0)
      {
          if (p % 2 == 1)
              ans = ans * v % MOD;
          v = v * v % MOD;
          p = p / 2;
      }
      return (int)ans;
  }
  
  private double dist(double x, double y, double xx, double yy)
  {
      return Math.sqrt((xx - x) * (xx - x) + (yy - y) * (yy - y));
  }
  

  
 
  private int mod_add(int a, int b) {
      int v = a + b;
      if (v >= MOD) v -= MOD;
      return v;
  }
  
  
  private long overlap(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4) {
      if (x1 > x3) return overlap(x3, y3, x4, y4, x1, y1, x2, y2);
      
      if (x3 > x2 || y4 < y1 || y3 > y2) return 0L;
      
      //(x3, ?, x2, ?)
      int yL = Math.max(y1, y3);
      int yH = Math.min(y2, y4); 
      int xH = Math.min(x2, x4);
      
      return f(x3, yL, xH, yH);
  }
  //return #black cells in rectangle
  private long f(int x1, int y1, int x2, int y2) {
      long dx = 1L + x2 - x1;
      long dy = 1L + y2 - y1;
      if (dx % 2 == 0 || dy % 2 == 0 || (x1 + y1) % 2 == 0) 
          return 1L * dx * dy / 2;
      return 1L * dx * dy / 2 + 1;
  }
  
  private int distM(int x, int y, int xx, int yy) {
      return abs(x - xx) + abs(y - yy);
  }
  
  private boolean less(int x, int y, int xx, int yy) {
      return x < xx || y > yy;
  }
  
  private int mul(int x, int y) {
      return (int)(1L * x * y % MOD);
  }
  
  
 
  
  private int nBit1(int v) {
      int v0 = v;
      int c = 0;
      while (v != 0) {
          ++c;
          v = v & (v - 1);
      }
      return c;
  }
  
  private long abs(long v) {
      return v > 0 ? v : -v;
  }
  
  private int abs(int v) {
      return v > 0 ? v : -v;
  }
  
  private int common(int v) {
      int c = 0;
      while (v != 1) {
          v = (v >>> 1);
          ++c;
      }
      
      return c;
  }
  
  private void reverse(char[] a, int i, int j) {
      while (i < j) {
          swap(a, i++, j--);
      }
  }
  
  private void swap(char[] a, int i, int j) {
      char t = a[i];
      a[i] = a[j];
      a[j] = t;
  }
  
  private int gcd(int x, int y) {
      if (y == 0) return x;
      return gcd(y, x % y);
  }
  private long gcd(long x, long y) {
      if (y == 0) return x;
      return gcd(y, x % y);
  }
  private int max(int a, int b) {
      return a >  b ? a : b;
  }
  
  private long max(long a, long b) {
      return a >  b ? a : b;
  }
  
  private int min(int a, int b) {
      return a >  b ? b : a;
  }
  
  private long min(long a, long b) {
      return a >  b ? b : a;
  }
  
  static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;
 
        public FastReader(BufferedReader in)
        {            
            br = in;
        }
 
        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    String line = br.readLine();
                    if (line == null || line.length() == 0) return "";
                    st = new StringTokenizer(line);
                }
                catch (IOException  e)
                {
                    return "";
                    //e.printStackTrace();
                }
            }
            return st.nextToken();
        }
 
        int nextInt()
        {
            return Integer.parseInt(next());
        }
 
        long nextLong()
        {
            return Long.parseLong(next());
        }
 
        double nextDouble()
        {
            return Double.parseDouble(next());
        }
 
        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                return null;
                //e.printStackTrace();
            }
            return str;
        }
    }
}