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: # pylint: disable=unused-variable
  # pylint: enable=too-many-lines
  # * Just believe in yourself
   
   
  # $ Author @CAP
  # import numpy
  import os
  import sys
  from io import BytesIO, IOBase
  import math as M
  import itertools as ITR
  from collections import defaultdict as D
  from collections import Counter as C
  from collections import deque as Q
  import threading
  from functools import cmp_to_key, lru_cache, reduce
  from functools import cmp_to_key as CMP
  from bisect import bisect, bisect_left as BL
  from bisect import bisect_right as BR
  import random as R
  import string
  import cmath, time
  from heapq import heapify, heappop as HPOP
  from heapq import heappush as HPUSH
  import heapq as H
   
  enum = enumerate
  start_time = time.time()
   
  # * Variables
   
  MOD = 1_00_00_00_007
  MA = float("inf")
  MI = float("-inf")
   
  # * Graph 8 direction
  d8i = (-1, -1, 0, 1, 1, 1, 0, -1); d8j = (0, 1, 1, 1, 0, -1, -1, -1)
   
  # * Graph 4 direction
  d4i = (-1, 0, 1, 0); d4j=(0, 1, 0, -1)
   
  # * Stack increment
   
   
  def increase_stack():
      sys.setrecursionlimit(2 ** 32 // 2 - 1)
      threading.stack_size(1 << 27)
      # sys.setrecursionlimit(10**6)
      # threading.stack_size(10**8)
      # t = threading.Thread(target=main)
      # t.start()
      # t.join()
   
   
  # * Region Funtions
   
   
  def binary(n):
      return bin(n)[2:]
   
   
  def decimal(s):
      return int(s, 2)
   
   
  def pow2(n):
      p = 0
      while n > 1:
          n //= 2
          p += 1
      return p
   
   
  def maxfactor(n):
      q = []
      for i in range(1, int(n ** 0.5) + 1):
          if n % i == 0:
              q.append(i)
      if q:
          return q[-1]
   
   
  def factors(n):
      q = []
      for i in range(1, int(n ** 0.5) + 1):
          if n % i == 0:
              q.append(i)
              q.append(n // i)
      return list(sorted(list(set(q))))
   
   
  def primeFactors(n):
      l = []
      while n % 2 == 0:
          l.append(2)
          n = n / 2
      for i in range(3, int(M.sqrt(n)) + 1, 2):
          while n % i == 0:
              l.append(i)
              n = n / i
      if n > 2:
          l.append(int(n))
      l.sort()
      return l
   
   
  def isPrime(n):
      if n == 1:
          return False
      else:
          root = int(n ** 0.5)
          root += 1
          for i in range(2, root):
              if n % i == 0:
                  return False
          return True
   
   
  def seive(n):
      a = []
      prime = [True for i in range(n + 1)]
      p = 2
      while p * p <= n:
          if prime[p] == True:
              for i in range(p ** 2, n + 1, p):
                  prime[i] = False
          p = p + 1
      for p in range(2, n + 1):
          if prime[p]:
              a.append(p)
      prime[0] = prime[1] = False
      return a, prime
   
   
  def maxPrimeFactors(n):
      maxPrime = -1
      while n % 2 == 0:
          maxPrime = 2
          n >>= 1
      for i in range(3, int(M.sqrt(n)) + 1, 2):
          while n % i == 0:
              maxPrime = i
              n = n / i
      if n > 2:
          maxPrime = n
      return int(maxPrime)
   
   
  def countchar(s, i):
      c = 0
      ch = s[i]
      for i in range(i, len(s)):
          if s[i] == ch:
              c += 1
          else:
              break
      return c
   
   
  def str_counter(a):
      q = [0] * 26
      for i in range(len(a)):
          q[ord(a[i]) - 97] = q[ord(a[i]) - 97] + 1
      return q
   
   
  def lis(arr):
      n = len(arr)
      lis = [1] * n
      maximum = 0
   
      for i in range(1, n):
          for j in range(0, i):
              if arr[i] > arr[j] and lis[i] < lis[j] + 1:
                  lis[i] = lis[j] + 1
                  maximum = max(maximum, lis[i])
      return maximum
   
   
  def gcd(a, b):
      if b == 0:
          return a
      else:
          return gcd(b, a % b)
   
   
  def agcd(a, *b):
   
      for i in b:
          a = gcd(a, i)
      return a
   
   
  def lcm(a, *b):
      val = a
      gc = a
      for i in b:
          gc = gcd(gc, i)
          val *= i
      return val // gc
   
   
  def ncr(n, r):
      return M.factorial(n) // (M.factorial(n - r) * M.factorial(r))
   
   
  def npr(n, r):
      return M.factorial(n) // M.factorial(n - r)
   
   
  # * Make work easy funtions
   
   
  def IF(c, t, f):
      return t if c else f
   
   
  def YES(c):
      print(IF(c, "YES", "NO"))
   
   
  def Yes(c):
      print(IF(c, "Yes", "No"))
   
   
  def yes(c):
      print(IF(c, "yes", "no"))
   
   
  def JA(a, sep=" "):
      print(sep.join(map(str, a)))
   
   
  def JAA(a, s="\n", t=" "):
      print(s.join(t.join(map(str, b)) for b in a))
   
   
  def PS(a, s=" "):
      print(str(a), end=s)
   
   
  # * Region Taking Input
   
   
  def I():
      return int(inp())
   
   
  def F():
      return float(inp())
   
   
  def LI():
      return list(map(int, inp().split()))
   
   
  def LF():
      return list(map(float, inp().split()))
   
   
  def MATI(n):
      return [LI() for i in range(n)]
   
   
  def MATS(n):
      return [list(inp()) for i in range(n)]
   
   
  def IV():
      return map(int, inp().split())
   
   
  def FV():
      return map(float, inp().split())
   
   
  def LS():
      return list(inp())
   
   
  def S():
      return inp()
   
   
  # * Region Fastio
   
  BUFSIZE = 8192
   
   
  class FastIO(IOBase):
      newlines = 0
   
      def __init__(self, file):
          self._fd = file.fileno()
          self.buffer = BytesIO()
          self.writable = "x" in file.mode or "r" not in file.mode
          self.write = self.buffer.write if self.writable else None
   
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
   
      def readline(self):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              self.newlines = b.count(b"\n") + (not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
   
      def flush(self):
          if self.writable:
              os.write(self._fd, self.buffer.getvalue())
              self.buffer.truncate(0), self.buffer.seek(0)
   
   
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
   
   
  sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  inp = lambda: sys.stdin.readline().rstrip("\r\n")
   
   
  # @==================================== Write The Useful Code Here ============================
   
  # @Make it one if there is some test cases
  TestCases = 1  # @=====================
  # @ =======================================
  def bfs(grid,n,m,que):
      while que:
          x,y=que.popleft()
          count=0
          for i in range(4):
              ni=x+d4i[i]; nj=y+d4j[i]
              if ni<n and nj<m and ni>=0 and nj>=0 and grid[ni][nj]=='.' :
                  count+=1
          if count==1 or count==0:
              grid[x][y]="+"
              for q in range(4):
                  ni=x+d4i[q]; nj=y+d4j[q]
                      
                  if ni<n and nj<m and ni>=0 and nj>=0 and grid[ni][nj]=='.':
                      que.append((ni,nj))
           
  def solve(test_no):
      n,m=IV()
      grid=[]
      for i in range(n):
          q=LS()
          grid.append(q)
      que=Q()
      for i in range(n):
          for j in range(m):
              if grid[i][j]=='L':
                  for q in range(4):
                      ni=i+d4i[q]; nj=j+d4j[q]
                          
                      if ni<n and nj<m and ni>=0 and nj>=0 and grid[ni][nj]=='.':
                          que.append((ni,nj))
                  bfs(grid,n,m,que)
                  break
  
      for i in range(n):
          print("".join(grid[i]))
  # < This is the Main Function
   
   
  def main():
      flag = 1
      #< Checking we are offline or not
      try:
          sys.stdin = open(
              "C:/Users/raavi.manoj/Documents/coding/python/input.txt",
              "r",
          )
          sys.stdout = open(
              "C:/Users/raavi.manoj/Documents/coding/python/output.txt",
              "w",
          )
      except:
          flag = 0
  
      t = 1
      if TestCases:
          t = I()
      for test in range(1, t + 1):
          solve(test)
   
      if flag:
          print("\nTHIS IS A PYTHON OUTPUT FILE")
          print("Time: %.4f seconds" % (time.time() - start_time))
          localtime = time.asctime(time.localtime(time.time()))
          print(localtime)
          sys.stdout.close()
   
   
  # <  End Region
   
   
  if __name__ == "__main__":
   
      # ? Incresing Stack Limit
      # increase_stack()
   
      #< Calling Main Function
      main()
   
   
   
  
  