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
import java.util.*;

public class E803 {
    static final int WON = 1;
    static final int LOST = 2;
    static final int DRAW = 3;
    static String game;
    static int n;
    static int k;
    static Stack<Question> q;
    static int answer[];
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        n = s.nextInt();
        k = s.nextInt();
        game = s.next();
        
       // String ans = dynamicSolve();
        
        String ans1 = linearSolve();
        System.out.println(ans1);
        
    }
    
    static String dynamicSolve() {
        int m = 2*k+1;
        int dp[][] = new int[n+1][m];
        dp[n][0] = DRAW;
        dp[n][m-1] = DRAW;
        for(int i = n-1; i >= 0; --i) {
            switch(game.charAt(i)) {
            case 'W':
                for(int j = 2; j < m; ++j) {
                    if(dp[i+1][j] != 0) {
                        dp[i][j-1] = WON;
                    }
                }
                break;
            case 'L':
                for(int j = 0; j < m - 2; ++j) {
                    if(dp[i+1][j] != 0) {
                        dp[i][j+1] = LOST;
                    }
                }
                break;
            case 'D':
                for(int j = 1; j < m - 1; ++j) {
                    if(dp[i+1][j] != 0) {
                        dp[i][j] = DRAW;
                    }
                }
                break;
            case '?':
                for(int j = 1; j < m-1; ++j) {
                    if(dp[i+1][j] != 0) {
                        dp[i][j] = DRAW;
                    } else if(dp[i+1][j+1] != 0) {
                        dp[i][j] = WON;
                    } else if(dp[i+1][j-1] != 0) {
                        dp[i][j] = LOST;
                    }
                }
                break;
            }
            //System.out.println(Arrays.toString(dp[i]));
        }
        if(dp[0][k] == 0) {
            return "NO";
        } else {
            int ptr = k;
            StringBuilder ans = new StringBuilder();
            for(int i = 0; i < n; ++i) {
                if(dp[i][ptr] == 1) {
                    ans.append('W');
                    ptr++;
                } else if(dp[i][ptr] == 2) {
                    ans.append('L');
                    ptr--;
                } else if(dp[i][ptr] == 3) {
                    ans.append('D');
                }
            }
            return ans.toString();
        }
    }
    
    static String linearSolve() {
        answer = new int[n];
        q = new Stack<>();
        // difference between wins and losses
        int curDif = 0;
        for(int ptr = 0; ptr < n; ++ptr) {
            char curGame = game.charAt(ptr);
            if(curGame == 'W') {
                curDif++;
                answer[ptr] = WON;
                if(ptr != n - 1) {
                    if(curDif == k) {
                        if(!addLoss()) {
                            return "NO";
                        } else {
                            curDif--;
                        }
                    }
                    if(!q.isEmpty()) {
                        Question last = q.peek();
                        last.maxDif = Integer.max(last.maxDif, curDif);
                        last.minDif = Integer.min(last.minDif, curDif);
                    }
                }                
            } else if(curGame == 'L') {
                curDif--;
                answer[ptr] = LOST;
                if(ptr != n - 1) {
                    if(curDif == -k) {
                        if(!addWin()) {
                            return "NO";
                        } else {
                            curDif++;
                        }
                    }
                    if(!q.isEmpty()) {
                        Question last = q.peek();
                        last.maxDif = Integer.max(last.maxDif, curDif);
                        last.minDif = Integer.min(last.minDif, curDif);
                    }
                }                
            } else if(curGame == '?') {
                q.push(new Question(ptr, curDif));
            } else {
                answer[ptr] = DRAW;
            }
        }
        int answerLog[] = Arrays.copyOf(answer, answer.length);
        Stack<Question> qLog = new Stack<Question>();
        for(int i = 0; i < q.size(); ++i) {
            qLog.push(new Question(q.get(i)));
        }
        int dif;
        for(dif = k - curDif; dif > 0 && addWin(); --dif);
        if(dif != 0) {
            answer = answerLog;
            q = qLog;
            for(dif = curDif + k; dif > 0 && addLoss(); --dif);
        }
        if(dif != 0) {
            return "NO";
        }
        StringBuilder ans = new StringBuilder();
        for(int i = 0; i < n; ++i) {
            switch(answer[i]) {
            case 0:
                ans.append('D');
                break;
            case WON:
                ans.append('W');
                break;
            case LOST:
                ans.append('L');
                break;
            case DRAW:
                ans.append('D');
                break;
            }
        }
        return ans.toString();
    }
    
    /**
     * tries to add win to the last question mark
     * @return true if the win was added, false if it is impossible
     */
    static boolean addWin() {
        if(q.isEmpty()) {
            return false;
        }
        Question last = q.pop();
        //trying to add W - increase difference
        if(last.maxDif == k - 1) {
            return false;
        }
        answer[last.pos] = WON;
        if(last.maxDif != Integer.MAX_VALUE) {
            last.maxDif++;
            last.minDif++;
        }
        last.curDif++;
        if(last.pos != n - 1) {
            if(last.curDif == k) {
                if(!addLoss()) {
                    return false;
                }
            }
            if(!q.isEmpty()) {
                Question penult = q.peek();
                penult.maxDif = Integer.max(penult.maxDif, Integer.max(last.maxDif, last.curDif));
                penult.minDif = Integer.min(penult.minDif, Integer.min(last.minDif, last.curDif));
            }
        }
        return true;
    }    

    /**
     * tries to add win to the last question mark
     * @return true if the win was added, false if it is impossible
     */
    static boolean addLoss() {
        if(q.isEmpty()) {
            return false;
        }
        Question last = q.pop();
        //trying to add L - decrease difference
        if(last.minDif == -k + 1) {
            return false;
        }
        answer[last.pos] = LOST;
        if(last.maxDif != Integer.MAX_VALUE) {
            last.maxDif--;
            last.minDif--;
        }
        last.curDif--;  
        if(last.pos != n - 1) {
            if(last.curDif == -k) {
                if(!addWin()) {
                    return false;
                }
            }
            if(!q.isEmpty()) {
                Question penult = q.peek();
                penult.maxDif = Integer.max(penult.maxDif, Integer.max(last.maxDif, last.curDif));
                penult.minDif = Integer.min(penult.minDif, Integer.min(last.minDif, last.curDif));
            }
        }        
        return true;
    }
    
    static class Question {
        int pos;
        // minimal and maximal differences starting from position pos and to the next question
        // mark if exists or to the end of game otherwise
        int minDif = Integer.MAX_VALUE;
        int maxDif = Integer.MIN_VALUE;
        int curDif;
        Question(int pos, int curDif) {
            this.pos = pos;
            this.curDif = curDif;
        }
        public Question(Question q) {
            pos = q.pos;
            minDif = q.minDif;
            maxDif = q.maxDif;
            curDif = q.curDif;
        }
    }
}
