Each evening Roma plays online poker on his favourite website. The rules of poker on this website are a bit strange: there are always two players in a hand, there are no bets, and the winner takes 1 virtual bourle from the loser.

Last evening Roma started to play poker. He decided to spend no more than k virtual bourles — he will stop immediately if the number of his loses exceeds the number of his wins by k. Also Roma will leave the game if he wins enough money for the evening, i.e. if the number of wins exceeds the number of loses by k.

Next morning Roma found a piece of paper with a sequence on it representing his results. Roma doesn't remember the results exactly, and some characters in the sequence are written in a way such that it's impossible to recognize this character, so Roma can't recall whether he won k bourles or he lost.

The sequence written by Roma is a string s consisting of characters W (Roma won the corresponding hand), L (Roma lost), D (draw) and ? (unknown result). Roma wants to restore any valid sequence by changing all ? characters to W, L or D. The sequence is called valid if all these conditions are met: 

  * In the end the absolute difference between the number of wins and loses is equal to k; 
  * There is no hand such that the absolute difference before this hand was equal to k. 



Help Roma to restore any such sequence.

Input

The first line contains two numbers n (the length of Roma's sequence) and k (1 ≤ n, k ≤ 1000).

The second line contains the sequence s consisting of characters W, L, D and ?. There are exactly n characters in this sequence.

Output

If there is no valid sequence that can be obtained from s by replacing all ? characters by W, L or D, print NO.

Otherwise print this sequence. If there are multiple answers, print any of them.

Examples

Input

3 2
L??


Output

LDL


Input

3 1
W??


Output

NO


Input

20 5
?LLLLLWWWWW?????????


Output

WLLLLLWWWWWWWWLWLWDW
def main():
    n, k = [int(x) for x in input().split()]
    s = input()

    DP = [[0]*(2*k+10) for _ in range(n+1)]
    DP[0][0] = 1

    P = [[-1]*(2*k+10) for _ in range(n+1)]
    for i in range(n):
        dpi = DP[i]
        dpi1 = DP[i+1]

        pi = P[i]
        pi1 = P[i+1]
        
        if s[i] == 'W':
            for t in range(-k+1,k):
                if dpi[t]:
                    dpi1[t+1] = 1
                    pi1[t+1] = 0 

        elif s[i] == 'L':
            for t in range(-k+1,k):
                if dpi[t]:
                    dpi1[t-1] = 1
                    pi1[t-1] = 1 
            
        elif s[i] == 'D':
            for t in range(-k+1,k):
                if dpi[t]:
                    dpi1[t] = 1
                    pi1[t] = 2 

        elif s[i] == '?':
            for t in range(-k+1,k):
                if dpi[t]:
                    dpi1[t+1] = 1
                    pi1[t+1] = 0 

                    dpi1[t-1] = 1
                    pi1[t-1] = 1 

                    dpi1[t] = 1
                    pi1[t] = 2
    if DP[-1][k]:
        out = []
        t = k
        for i in reversed(range(1,n+1)):
            out.append(P[i][t])
            t += (-1,1,0)[out[-1]]     
    elif DP[-1][-k]:
        out = []
        t = -k
        for i in reversed(range(1,n+1)):
            out.append(P[i][t])
            t += (-1,1,0)[out[-1]]
    else:
        print 'NO'
        sys.exit()
    
    print ''.join('WLD?'[i] for i in reversed(out))




######## Python 2 and 3 footer by Pajenegod and c1729

# Note because cf runs old PyPy3 version which doesn't have the sped up
# unicode strings, PyPy3 strings will many times be slower than pypy2.
# There is a way to get around this by using binary strings in PyPy3
# but its syntax is different which makes it kind of a mess to use.

# So on cf, use PyPy2 for best string performance.

py2 = round(0.5)
if py2:
    from future_builtins import ascii, filter, hex, map, oct, zip
    range = xrange

import os, sys
from io import IOBase, BytesIO

BUFSIZE = 8192
class FastIO(BytesIO):
    newlines = 0

    def __init__(self, file):
        self._file = file
        self._fd = file.fileno()
        self.writable = "x" in file.mode or "w" in file.mode
        self.write = super(FastIO, self).write if self.writable else None

    def _fill(self):
        s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
        self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
        return s

    def read(self):
        while self._fill(): pass
        return super(FastIO,self).read()

    def readline(self):
        while self.newlines == 0:
            s = self._fill(); self.newlines = s.count(b"\n") + (not s)
        self.newlines -= 1
        return super(FastIO, self).readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.getvalue())
            self.truncate(0), self.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        if py2:
            self.write = self.buffer.write
            self.read = self.buffer.read
            self.readline = self.buffer.readline
        else:
            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)
input = lambda: sys.stdin.readline().rstrip('\r\n')

# Cout implemented in Python
import sys
class ostream:
    def __lshift__(self,a):
        sys.stdout.write(str(a))
        return self
cout = ostream()
endl = '\n'

# Read all remaining integers in stdin, type is given by optional argument, this is fast
def readnumbers(zero = 0):
    conv = ord if py2 else lambda x:x
    A = []; numb = zero; sign = 1; i = 0; s = sys.stdin.buffer.read()
    try:
        while True:
            if s[i] >= b'0' [0]:
                numb = 10 * numb + conv(s[i]) - 48
            elif s[i] == b'-' [0]: sign = -1
            elif s[i] != b'\r' [0]:
                A.append(sign*numb)
                numb = zero; sign = 1
            i += 1
    except:pass
    if s and s[-1] >= b'0' [0]:
        A.append(sign*numb)
    return A

if __name__== "__main__":
  main()
