description: There is a grid, consisting of n rows and m columns. Each cell of the grid is either free or blocked. One of the free cells contains a lab. All the cells beyond the borders of the grid are also blocked.
  
  A crazy robot has escaped from this lab. It is currently in some free cell of the grid. You can send one of the following commands to the robot: "move right", "move down", "move left" or "move up". Each command means moving to a neighbouring cell in the corresponding direction.
  
  However, as the robot is crazy, it will do anything except following the command. Upon receiving a command, it will choose a direction such that it differs from the one in command and the cell in that direction is not blocked. If there is such a direction, then it will move to a neighbouring cell in that direction. Otherwise, it will do nothing.
  
  We want to get the robot to the lab to get it fixed. For each free cell, determine if the robot can be forced to reach the lab starting in this cell. That is, after each step of the robot a command can be sent to a robot such that no matter what different directions the robot chooses, it will end up in a lab.
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of testcases.
  
  The first line of each testcase contains two integers n and m (1 ≤ n, m ≤ 10^6; n ⋅ m ≤ 10^6) — the number of rows and the number of columns in the grid.
  
  The i-th of the next n lines provides a description of the i-th row of the grid. It consists of m elements of one of three types: 
  
    * '.' — the cell is free; 
    * '#' — the cell is blocked; 
    * 'L' — the cell contains a lab. 
  
  
  
  The grid contains exactly one lab. The sum of n ⋅ m over all testcases doesn't exceed 10^6.
  
  Output
  
  For each testcase find the free cells that the robot can be forced to reach the lab from. Given the grid, replace the free cells (marked with a dot) with a plus sign ('+') for the cells that the robot can be forced to reach the lab from. Print the resulting grid.
  
  Example
  
  Input
  
  
  4
  3 3
  ...
  .L.
  ...
  4 5
  #....
  ..##L
  ...#.
  .....
  1 1
  L
  1 9
  ....L..#.
  
  
  Output
  
  
  ...
  .L.
  ...
  #++++
  ..##L
  ...#+
  ...++
  L
  ++++L++#.
  
  Note
  
  In the first testcase there is no free cell that the robot can be forced to reach the lab from. Consider a corner cell. Given any direction, it will move to a neighbouring border grid that's not a corner. Now consider a non-corner free cell. No matter what direction you send to the robot, it can choose a different direction such that it ends up in a corner.
  
  In the last testcase, you can keep sending the command that is opposite to the direction to the lab and the robot will have no choice other than move towards the lab.
solution:     import java.beans.DesignMode;
      import java.io.BufferedReader;
      import java.io.FileInputStream;
      import java.io.FileNotFoundException;
      import java.io.IOException;
      import java.io.InputStreamReader;
      import java.util.*;
      import java.util.concurrent.LinkedBlockingDeque;
      import java.util.concurrent.CompletableFuture.AsynchronousCompletionTask;
  
      import org.xml.sax.ErrorHandler;
  
      import java.io.PrintStream;
      import java.io.PrintWriter;
      import java.io.DataInputStream;
  
          public class Solution {
              //TEMPLATE -------------------------------------------------------------------------------------
              public static boolean Local(){
                  try{ 
                      return System.getenv("LOCAL_SYS")!=null;
                  }catch(Exception e){
                      return false;
                  }
              }   
  
              public static boolean LOCAL;
  
              static class FastScanner {
  
                      BufferedReader br;
                      StringTokenizer st ;
  
                      FastScanner(){
                          br =  new BufferedReader(new InputStreamReader(System.in));
                          st = new StringTokenizer("");
                      }
  
                      FastScanner(String file) {
  
                          try{
                              br =  new BufferedReader(new InputStreamReader(new FileInputStream(file)));
                              st = new StringTokenizer("");
                          }catch(FileNotFoundException e) {
                              // TODO Auto-generated catch block
                              System.out.println("file not found");
                              e.printStackTrace();
                          }
                          
                      }
                      String next() {
                          while (!st.hasMoreTokens())
                              try {
                                  st = new StringTokenizer(br.readLine());
                              } catch (IOException e) {
                              }
                          return st.nextToken();
                      }
  
                      int nextInt() {
                          return Integer.parseInt(next());
                      }
  
                      long nextLong() {
                          return Long.parseLong(next());
                      }
  
                      double nextDouble(){
                          return Double.parseDouble(next());
                      }
  
                      String readLine() throws IOException{
                          return br.readLine();
                      }
                  }
                                      
              static class Pair<T,X> {
  
                  T first;
                  X second;
                  
                  Pair(T first,X second){
                      this.first = first;
                      this.second = second;
                  }
  
                  @Override
                  public int hashCode(){
                      return Objects.hash(first,second);
                  }
  
                  @Override
                  public boolean equals(Object obj){
                      return obj.hashCode() == this.hashCode();
                  }
  
              }
  
          
          static PrintStream debug = null;      
          static long mod = (long)(Math.pow(10,9) + 7); 
      //TEMPLATE -------------------------------------------------------------------------------------END//
          public static void main(String[] args) throws Exception {
              
              FastScanner s = new FastScanner();
              LOCAL = Local();
              //PrintWriter pw = new PrintWriter(System.out);
              if(LOCAL){
                  s = new FastScanner("src/input.txt");
                  PrintStream o = new PrintStream("src/sampleout.txt");
                  debug = new PrintStream("src/debug.txt");
                  System.setOut(o);
              //  pw = new PrintWriter(o);
              } long mod = 1000000007;
  
          
              int tcr = s.nextInt();                  
              
  
              StringBuilder sb = new StringBuilder();
  
              
              for(int tc=0;tc<tcr;tc++){
                  int n = s.nextInt();
                  int m = s.nextInt();
                  char arr[][] = new char[n][m];
                  int r = 0;
                  int c = 0;
                  int dx[] = {0,0,-1,1};
                  int dy[] = {-1,1,0,0};
                  int op[] = {1,0,3,2};
                  for(int i=0;i<n;i++){
                      arr[i] = s.next().toCharArray();
                      for(int j=0;j<m;j++){
                          if(arr[i][j] == 'L'){
                              r = i;
                              c = j;
                          }
                      }
                  }
                  Queue<int[]> q = new LinkedList<>();
                  q.add(new int[]{r,c,-1});
                  boolean poss[][] = new boolean[n][m];
                  boolean vis[][]  = new boolean[n][m];
                  vis[r][c] = true;
                  poss[r][c] = true;
                  // q.add(null);
                  while(!q.isEmpty()){
                      dbg(debug,q);
  
                      int curr[] = q.poll();
                      // if(curr == null){
                      //     dbg(debug,q);
                      //     vis = poss;
                      //     if(q.size() > 0){
                      //         q.add(null);
                      //     }
                      //     continue;
                      // }
  
                      if(curr[2] != -1){
                          
                          int can_go = 0;
  
                      
                          for(int i=0;i<4;i++){
                              int nr = curr[0] + dx[i];
                              int nc = curr[1] + dy[i];
                              if((nr >= 0) && (nr < n) && (nc >= 0) && (nc < m) && (arr[nr][nc] == '.')){
                                  if(!poss[nr][nc]){
                                      can_go++;
                                  }
                              }
                              
                          }
  
                          // if(curr[0]==1 && curr[1] == 0){
                          //     println(can_go);
                          // }
  
                          if(can_go <= 1){
                              poss[curr[0]][curr[1]] = true;
                              
                          }
                      }
  
                      if((!poss[curr[0]][curr[1]])){
                          continue;
                      }
  
                      for(int i=0;i<4;i++){
                          int nr = curr[0] + dx[i];
                          int nc = curr[1] + dy[i];
                          if((nr >= 0) && (nr < n) && (nc >= 0) && (nc < m) && (arr[nr][nc] == '.') && (!poss[nr][nc])){
                              vis[nr][nc] = true;
                              //dbg(debug,nr+" "+nc+" added by ->"+curr[0]+","+curr[1]);
                              q.add(new int[]{nr,nc,i}); 
                          }
                      }
                  }
  
                  for(int i=0;i<n;i++){
                      for(int j=0;j<m;j++){
                          if(arr[i][j] == '.' && (poss[i][j])){
                              sb.append('+');
                          }else{
                              sb.append(arr[i][j]);
                          }
                      }
                      sb.append('\n');
                  }
  
              }
              print(sb.toString());
          }
  
  
          public static int check(int arr[],int k){
              
              int n = arr.length;
  
              if(k > (n/2)){
                  return arr[n/2];
              }
  
              int st = k-1;
              int e = n - k;
  
              for(int i=st+1;i<=e;i++){
                  if(arr[i] != arr[i-1]){return -1;}
              }
              return arr[st];
  
          }
  
  
          public static List<int[]> print_prime_factors(int n){
          
              List<int[]> list = new ArrayList<>();
              
              for(int i=2;i<=(int)(Math.sqrt(n));i++){
  
                  if(n % i == 0){
                      
                      int cnt = 0;
                      
                      while( (n % i) == 0){
                          n = n/i;
                          cnt++;
                      }
  
                      list.add(new int[]{i,cnt});
                  }
              }
  
              if(n!=1){
                  list.add(new int[]{n,1});
              }
  
              return list;
          }
  
          public static List<int[]> prime_factors(int n,List<Integer> sieve){
              List<int[]> list = new ArrayList<>();
              int index = 0;
              while(n > 1 && sieve.get(index) <= Math.sqrt(n)){
                  int curr = sieve.get(index);
                  int cnt = 0;
                  while((n % curr) == 0){
                      n = n/curr;
                      cnt++;
                  }
                  if(cnt >= 1){
                      list.add(new int[]{curr,cnt});
                  }
                  index++;
              }
              if(n > 1){
                  list.add(new int[]{n,1});
              }
              return list;
          }
  
          public static boolean inRange(int r1,int r2,int val){
              return ((val >= r1) && (val <= r2));
          }
  
          static int len(long num){
              return Long.toString(num).length();
          }
  
          static long mulmod(long a, long b,long mod)
          {
              long ans = 0l;
              
              while(b > 0){
                  long curr = (b & 1l);
                  if(curr == 1l){
                      ans = ((ans % mod) + a) % mod;
                  }
                  
                  a = (a + a) % mod;
  
                  b = b >> 1;
              }
  
              return ans;
          }
  
  
          public static void dbg(PrintStream ps,Object... o) throws Exception{
              if(ps == null){
                  return;
              }
              Debug.dbg(ps,o);
          }
  
          public static long modpow(long num,long pow,long mod){
  
              long val = num;
              long ans = 1l;
  
              while(pow > 0l){
                  
                  long bit = pow & 1l;
  
                  if(bit == 1){
                      ans = (ans * (val%mod))%mod;
                  }
  
                  val = (val * val) % mod;
                  pow = pow >> 1;
              }
  
              return ans;
  
          }
  
          public static char get(int n){
              return (char)('a' + n);
          }
  
          public static long[] sort(long arr[]){
              List<Long> list = new ArrayList<>();
              for(long n : arr){list.add(n);}
              Collections.sort(list);
              for(int i=0;i<arr.length;i++){
                  arr[i] = list.get(i);
              }
              return arr;
          }
  
          public static int[] sort(int arr[]){
              List<Integer> list = new ArrayList<>();
              for(int n : arr){list.add(n);}
              Collections.sort(list);
              for(int i=0;i<arr.length;i++){
                  arr[i] = list.get(i);
              }
              return arr;
          }
  
          // return the (index + 1)
          // where index is the pos of just smaller element
          // i.e count of elemets strictly less than num
          public static int justSmaller(long arr[],long num){
              //  System.out.println(num+"@");
              int st = 0;
              int e = arr.length - 1;
  
              int ans = -1;
  
              while(st <= e){
  
                  int mid = (st + e)/2;
  
                  if(arr[mid] >= num){
                      e = mid - 1;
                  }else{
                      ans = mid;
                      st = mid + 1;
                  }
  
              }
  
  
              return ans + 1;
  
          }
          public static int justSmaller(int arr[],int num){
              //  System.out.println(num+"@");
              int st = 0;
              int e = arr.length - 1;
  
              int ans = -1;
  
              while(st <= e){
  
                  int mid = (st + e)/2;
  
                  if(arr[mid] >= num){
                      e = mid - 1;
                  }else{
                      ans = mid;
                      st = mid + 1;
                  }
  
              }
  
  
              return ans + 1;
  
          }
          
          //return (index of just greater element)
          //count of elements smaller than or equal to num
  
          public static int justGreater(long arr[],long num){
              int st = 0;
              int e = arr.length - 1;
  
              int ans = arr.length;
  
              while(st <= e){
                  
                  int mid = (st + e)/2;
  
                  if(arr[mid] <= num){
                      st = mid + 1;
                  }else{
                      ans = mid;
                      e = mid - 1;
                  }
              }
  
              return ans;
  
          }
  
          public static int justGreater(int arr[],int num){
              int st = 0;
              int e = arr.length - 1;
  
              int ans = arr.length;
  
              while(st <= e){
                  
                  int mid = (st + e)/2;
  
                  if(arr[mid] <= num){
                      st = mid + 1;
                  }else{
                      ans = mid;
                      e = mid - 1;
                  }
              }
  
              return ans;
  
          }
  
          
  
          public static void println(Object obj){
              System.out.println(obj.toString());
          }
  
          public static void print(Object obj){
              System.out.print(obj.toString());
          }
  
          public static int gcd(int a,int b){
              if(b == 0){return a;}
              return gcd(b,a%b);
          }
  
          public static long gcd(long a,long b){
              if(b == 0l){
                  return a;
              }
  
              return gcd(b,a%b);
          }
  
          public static int find(int parent[],int v){
              if(parent[v] == v){
                  return v;
              }
              
              return parent[v] = find(parent, parent[v]);
          }
  
  
  
          public static List<Integer> sieve(){
          
                  List<Integer> prime = new ArrayList<>();
  
                  int arr[] = new int[1000001];
  
              Arrays.fill(arr,1);
  
              arr[1] = 0;
              arr[2] = 1;
  
              for(int i=2;i<1000001;i++){
                  
                  if(arr[i] == 1){
                      
                      prime.add(i);
  
                      for(long j = (i*1l*i);j<1000001;j+=i){
                          arr[(int)j] = 0;
                      }
                  }
              }
  
              return prime;
          }
  
          static boolean isPower(long n,long a){
              
              long log = (long)(Math.log(n)/Math.log(a));
  
              long power = (long)Math.pow(a,log);
  
              if(power == n){return true;}
  
              return false;
          }
  
  
          private static int mergeAndCount(int[] arr, int l,int m, int r)
          {
              // Left subarray
              int[] left =  Arrays.copyOfRange(arr, l, m + 1);
  
              // Right subarray
              int[] right = Arrays.copyOfRange(arr, m + 1, r + 1);
  
              int i = 0, j = 0, k = l, swaps = 0;
  
              while (i < left.length && j < right.length) {
                  if (left[i] <= right[j])
                      arr[k++] = left[i++];
                  else {
                      arr[k++] = right[j++];
                      swaps += (m + 1) - (l + i);
                  }
              }
              while (i < left.length)
                  arr[k++] = left[i++];
              while (j < right.length)
                  arr[k++] = right[j++];
              return swaps;
          }
  
          // Merge sort function
          private static int mergeSortAndCount(int[] arr, int l,int r)
          {
  
              // Keeps track of the inversion count at a
              // particular node of the recursion tree
              int count = 0;
  
              if (l < r) {
                  int m = (l + r) / 2;
  
                  // Total inversion count = left subarray count
                  // + right subarray count + merge count
  
                  // Left subarray count
                  count += mergeSortAndCount(arr, l, m);
  
                  // Right subarray count
                  count += mergeSortAndCount(arr, m + 1, r);
  
                  // Merge count
                  count += mergeAndCount(arr, l, m, r);
              }
  
              return count;
          }
  
          static class Debug{
              //change to System.getProperty("ONLINE_JUDGE")==null; for CodeForces
              public static final boolean LOCAL = System.getProperty("ONLINE_JUDGE")==null;
  
              
  
              private static <T> String ts(T t) {
                  if(t==null) {
                      return "null";
                  }
                  try {
                      return ts((Iterable) t);
                  }catch(ClassCastException e) {
                      if(t instanceof int[]) {
                          String s = Arrays.toString((int[]) t);
                          return "{"+s.substring(1, s.length()-1)+"}\n";
                      }else if(t instanceof long[]) {
                          String s = Arrays.toString((long[]) t);
                          return "{"+s.substring(1, s.length()-1)+"}\n";
                      }else if(t instanceof char[]) {
                          String s = Arrays.toString((char[]) t);
                          return "{"+s.substring(1, s.length()-1)+"}\n";
                      }else if(t instanceof double[]) {
                          String s = Arrays.toString((double[]) t);
                          return "{"+s.substring(1, s.length()-1)+"}\n";
                      }else if(t instanceof boolean[]) {
                          String s = Arrays.toString((boolean[]) t);
                          return "{"+s.substring(1, s.length()-1)+"}\n";
                      }
                      try {
                          return ts((Object[]) t);
                      }catch(ClassCastException e1) {
                          return t.toString();
                      }
                  }
              }
              private static <T> String ts(T[] arr) {
                  StringBuilder ret = new StringBuilder();
                  ret.append("{");
                  boolean first = true;
                  for(T t: arr) {
                      if(!first) {
                          ret.append(", ");
                      }
                      first = false;
                      ret.append(ts(t));
                  }
                  ret.append("}");
                  return ret.toString();
              }
              private static <T> String ts(Iterable<T> iter) {
                  StringBuilder ret = new StringBuilder();
                  ret.append("{");
                  boolean first = true;
                  for(T t: iter) {
                      if(!first) {
                          ret.append(", ");
                      }
                      first = false;
                      ret.append(ts(t));
                  }
                  ret.append("}\n");
                  return ret.toString();
              }
              public static void dbg(PrintStream ps,Object... o) throws Exception {
                  if(LOCAL) {
                      System.setErr(ps);
                      System.err.print("Line #"+Thread.currentThread().getStackTrace()[2].getLineNumber()+": [\n");
                      for(int i = 0; i<o.length; i++) {
                          if(i!=0) {
                              System.err.print(", ");
                          }
                          System.err.print(ts(o[i]));
                      }
                      System.err.println("]");
                  }
              }
          }
  
      }