**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Test of Love
time_limit_ms: 2000
memory_limit_mb: 256
Description: ErnKor is ready to do anything for Julen, even to swim through crocodile- infested swamps. We decided to test this love. ErnKor will have to swim across a river with a width of $1$ meter and a length of $n$ meters.

The river is very cold. Therefore, in total (that is, throughout the entire swim from $0$ to $n+1$) ErnKor can swim in the water for no more than $k$ meters. For the sake of humanity, we have added not only crocodiles to the river, but also logs on which he can jump. Our test is as follows:

Initially, ErnKor is on the left bank and needs to reach the right bank. They are located at the $0$ and $n+1$ meters respectively. The river can be represented as $n$ segments, each with a length of $1$ meter. Each segment contains either a log 'L', a crocodile 'C', or just water 'W'. ErnKor can move as follows:

  * If he is on the surface (i.e., on the bank or on a log), he can jump forward for no more than $m$ ($1 \le m \le 10$) meters (he can jump on the bank, on a log, or in the water).    * If he is in the water, he can only swim to the next river segment (or to the bank if he is at the $n$-th meter).    * ErnKor cannot land in a segment with a crocodile in any way.

Determine if ErnKor can reach the right bank.

Input: The first line contains a single integer $t$ ($1 \le t \le 10^4$)  — the number of test cases.

The first line of each test case contains three numbers $n, m, k$ ($0 \le k \le 2 \cdot 10^5$, $1 \le n \le 2 \cdot 10^5$, $1 \le m \le 10$) — the length of the river, the distance ErnKor can jump, and the number of meters ErnKor can swim without freezing.

The second line of each test case contains a string $a$ of length $n$. $a_i$ denotes the object located at the $i$-th meter. ($a_i \in \\{$'W','C','L'$\\}$)

It is guaranteed that the sum of $n$ over all test cases does not exceed $2 \cdot 10^5$.

Output: For each test case, output "YES" if ErnKor can pass the test, and output "NO" otherwise.

You can output the answer in any case (upper or lower). For example, the strings "yEs", "yes", "Yes", and "YES" will be recognized as positive responses.

Examples:
input:
6
6 2 0
LWLLLW
6 1 1
LWLLLL
6 1 1
LWLLWL
6 2 15
LWLLCC
6 10 0
CCCCCC
6 6 1
WCCCCW
output:
YES
YES
NO
NO
YES
YES

Note: Let's consider examples:

  * First example: We jump from the shore to the first log ($0 \rightarrow 1$), from the first log to the second ($1 \rightarrow 3$), from the second to the fourth ($3 \rightarrow 5$), and from the last log to the shore ($5 \rightarrow 7$). So, we have $0 \rightarrow 1 \rightarrow 3 \rightarrow 5 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * Second example: $0 \rightarrow 1$, we jump into the water from the first log ($1 \rightarrow 2$), swim a cell to the log ($2 \leadsto 3$), $3 \rightarrow 4 \rightarrow 5 \rightarrow 6 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * In the third example, ErnKor needs to swim two cells 'W', but can only swim one. Therefore, the answer is «NO».    * Sixth example: We jump from the shore into the water ($0 \rightarrow 6$) and swim one cell in the water ($6 \leadsto 7$). Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».

Buggy Code:
import sys
input = lambda: sys.stdin.readline().rstrip()
"""
Example
input
6
6 2 0
LWLLLW
6 1 1
LWLLLL
6 1 1
LWLLWL
6 2 15
LWLLCC
6 10 0
CCCCCC
6 6 1
WCCCCW

output
YES
YES
NO
NO
YES
YES
"""

def solve(n, m, k, s):
    position = 0  # Starting at the left bank (position 0)
    swam_once = False

    while position < n:
        next_position = -1

        # Check for the farthest position we can jump to
        for jump in range(1, m + 1):
            if position + jump >= n:
                return "YES"
            if s[position + jump] == 'L':
                next_position = position + jump

        if next_position != -1:
            position = next_position
        else:
            # If we can't jump to a log, we must swim
            if swam_once:
                return "NO"  # We can't swim more than once
            if position + 1 < n and s[position + 1] == 'C':
                return "NO"  # We can't swim into a crocodile
            position += 1
            swam_once = True

    return "YES"

for _ in range(int(input())):
    n, m, k = map(int, input().split())
    s = input()
    print(solve(n, m, k, s))

**Instructions:**
- Focus on edge cases or scenarios that maximize the failure probability in faulty solutions.
- Due to the output length limit, you should generate a **small-scale** test input that is **complete and valid**.
- Output the test input directly, not code to generate it.

**Output format:**
```plaintext
{test input}
```

Think step by step.

Response:
```plaintext
1
10 2 1
LWCLWCLWCL
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Test of Love
time_limit_ms: 2000
memory_limit_mb: 256
Description: ErnKor is ready to do anything for Julen, even to swim through crocodile- infested swamps. We decided to test this love. ErnKor will have to swim across a river with a width of $1$ meter and a length of $n$ meters.

The river is very cold. Therefore, in total (that is, throughout the entire swim from $0$ to $n+1$) ErnKor can swim in the water for no more than $k$ meters. For the sake of humanity, we have added not only crocodiles to the river, but also logs on which he can jump. Our test is as follows:

Initially, ErnKor is on the left bank and needs to reach the right bank. They are located at the $0$ and $n+1$ meters respectively. The river can be represented as $n$ segments, each with a length of $1$ meter. Each segment contains either a log 'L', a crocodile 'C', or just water 'W'. ErnKor can move as follows:

  * If he is on the surface (i.e., on the bank or on a log), he can jump forward for no more than $m$ ($1 \le m \le 10$) meters (he can jump on the bank, on a log, or in the water).    * If he is in the water, he can only swim to the next river segment (or to the bank if he is at the $n$-th meter).    * ErnKor cannot land in a segment with a crocodile in any way.

Determine if ErnKor can reach the right bank.

Input: The first line contains a single integer $t$ ($1 \le t \le 10^4$)  — the number of test cases.

The first line of each test case contains three numbers $n, m, k$ ($0 \le k \le 2 \cdot 10^5$, $1 \le n \le 2 \cdot 10^5$, $1 \le m \le 10$) — the length of the river, the distance ErnKor can jump, and the number of meters ErnKor can swim without freezing.

The second line of each test case contains a string $a$ of length $n$. $a_i$ denotes the object located at the $i$-th meter. ($a_i \in \\{$'W','C','L'$\\}$)

It is guaranteed that the sum of $n$ over all test cases does not exceed $2 \cdot 10^5$.

Output: For each test case, output "YES" if ErnKor can pass the test, and output "NO" otherwise.

You can output the answer in any case (upper or lower). For example, the strings "yEs", "yes", "Yes", and "YES" will be recognized as positive responses.

Examples:
input:
6
6 2 0
LWLLLW
6 1 1
LWLLLL
6 1 1
LWLLWL
6 2 15
LWLLCC
6 10 0
CCCCCC
6 6 1
WCCCCW
output:
YES
YES
NO
NO
YES
YES

Note: Let's consider examples:

  * First example: We jump from the shore to the first log ($0 \rightarrow 1$), from the first log to the second ($1 \rightarrow 3$), from the second to the fourth ($3 \rightarrow 5$), and from the last log to the shore ($5 \rightarrow 7$). So, we have $0 \rightarrow 1 \rightarrow 3 \rightarrow 5 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * Second example: $0 \rightarrow 1$, we jump into the water from the first log ($1 \rightarrow 2$), swim a cell to the log ($2 \leadsto 3$), $3 \rightarrow 4 \rightarrow 5 \rightarrow 6 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * In the third example, ErnKor needs to swim two cells 'W', but can only swim one. Therefore, the answer is «NO».    * Sixth example: We jump from the shore into the water ($0 \rightarrow 6$) and swim one cell in the water ($6 \leadsto 7$). Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».

Buggy Code:
x=int(input())
for i in range(x):
    len_riv,jump,swim = map(int,input().split())
    given=["L"]+list(input())+["L"]
    i=0
    ans="YES"
    while i<len_riv+1:
        if given[i]=="L":
            if given[i+1]=="L":
                i+=1
            elif given[i+1]=="W" or given[i+1]=="C":
                i+=jump
        elif given[i]=="W":
            if swim>0:
                i+=1
                swim-=1
            else:
                ans="NO"
                break
        else:
            ans="NO"
            break
    print(ans)

**Instructions:**
- Focus on edge cases or scenarios that maximize the failure probability in faulty solutions.
- Due to the output length limit, you should generate a **small-scale** test input that is **complete and valid**.
- Output the test input directly, not code to generate it.

**Output format:**
```plaintext
{test input}
```

Think step by step.

Response:
To generate a challenging test input that exposes the bug in the provided code, let's consider the following scenarios:

1. **Edge Cases for Swimming and Jumping:**
   - Ensure that the maximum swimming distance is exactly the same as the required distance to reach the end.
   - Ensure that the maximum jumping distance is just enough to avoid crocodiles and reach the next log or the bank.

2. **Crocodile and Log Placement:**
   - Place crocodiles in positions that make it impossible to jump over them without swimming, and ensure the swimming limit is just enough to reach the next safe position.
   - Place logs in positions that are just out of reach by jumping, forcing the need to swim.

3. **Boundary Conditions:**
   - Test cases where the river length is 0 or 1, and the swimming limit is 0 or 1.

Here is a small-scale test input that includes these considerations:

```plaintext
4
1 1 0
L
2 1 1
LC
3 2 1
LWL
4 2 2
LWLC
```

### Explanation:

1. **Test Case 1:**
   - River length: 1
   - Jump distance: 1
   - Swimming limit: 0
   - River: L
   - **Expected Output:** YES
   - **Reason:** ErnKor can jump directly to the log and then to the bank without swimming.

2. **Test Case 2:**
   - River length: 2
   - Jump distance: 1
   - Swimming limit: 1
   - River: LC
   - **Expected Output:** NO
   - **Reason:** ErnKor can jump to the log, but then there is a crocodile, and he cannot jump over it. He cannot swim because the swimming limit is 0.

3. **Test Case 3:**
   - River length: 3
   - Jump distance: 2
   - Swimming limit: 1
   - River: LWL
   - **Expected Output:** YES
   - **Reason:** ErnKor can jump to the first log, then jump to the second log, and finally to the bank without swimming.

4. **Test Case 4:**
   - River length: 4
   - Jump distance: 2
   - Swimming limit: 2
   - River: LWLC
   - **Expected Output:** NO
   - **Reason:** ErnKor can jump to the first log, then swim to the second log, but then there is a crocodile, and he cannot jump over it. He cannot swim again because the swimming limit is 0.

This test input should help expose the bug in the provided code by covering edge cases and ensuring that the logic for jumping and swimming is correctly implemented.


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Test of Love
time_limit_ms: 2000
memory_limit_mb: 256
Description: ErnKor is ready to do anything for Julen, even to swim through crocodile- infested swamps. We decided to test this love. ErnKor will have to swim across a river with a width of $1$ meter and a length of $n$ meters.

The river is very cold. Therefore, in total (that is, throughout the entire swim from $0$ to $n+1$) ErnKor can swim in the water for no more than $k$ meters. For the sake of humanity, we have added not only crocodiles to the river, but also logs on which he can jump. Our test is as follows:

Initially, ErnKor is on the left bank and needs to reach the right bank. They are located at the $0$ and $n+1$ meters respectively. The river can be represented as $n$ segments, each with a length of $1$ meter. Each segment contains either a log 'L', a crocodile 'C', or just water 'W'. ErnKor can move as follows:

  * If he is on the surface (i.e., on the bank or on a log), he can jump forward for no more than $m$ ($1 \le m \le 10$) meters (he can jump on the bank, on a log, or in the water).    * If he is in the water, he can only swim to the next river segment (or to the bank if he is at the $n$-th meter).    * ErnKor cannot land in a segment with a crocodile in any way.

Determine if ErnKor can reach the right bank.

Input: The first line contains a single integer $t$ ($1 \le t \le 10^4$)  — the number of test cases.

The first line of each test case contains three numbers $n, m, k$ ($0 \le k \le 2 \cdot 10^5$, $1 \le n \le 2 \cdot 10^5$, $1 \le m \le 10$) — the length of the river, the distance ErnKor can jump, and the number of meters ErnKor can swim without freezing.

The second line of each test case contains a string $a$ of length $n$. $a_i$ denotes the object located at the $i$-th meter. ($a_i \in \\{$'W','C','L'$\\}$)

It is guaranteed that the sum of $n$ over all test cases does not exceed $2 \cdot 10^5$.

Output: For each test case, output "YES" if ErnKor can pass the test, and output "NO" otherwise.

You can output the answer in any case (upper or lower). For example, the strings "yEs", "yes", "Yes", and "YES" will be recognized as positive responses.

Examples:
input:
6
6 2 0
LWLLLW
6 1 1
LWLLLL
6 1 1
LWLLWL
6 2 15
LWLLCC
6 10 0
CCCCCC
6 6 1
WCCCCW
output:
YES
YES
NO
NO
YES
YES

Note: Let's consider examples:

  * First example: We jump from the shore to the first log ($0 \rightarrow 1$), from the first log to the second ($1 \rightarrow 3$), from the second to the fourth ($3 \rightarrow 5$), and from the last log to the shore ($5 \rightarrow 7$). So, we have $0 \rightarrow 1 \rightarrow 3 \rightarrow 5 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * Second example: $0 \rightarrow 1$, we jump into the water from the first log ($1 \rightarrow 2$), swim a cell to the log ($2 \leadsto 3$), $3 \rightarrow 4 \rightarrow 5 \rightarrow 6 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * In the third example, ErnKor needs to swim two cells 'W', but can only swim one. Therefore, the answer is «NO».    * Sixth example: We jump from the shore into the water ($0 \rightarrow 6$) and swim one cell in the water ($6 \leadsto 7$). Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».

Buggy Code:
import java.util.*;
public class D_Test_of_Love{
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
    int t = sc.nextInt();
    while(t > 0){
        int n = sc.nextInt();
        int m  =sc.nextInt();
        int k = sc.nextInt();
        String s = sc.next();
        sc.nextLine();
        if(isPossible(n,m,k,s))
        System.out.println("YES");
        else
        System.out.println("NO");
        t--;
    }
    }
    public static boolean isPossible(int n,int m,int k,String s){
        int jump = m,swim = k;
        for(char ch:s.toCharArray()){
            if(ch == 'L'){
                jump = m;
                jump--;
            }
            else if(ch == 'C'){
                jump--;
                if(jump < 0)
                return false;
            }
            else{
                if(jump == 0 && swim == 0)
                return false;
                if(jump > 0)
                jump--;
                else
                swim--;
            }
        }
        return true;
    }
}

**Instructions:**
- Focus on edge cases or scenarios that maximize the failure probability in faulty solutions.
- Due to the output length limit, you should generate a **small-scale** test input that is **complete and valid**.
- Output the test input directly, not code to generate it.

**Output format:**
```plaintext
{test input}
```

Think step by step.

Response:
```plaintext
1
5 2 1
LWCLW
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Test of Love
time_limit_ms: 2000
memory_limit_mb: 256
Description: ErnKor is ready to do anything for Julen, even to swim through crocodile- infested swamps. We decided to test this love. ErnKor will have to swim across a river with a width of $1$ meter and a length of $n$ meters.

The river is very cold. Therefore, in total (that is, throughout the entire swim from $0$ to $n+1$) ErnKor can swim in the water for no more than $k$ meters. For the sake of humanity, we have added not only crocodiles to the river, but also logs on which he can jump. Our test is as follows:

Initially, ErnKor is on the left bank and needs to reach the right bank. They are located at the $0$ and $n+1$ meters respectively. The river can be represented as $n$ segments, each with a length of $1$ meter. Each segment contains either a log 'L', a crocodile 'C', or just water 'W'. ErnKor can move as follows:

  * If he is on the surface (i.e., on the bank or on a log), he can jump forward for no more than $m$ ($1 \le m \le 10$) meters (he can jump on the bank, on a log, or in the water).    * If he is in the water, he can only swim to the next river segment (or to the bank if he is at the $n$-th meter).    * ErnKor cannot land in a segment with a crocodile in any way.

Determine if ErnKor can reach the right bank.

Input: The first line contains a single integer $t$ ($1 \le t \le 10^4$)  — the number of test cases.

The first line of each test case contains three numbers $n, m, k$ ($0 \le k \le 2 \cdot 10^5$, $1 \le n \le 2 \cdot 10^5$, $1 \le m \le 10$) — the length of the river, the distance ErnKor can jump, and the number of meters ErnKor can swim without freezing.

The second line of each test case contains a string $a$ of length $n$. $a_i$ denotes the object located at the $i$-th meter. ($a_i \in \\{$'W','C','L'$\\}$)

It is guaranteed that the sum of $n$ over all test cases does not exceed $2 \cdot 10^5$.

Output: For each test case, output "YES" if ErnKor can pass the test, and output "NO" otherwise.

You can output the answer in any case (upper or lower). For example, the strings "yEs", "yes", "Yes", and "YES" will be recognized as positive responses.

Examples:
input:
6
6 2 0
LWLLLW
6 1 1
LWLLLL
6 1 1
LWLLWL
6 2 15
LWLLCC
6 10 0
CCCCCC
6 6 1
WCCCCW
output:
YES
YES
NO
NO
YES
YES

Note: Let's consider examples:

  * First example: We jump from the shore to the first log ($0 \rightarrow 1$), from the first log to the second ($1 \rightarrow 3$), from the second to the fourth ($3 \rightarrow 5$), and from the last log to the shore ($5 \rightarrow 7$). So, we have $0 \rightarrow 1 \rightarrow 3 \rightarrow 5 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * Second example: $0 \rightarrow 1$, we jump into the water from the first log ($1 \rightarrow 2$), swim a cell to the log ($2 \leadsto 3$), $3 \rightarrow 4 \rightarrow 5 \rightarrow 6 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * In the third example, ErnKor needs to swim two cells 'W', but can only swim one. Therefore, the answer is «NO».    * Sixth example: We jump from the shore into the water ($0 \rightarrow 6$) and swim one cell in the water ($6 \leadsto 7$). Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».

Buggy Code:
import java.util.*;

public class max_of_three {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int t = in.nextInt();
        while (t-- > 0) {
            int a = in.nextInt(), m = in.nextInt(), k = in.nextInt();
            String s = in.next();
            int n = s.length(), x = 0, y = 0;
            int[] L = new int[n];
            int[] W = new int[n];
            Arrays.fill(L, -1);
            Arrays.fill(W, -1);
            for (int i = 0; i < n; i++) {
                if (s.charAt(i) == 'L')
                    L[x++] = i;
                if (s.charAt(i) == 'W')
                    W[y++] = i;
            }
            int n1 = x, n2 = y;
            x = 0;
            y = 0;
            boolean xx = false, yy = false;
            // System.out.println(Arrays.toString(L));
            // System.out.println(Arrays.toString(W));
            if (L[0] > m)
                yy = true;
            if (m >= n)
                System.out.println("Yes");
            else
                while (true) {
                    xx = false;
                    if (x < n1 - 1) {
                        if (!yy && L[x + 1] - L[x] <= m) {
                            x++;
                            if (L[x] + m >= n) {
                                System.out.println("Yes");
                                break;
                            }
                        } else {
                            if (k <= 0) {
                                System.out.println("No");
                                break;
                            }
                            while (L[0] <= m && y < n2 && W[y] < L[x]) {
                                y++;
                                // xx = true;
                            }
                            // System.out.println("111 x = " + x + " y = " + y);
                            if (y == n2 || (W[y] - L[x] > m)) {
                                System.out.println("No");
                                break;
                            } else {
                                while (y < n2 - 1 && k > 0 && W[y] == W[y + 1] - 1) {
                                    y++;
                                    k--;
                                }
                                // LWLWWWCLWWL
                                if (y == n2 - 1) {
                                    if (k == 0) {
                                        System.out.println("No");
                                        break;
                                    }
                                }
                                while (x < n1 && W[y] > L[x]) {
                                    x++;
                                }
                                if (x == n1 || L[x] - W[y] > 1) {
                                    System.out.println("No");
                                    break;
                                }
                                k -= L[x] - W[y];
                                // System.out.println("x = " + x + " y = " + y + " k = " + k + " ..");
                            }
                        }
                    } else {
                        if (L[x] + m >= n) {
                            System.out.println("Yes");
                            break;
                        } else {
                            while (y < n2 && W[y] < L[x]) {
                                y++;
                            }
                            if (y < n2 && W[y] + k >= n) {
                                System.out.println("Yes");
                                xx = true;
                                break;
                            } else {
                                System.out.println("No");
                                break;
                            }
                        }
                    }
                    // System.out.println("x = " + x + " y = " + y + " k = " + k);
                    yy = false;
                }
        }
    }

}

**Instructions:**
- Focus on edge cases or scenarios that maximize the failure probability in faulty solutions.
- Due to the output length limit, you should generate a **small-scale** test input that is **complete and valid**.
- Output the test input directly, not code to generate it.

**Output format:**
```plaintext
{test input}
```

Think step by step.

Response:
```plaintext
1
10 3 2
LWCLWCLWCL
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Test of Love
time_limit_ms: 2000
memory_limit_mb: 256
Description: ErnKor is ready to do anything for Julen, even to swim through crocodile- infested swamps. We decided to test this love. ErnKor will have to swim across a river with a width of $1$ meter and a length of $n$ meters.

The river is very cold. Therefore, in total (that is, throughout the entire swim from $0$ to $n+1$) ErnKor can swim in the water for no more than $k$ meters. For the sake of humanity, we have added not only crocodiles to the river, but also logs on which he can jump. Our test is as follows:

Initially, ErnKor is on the left bank and needs to reach the right bank. They are located at the $0$ and $n+1$ meters respectively. The river can be represented as $n$ segments, each with a length of $1$ meter. Each segment contains either a log 'L', a crocodile 'C', or just water 'W'. ErnKor can move as follows:

  * If he is on the surface (i.e., on the bank or on a log), he can jump forward for no more than $m$ ($1 \le m \le 10$) meters (he can jump on the bank, on a log, or in the water).    * If he is in the water, he can only swim to the next river segment (or to the bank if he is at the $n$-th meter).    * ErnKor cannot land in a segment with a crocodile in any way.

Determine if ErnKor can reach the right bank.

Input: The first line contains a single integer $t$ ($1 \le t \le 10^4$)  — the number of test cases.

The first line of each test case contains three numbers $n, m, k$ ($0 \le k \le 2 \cdot 10^5$, $1 \le n \le 2 \cdot 10^5$, $1 \le m \le 10$) — the length of the river, the distance ErnKor can jump, and the number of meters ErnKor can swim without freezing.

The second line of each test case contains a string $a$ of length $n$. $a_i$ denotes the object located at the $i$-th meter. ($a_i \in \\{$'W','C','L'$\\}$)

It is guaranteed that the sum of $n$ over all test cases does not exceed $2 \cdot 10^5$.

Output: For each test case, output "YES" if ErnKor can pass the test, and output "NO" otherwise.

You can output the answer in any case (upper or lower). For example, the strings "yEs", "yes", "Yes", and "YES" will be recognized as positive responses.

Examples:
input:
6
6 2 0
LWLLLW
6 1 1
LWLLLL
6 1 1
LWLLWL
6 2 15
LWLLCC
6 10 0
CCCCCC
6 6 1
WCCCCW
output:
YES
YES
NO
NO
YES
YES

Note: Let's consider examples:

  * First example: We jump from the shore to the first log ($0 \rightarrow 1$), from the first log to the second ($1 \rightarrow 3$), from the second to the fourth ($3 \rightarrow 5$), and from the last log to the shore ($5 \rightarrow 7$). So, we have $0 \rightarrow 1 \rightarrow 3 \rightarrow 5 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * Second example: $0 \rightarrow 1$, we jump into the water from the first log ($1 \rightarrow 2$), swim a cell to the log ($2 \leadsto 3$), $3 \rightarrow 4 \rightarrow 5 \rightarrow 6 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * In the third example, ErnKor needs to swim two cells 'W', but can only swim one. Therefore, the answer is «NO».    * Sixth example: We jump from the shore into the water ($0 \rightarrow 6$) and swim one cell in the water ($6 \leadsto 7$). Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».

Buggy Code:
#include <iostream>
#include <deque>
#include <deque>
#include <map>
#include <set>
#include <numeric>
#include <queue>
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <string>
#include <array>
//#include <bits/stdc++.h>

#define ll long long
#define ld long double
#define FIO ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
//const int N = 1 << 15, G = 4, TT = 226;
const ll mod = 1e9 + 7;
using namespace std;
const ll inf = 1e18, N = 205, K = 205, P = 200;
#define eps 1e-8
#define pi acos(-1)

void solve()
{
	ll n, m, k; string s;
	cin >> n >> m >> k;
	cin >> s;
	vector<char> v;
	v.push_back('S');
	for (auto& i : s) v.push_back(i);
	v.push_back('S');
	ll i = 0;
	string ans = "YES\n";
	while (i < n)
	{
		ll idx = -1;
		if (v[i] == 'S' && i)break;
		if (v[i] == 'L' || v[i] == 'S')
		{
			//search for furhest log or shore
			for (ll j = 1; j <= m; j++)
			{
				if (i + j >= v.size()) break;
				//cout << i + j << " ";
				if (v[i + j] == 'L' || v[i + j] == 'S')
					idx = i + j;
			}
			//search for swim
			if (idx == -1)
			{
				for (ll j = 1; j <= m; j++)
				{
					if (i + j >= v.size()) break;
					if (v[i + j] == 'W')
						idx = i + j;
				}
			}
			if (idx == -1)
			{
				ans = "NO\n";
				break;
			}
		}
		else if (v[i] == 'W')
		{
			if (!k)
			{
				ans = "NO\n";
				break;
			}
			idx = i + 1;
			k--;
		}
		else if (v[i] == 'C')
		{
			ans = "NO\n";
			break;
		}
		i = idx;
	}
	cout << ans;
}

int main()
{
	FIO;
	//freopen("path.in", "r", stdin);

	ll t = 1;
	cin >> t;
	while (t--)
	{
		solve();
	}
}

**Instructions:**
- Focus on edge cases or scenarios that maximize the failure probability in faulty solutions.
- Due to the output length limit, you should generate a **small-scale** test input that is **complete and valid**.
- Output the test input directly, not code to generate it.

**Output format:**
```plaintext
{test input}
```

Think step by step.

Response:
```plaintext
1
10 2 2
LWCLWCLWCL
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Test of Love
time_limit_ms: 2000
memory_limit_mb: 256
Description: ErnKor is ready to do anything for Julen, even to swim through crocodile- infested swamps. We decided to test this love. ErnKor will have to swim across a river with a width of $1$ meter and a length of $n$ meters.

The river is very cold. Therefore, in total (that is, throughout the entire swim from $0$ to $n+1$) ErnKor can swim in the water for no more than $k$ meters. For the sake of humanity, we have added not only crocodiles to the river, but also logs on which he can jump. Our test is as follows:

Initially, ErnKor is on the left bank and needs to reach the right bank. They are located at the $0$ and $n+1$ meters respectively. The river can be represented as $n$ segments, each with a length of $1$ meter. Each segment contains either a log 'L', a crocodile 'C', or just water 'W'. ErnKor can move as follows:

  * If he is on the surface (i.e., on the bank or on a log), he can jump forward for no more than $m$ ($1 \le m \le 10$) meters (he can jump on the bank, on a log, or in the water).    * If he is in the water, he can only swim to the next river segment (or to the bank if he is at the $n$-th meter).    * ErnKor cannot land in a segment with a crocodile in any way.

Determine if ErnKor can reach the right bank.

Input: The first line contains a single integer $t$ ($1 \le t \le 10^4$)  — the number of test cases.

The first line of each test case contains three numbers $n, m, k$ ($0 \le k \le 2 \cdot 10^5$, $1 \le n \le 2 \cdot 10^5$, $1 \le m \le 10$) — the length of the river, the distance ErnKor can jump, and the number of meters ErnKor can swim without freezing.

The second line of each test case contains a string $a$ of length $n$. $a_i$ denotes the object located at the $i$-th meter. ($a_i \in \\{$'W','C','L'$\\}$)

It is guaranteed that the sum of $n$ over all test cases does not exceed $2 \cdot 10^5$.

Output: For each test case, output "YES" if ErnKor can pass the test, and output "NO" otherwise.

You can output the answer in any case (upper or lower). For example, the strings "yEs", "yes", "Yes", and "YES" will be recognized as positive responses.

Examples:
input:
6
6 2 0
LWLLLW
6 1 1
LWLLLL
6 1 1
LWLLWL
6 2 15
LWLLCC
6 10 0
CCCCCC
6 6 1
WCCCCW
output:
YES
YES
NO
NO
YES
YES

Note: Let's consider examples:

  * First example: We jump from the shore to the first log ($0 \rightarrow 1$), from the first log to the second ($1 \rightarrow 3$), from the second to the fourth ($3 \rightarrow 5$), and from the last log to the shore ($5 \rightarrow 7$). So, we have $0 \rightarrow 1 \rightarrow 3 \rightarrow 5 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * Second example: $0 \rightarrow 1$, we jump into the water from the first log ($1 \rightarrow 2$), swim a cell to the log ($2 \leadsto 3$), $3 \rightarrow 4 \rightarrow 5 \rightarrow 6 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * In the third example, ErnKor needs to swim two cells 'W', but can only swim one. Therefore, the answer is «NO».    * Sixth example: We jump from the shore into the water ($0 \rightarrow 6$) and swim one cell in the water ($6 \leadsto 7$). Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».

Buggy Code:
#include <bits/stdc++.h>
using namespace std;
int solve(string &s, int n, int m, int &k, int i, vector<int> &dp)
{
    if (i > n)
        return 1;
    if(dp[i] != -1)
        return dp[i];
    int ans = 0;
    if (i == 0)
    {
        for (int j = 1; j <= m; j++)
        {
            ans = ans | solve(s, n, m, k, i + j,dp);
        }
    }
    else
    {
        if (s[i - 1] == 'C')
            return 0;
        else if (s[i - 1] == 'L')
        {
            for (int j = 1; j <= m; j++)
            {
                ans = ans | solve(s, n, m, k, i + j,dp);
            }
        }
        else if (s[i - 1] == 'W' && k)
        {
            k--;
            ans = ans | solve(s, n, m, k, i + 1,dp);
            k++;
        }
    }

    return dp[i] = ans;
}
int main()
{
    int t;
    cin >> t;
    while (t--)
    {
        int n, m, k;
        cin >> n >> m >> k;
        string s;
        cin >> s;
        vector<int> dp(n + 5, -1);
        int ans = solve(s, n, m, k, 0, dp);
        if (ans)
        {
            cout << "YES" << endl;
        }
        else
        {
            cout << "NO" << endl;
        }
    }
    return 0;
}

**Instructions:**
- Focus on edge cases or scenarios that maximize the failure probability in faulty solutions.
- Due to the output length limit, you should generate a **small-scale** test input that is **complete and valid**.
- Output the test input directly, not code to generate it.

**Output format:**
```plaintext
{test input}
```

Think step by step.

Response:
```plaintext
1
10 3 2
WLLWCWWCWL
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Test of Love
time_limit_ms: 2000
memory_limit_mb: 256
Description: ErnKor is ready to do anything for Julen, even to swim through crocodile- infested swamps. We decided to test this love. ErnKor will have to swim across a river with a width of $1$ meter and a length of $n$ meters.

The river is very cold. Therefore, in total (that is, throughout the entire swim from $0$ to $n+1$) ErnKor can swim in the water for no more than $k$ meters. For the sake of humanity, we have added not only crocodiles to the river, but also logs on which he can jump. Our test is as follows:

Initially, ErnKor is on the left bank and needs to reach the right bank. They are located at the $0$ and $n+1$ meters respectively. The river can be represented as $n$ segments, each with a length of $1$ meter. Each segment contains either a log 'L', a crocodile 'C', or just water 'W'. ErnKor can move as follows:

  * If he is on the surface (i.e., on the bank or on a log), he can jump forward for no more than $m$ ($1 \le m \le 10$) meters (he can jump on the bank, on a log, or in the water).    * If he is in the water, he can only swim to the next river segment (or to the bank if he is at the $n$-th meter).    * ErnKor cannot land in a segment with a crocodile in any way.

Determine if ErnKor can reach the right bank.

Input: The first line contains a single integer $t$ ($1 \le t \le 10^4$)  — the number of test cases.

The first line of each test case contains three numbers $n, m, k$ ($0 \le k \le 2 \cdot 10^5$, $1 \le n \le 2 \cdot 10^5$, $1 \le m \le 10$) — the length of the river, the distance ErnKor can jump, and the number of meters ErnKor can swim without freezing.

The second line of each test case contains a string $a$ of length $n$. $a_i$ denotes the object located at the $i$-th meter. ($a_i \in \\{$'W','C','L'$\\}$)

It is guaranteed that the sum of $n$ over all test cases does not exceed $2 \cdot 10^5$.

Output: For each test case, output "YES" if ErnKor can pass the test, and output "NO" otherwise.

You can output the answer in any case (upper or lower). For example, the strings "yEs", "yes", "Yes", and "YES" will be recognized as positive responses.

Examples:
input:
6
6 2 0
LWLLLW
6 1 1
LWLLLL
6 1 1
LWLLWL
6 2 15
LWLLCC
6 10 0
CCCCCC
6 6 1
WCCCCW
output:
YES
YES
NO
NO
YES
YES

Note: Let's consider examples:

  * First example: We jump from the shore to the first log ($0 \rightarrow 1$), from the first log to the second ($1 \rightarrow 3$), from the second to the fourth ($3 \rightarrow 5$), and from the last log to the shore ($5 \rightarrow 7$). So, we have $0 \rightarrow 1 \rightarrow 3 \rightarrow 5 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * Second example: $0 \rightarrow 1$, we jump into the water from the first log ($1 \rightarrow 2$), swim a cell to the log ($2 \leadsto 3$), $3 \rightarrow 4 \rightarrow 5 \rightarrow 6 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * In the third example, ErnKor needs to swim two cells 'W', but can only swim one. Therefore, the answer is «NO».    * Sixth example: We jump from the shore into the water ($0 \rightarrow 6$) and swim one cell in the water ($6 \leadsto 7$). Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».

Buggy Code:
"""
尝试一下On模拟
特判掉一些点
特判：
1、跳的距离 >= n -1：yes
2、全是鳄鱼，不能一下跳到终点：no
策略：贪心能跳就跳，跳不了就游过去
双指针大模拟
"""
def solve():
    n,m,k = map(int,input().split())
    g = list(input())
    cntk = 0
    # 直接从跳的位置看
    l,r = -1 ,0
    if g[r] == 'W':cntk+=1
    if cntk > k: return 'NO'
    while r < n:
        mm = m-1
        if r<=l:return 'NO'
        if r == n:return 'YES'
        if g[l] == 'L' or l == -1:
            # 如果现在是木板或岸上，就往前再看
            while mm > 0 :
                if r == n:return 'YES'
                if g[r] == 'L':break
                r+=1
                if r == n:return 'YES'
                mm-=1
            if g[r] == 'C':return 'NO'
            if g[r] == 'W':
                cntk += 1
            l = r
            r+=1
            if r == n: return 'YES'
            continue
        if cntk > k :return 'NO'

        if g[r] == 'C':
            r-=1
            continue
        if g[r] =='L':
            l = r
            r+=1
            continue
        if g[r] == 'W' and g[l] == 'W':
            l = r
            r+=1
            cntk+=1
    if cntk > k: return 'NO'
    return 'YES'

for i in range(int(input())):print(solve())

**Instructions:**
- Focus on edge cases or scenarios that maximize the failure probability in faulty solutions.
- Due to the output length limit, you should generate a **small-scale** test input that is **complete and valid**.
- Output the test input directly, not code to generate it.

**Output format:**
```plaintext
{test input}
```

Think step by step.

Response:
```plaintext
1
10 2 1
WCLWWLWCLW
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Test of Love
time_limit_ms: 2000
memory_limit_mb: 256
Description: ErnKor is ready to do anything for Julen, even to swim through crocodile- infested swamps. We decided to test this love. ErnKor will have to swim across a river with a width of $1$ meter and a length of $n$ meters.

The river is very cold. Therefore, in total (that is, throughout the entire swim from $0$ to $n+1$) ErnKor can swim in the water for no more than $k$ meters. For the sake of humanity, we have added not only crocodiles to the river, but also logs on which he can jump. Our test is as follows:

Initially, ErnKor is on the left bank and needs to reach the right bank. They are located at the $0$ and $n+1$ meters respectively. The river can be represented as $n$ segments, each with a length of $1$ meter. Each segment contains either a log 'L', a crocodile 'C', or just water 'W'. ErnKor can move as follows:

  * If he is on the surface (i.e., on the bank or on a log), he can jump forward for no more than $m$ ($1 \le m \le 10$) meters (he can jump on the bank, on a log, or in the water).    * If he is in the water, he can only swim to the next river segment (or to the bank if he is at the $n$-th meter).    * ErnKor cannot land in a segment with a crocodile in any way.

Determine if ErnKor can reach the right bank.

Input: The first line contains a single integer $t$ ($1 \le t \le 10^4$)  — the number of test cases.

The first line of each test case contains three numbers $n, m, k$ ($0 \le k \le 2 \cdot 10^5$, $1 \le n \le 2 \cdot 10^5$, $1 \le m \le 10$) — the length of the river, the distance ErnKor can jump, and the number of meters ErnKor can swim without freezing.

The second line of each test case contains a string $a$ of length $n$. $a_i$ denotes the object located at the $i$-th meter. ($a_i \in \\{$'W','C','L'$\\}$)

It is guaranteed that the sum of $n$ over all test cases does not exceed $2 \cdot 10^5$.

Output: For each test case, output "YES" if ErnKor can pass the test, and output "NO" otherwise.

You can output the answer in any case (upper or lower). For example, the strings "yEs", "yes", "Yes", and "YES" will be recognized as positive responses.

Examples:
input:
6
6 2 0
LWLLLW
6 1 1
LWLLLL
6 1 1
LWLLWL
6 2 15
LWLLCC
6 10 0
CCCCCC
6 6 1
WCCCCW
output:
YES
YES
NO
NO
YES
YES

Note: Let's consider examples:

  * First example: We jump from the shore to the first log ($0 \rightarrow 1$), from the first log to the second ($1 \rightarrow 3$), from the second to the fourth ($3 \rightarrow 5$), and from the last log to the shore ($5 \rightarrow 7$). So, we have $0 \rightarrow 1 \rightarrow 3 \rightarrow 5 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * Second example: $0 \rightarrow 1$, we jump into the water from the first log ($1 \rightarrow 2$), swim a cell to the log ($2 \leadsto 3$), $3 \rightarrow 4 \rightarrow 5 \rightarrow 6 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * In the third example, ErnKor needs to swim two cells 'W', but can only swim one. Therefore, the answer is «NO».    * Sixth example: We jump from the shore into the water ($0 \rightarrow 6$) and swim one cell in the water ($6 \leadsto 7$). Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».

Buggy Code:
from collections import deque

def can_reach(n, m, k, river):
    queue = deque([(0, 0)])
    visited = set()
    visited.add((0, 0))

    while queue:
        pos, dist = queue.popleft()

        if pos == n + 1:
            return "YES"

        for jump in range(1, m + 1):
            new_pos = pos + jump

            if new_pos > n + 1:
                continue

            if new_pos == n + 1:
                return "YES"

            if river[new_pos - 1] == 'C':
                continue

            if river[new_pos - 1] == 'W':
                new_swim_distance = dist + 1
                if new_swim_distance <= k and (new_pos, new_swim_distance) not in visited:
                    visited.add((new_pos, new_swim_distance))
                    queue.append((new_pos, new_swim_distance))

            if river[new_pos - 1] == 'L':
                if (new_pos, dist) not in visited:
                    visited.add((new_pos, dist))
                    queue.append((new_pos, dist))

    return "NO"

def main():
    import sys
    input = sys.stdin.read
    data = input().split()

    t = int(data[0])
    index = 1
    results = []

    for _ in range(t):
        n = int(data[index])
        m = int(data[index + 1])
        k = int(data[index + 2])
        river = data[index + 3]
        index += 4

        results.append(can_reach(n, m, k, river))

    for result in results:
        print(result)

main()

**Instructions:**
- Focus on edge cases or scenarios that maximize the failure probability in faulty solutions.
- Due to the output length limit, you should generate a **small-scale** test input that is **complete and valid**.
- Output the test input directly, not code to generate it.

**Output format:**
```plaintext
{test input}
```

Think step by step.

Response:
To generate a challenging test input that exposes the bug in the provided buggy code, we need to focus on scenarios that are likely to cause the code to fail. Here are the key considerations:

1. **Edge Cases**:
   - **Short Rivers**: Test with very short rivers (e.g., `n = 1` or `n = 2`).
   - **Single Segment Rivers**: Test with a single segment river to ensure the code handles the edge case where `n = 1`.
   - **Maximum Jump Distance**: Test with the maximum jump distance (`m = 10`).
   - **No Swimming Allowed**: Test with `k = 0` to ensure the code handles the case where ErnKor cannot swim at all.
   - **Crocodiles at Critical Positions**: Test with crocodiles at positions that should block ErnKor's path.

2. **Complex Scenarios**:
   - **Multiple Logs and Water Segments**: Test with a mix of logs and water segments to ensure the code handles multiple jumps and swimming.
   - **Swimming Limits**: Test with a river where ErnKor needs to swim the exact number of meters allowed (`k`).

Given these considerations, let's create a small-scale test input that is complete and valid:

```plaintext
3
1 1 0
W
3 2 1
LWL
6 2 2
WLLCWW
```

### Explanation:

1. **Test Case 1**:
   - `n = 1`, `m = 1`, `k = 0`
   - `river = "W"`
   - **Expected Output**: "NO"
   - **Reason**: ErnKor cannot swim and the only segment is water, so he cannot reach the right bank.

2. **Test Case 2**:
   - `n = 3`, `m = 2`, `k = 1`
   - `river = "LWL"`
   - **Expected Output**: "YES"
   - **Reason**: ErnKor can jump from the left bank to the log at position 1, then jump to the log at position 3, and finally jump to the right bank. He swims only 1 meter (from position 3 to 4).

3. **Test Case 3**:
   - `n = 6`, `m = 2`, `k = 2`
   - `river = "WLLCWW"`
   - **Expected Output**: "NO"
   - **Reason**: ErnKor can jump from the left bank to the log at position 1, then jump to the log at position 3, but he cannot jump over the crocodile at position 4. He would need to swim 3 meters to reach the next log, which exceeds the allowed 2 meters.

This test input should help expose any bugs in the provided code, especially in handling edge cases and complex scenarios.


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Test of Love
time_limit_ms: 2000
memory_limit_mb: 256
Description: ErnKor is ready to do anything for Julen, even to swim through crocodile- infested swamps. We decided to test this love. ErnKor will have to swim across a river with a width of $1$ meter and a length of $n$ meters.

The river is very cold. Therefore, in total (that is, throughout the entire swim from $0$ to $n+1$) ErnKor can swim in the water for no more than $k$ meters. For the sake of humanity, we have added not only crocodiles to the river, but also logs on which he can jump. Our test is as follows:

Initially, ErnKor is on the left bank and needs to reach the right bank. They are located at the $0$ and $n+1$ meters respectively. The river can be represented as $n$ segments, each with a length of $1$ meter. Each segment contains either a log 'L', a crocodile 'C', or just water 'W'. ErnKor can move as follows:

  * If he is on the surface (i.e., on the bank or on a log), he can jump forward for no more than $m$ ($1 \le m \le 10$) meters (he can jump on the bank, on a log, or in the water).    * If he is in the water, he can only swim to the next river segment (or to the bank if he is at the $n$-th meter).    * ErnKor cannot land in a segment with a crocodile in any way.

Determine if ErnKor can reach the right bank.

Input: The first line contains a single integer $t$ ($1 \le t \le 10^4$)  — the number of test cases.

The first line of each test case contains three numbers $n, m, k$ ($0 \le k \le 2 \cdot 10^5$, $1 \le n \le 2 \cdot 10^5$, $1 \le m \le 10$) — the length of the river, the distance ErnKor can jump, and the number of meters ErnKor can swim without freezing.

The second line of each test case contains a string $a$ of length $n$. $a_i$ denotes the object located at the $i$-th meter. ($a_i \in \\{$'W','C','L'$\\}$)

It is guaranteed that the sum of $n$ over all test cases does not exceed $2 \cdot 10^5$.

Output: For each test case, output "YES" if ErnKor can pass the test, and output "NO" otherwise.

You can output the answer in any case (upper or lower). For example, the strings "yEs", "yes", "Yes", and "YES" will be recognized as positive responses.

Examples:
input:
6
6 2 0
LWLLLW
6 1 1
LWLLLL
6 1 1
LWLLWL
6 2 15
LWLLCC
6 10 0
CCCCCC
6 6 1
WCCCCW
output:
YES
YES
NO
NO
YES
YES

Note: Let's consider examples:

  * First example: We jump from the shore to the first log ($0 \rightarrow 1$), from the first log to the second ($1 \rightarrow 3$), from the second to the fourth ($3 \rightarrow 5$), and from the last log to the shore ($5 \rightarrow 7$). So, we have $0 \rightarrow 1 \rightarrow 3 \rightarrow 5 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * Second example: $0 \rightarrow 1$, we jump into the water from the first log ($1 \rightarrow 2$), swim a cell to the log ($2 \leadsto 3$), $3 \rightarrow 4 \rightarrow 5 \rightarrow 6 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * In the third example, ErnKor needs to swim two cells 'W', but can only swim one. Therefore, the answer is «NO».    * Sixth example: We jump from the shore into the water ($0 \rightarrow 6$) and swim one cell in the water ($6 \leadsto 7$). Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».

Buggy Code:
import java.io.*;
import java.net.NetworkInterface;
import java.util.*;

public class Main {

    public static void main(String[] args) throws IOException {
        int t=nextInt();
        for (int i = 0; i <t ; i++) {
            int n=nextInt();int m=nextInt();int k=nextInt();
            char[] a=new char[n];
            String s=nextToken();
            for (int j = 0; j <n ; j++) {
                a[j]=s.charAt(j);
            }
            boolean croc=true;boolean water=true;
            int last=-1;
            int l=k;
            for (int j = 0; j <n && croc && water; j++) {
                if(a[j]=='C'){
                    if(last+m<=j){
                        croc=false;
                    }
                }
                else if(a[j]=='L'){
                    last=j;
                }
                else{
                    while(j<n-1 && a[j]=='W'){
                        j++;
                    }
                    if(j-last-m>l){
                        water=false;
                    }
                    else{
                        l-=Math.max(j - last - m,0);
                    }
                }
            }
            if (a[n - 1] == 'W') {
                if(n-1-last-m>l){
                    water=false;
                }
                else{
                    l-=Math.max(n-1 - last - m,0);
                }
            }
            if(water && croc){
                out.println("YES");
            }
            else{
                out.println("NO");
            }
        }
        out.close();
    }

    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter out = new PrintWriter(System.out);
    static StringTokenizer in = new StringTokenizer("");

    public static boolean hasNext () throws IOException {
        if (in.hasMoreTokens()) return true;
        String s;
        while ((s = br.readLine()) != null) {
            in = new StringTokenizer(s);
            if (in.hasMoreTokens()) return true;
        }
        return false;
    }

    public static String nextToken () throws IOException {
        while (!in.hasMoreTokens()) {
            in = new StringTokenizer(br.readLine());
        }
        return in.nextToken();
    }

    public static int nextInt () throws IOException {
        return Integer.parseInt(nextToken());
    }

    public static double nextDouble () throws IOException {
        return Double.parseDouble(nextToken());
    }

    public static long nextLong () throws IOException {
        return Long.parseLong(nextToken());
    }
}

**Instructions:**
- Focus on edge cases or scenarios that maximize the failure probability in faulty solutions.
- Due to the output length limit, you should generate a **small-scale** test input that is **complete and valid**.
- Output the test input directly, not code to generate it.

**Output format:**
```plaintext
{test input}
```

Think step by step.

Response:
To expose the bug in the provided code, we need to focus on edge cases and scenarios that can highlight issues with the logic. The buggy code has a few potential problems:

1. **Handling of the last segment**: The code might not correctly handle the last segment of the river, especially if it is a log or water.
2. **Swimming in the water**: The code might not correctly account for the number of meters ErnKor can swim in the water.
3. **Jumping from the last log to the bank**: The code might not correctly handle the scenario where ErnKor needs to jump from the last log to the bank.

Let's construct a test case that can expose these issues:

### Test Case 1: Handling the last segment
We can create a scenario where the last segment is water, and ErnKor needs to swim to the bank. This will test if the code correctly handles the last segment.

### Test Case 2: Swimming in the water
We can create a scenario where ErnKor needs to swim multiple segments in the water, and the number of meters he can swim is just enough to pass. This will test if the code correctly accounts for the number of meters ErnKor can swim.

### Test Case 3: Jumping from the last log to the bank
We can create a scenario where the last log is at a position such that ErnKor needs to jump to the bank, and the jump distance is just enough. This will test if the code correctly handles the jump from the last log to the bank.

### Combined Test Case
Let's combine these scenarios into a single test case:

```plaintext
3
10 2 2
LWLLLLLWLL
10 1 1
LWLLLLLWLC
10 3 3
LWLLLLLWLL
```

### Explanation:
1. **First Test Case:**
   - `n = 10`, `m = 2`, `k = 2`
   - River: `LWLLLLLWLL`
   - ErnKor can jump from the bank to the first log, then to the second log, and finally to the last log. From the last log, he can jump to the bank. He will swim 2 meters in the water, which is within the limit of `k = 2`. The answer should be `YES`.

2. **Second Test Case:**
   - `n = 10`, `m = 1`, `k = 1`
   - River: `LWLLLLLWLC`
   - ErnKor can jump from the bank to the first log, then to the second log, and so on. However, when he reaches the last segment, he will encounter a crocodile. The answer should be `NO`.

3. **Third Test Case:**
   - `n = 10`, `m = 3`, `k = 3`
   - River: `LWLLLLLWLL`
   - ErnKor can jump from the bank to the first log, then to the second log, and finally to the last log. From the last log, he can jump to the bank. He will swim 3 meters in the water, which is within the limit of `k = 3`. The answer should be `YES`.

This test case should help expose the bug in the provided code.

3
10 2 2
LWLLLLLWLL
10 1 1
LWLLLLLWLC
10 3 3
LWLLLLLWLL


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Test of Love
time_limit_ms: 2000
memory_limit_mb: 256
Description: ErnKor is ready to do anything for Julen, even to swim through crocodile- infested swamps. We decided to test this love. ErnKor will have to swim across a river with a width of $1$ meter and a length of $n$ meters.

The river is very cold. Therefore, in total (that is, throughout the entire swim from $0$ to $n+1$) ErnKor can swim in the water for no more than $k$ meters. For the sake of humanity, we have added not only crocodiles to the river, but also logs on which he can jump. Our test is as follows:

Initially, ErnKor is on the left bank and needs to reach the right bank. They are located at the $0$ and $n+1$ meters respectively. The river can be represented as $n$ segments, each with a length of $1$ meter. Each segment contains either a log 'L', a crocodile 'C', or just water 'W'. ErnKor can move as follows:

  * If he is on the surface (i.e., on the bank or on a log), he can jump forward for no more than $m$ ($1 \le m \le 10$) meters (he can jump on the bank, on a log, or in the water).    * If he is in the water, he can only swim to the next river segment (or to the bank if he is at the $n$-th meter).    * ErnKor cannot land in a segment with a crocodile in any way.

Determine if ErnKor can reach the right bank.

Input: The first line contains a single integer $t$ ($1 \le t \le 10^4$)  — the number of test cases.

The first line of each test case contains three numbers $n, m, k$ ($0 \le k \le 2 \cdot 10^5$, $1 \le n \le 2 \cdot 10^5$, $1 \le m \le 10$) — the length of the river, the distance ErnKor can jump, and the number of meters ErnKor can swim without freezing.

The second line of each test case contains a string $a$ of length $n$. $a_i$ denotes the object located at the $i$-th meter. ($a_i \in \\{$'W','C','L'$\\}$)

It is guaranteed that the sum of $n$ over all test cases does not exceed $2 \cdot 10^5$.

Output: For each test case, output "YES" if ErnKor can pass the test, and output "NO" otherwise.

You can output the answer in any case (upper or lower). For example, the strings "yEs", "yes", "Yes", and "YES" will be recognized as positive responses.

Examples:
input:
6
6 2 0
LWLLLW
6 1 1
LWLLLL
6 1 1
LWLLWL
6 2 15
LWLLCC
6 10 0
CCCCCC
6 6 1
WCCCCW
output:
YES
YES
NO
NO
YES
YES

Note: Let's consider examples:

  * First example: We jump from the shore to the first log ($0 \rightarrow 1$), from the first log to the second ($1 \rightarrow 3$), from the second to the fourth ($3 \rightarrow 5$), and from the last log to the shore ($5 \rightarrow 7$). So, we have $0 \rightarrow 1 \rightarrow 3 \rightarrow 5 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * Second example: $0 \rightarrow 1$, we jump into the water from the first log ($1 \rightarrow 2$), swim a cell to the log ($2 \leadsto 3$), $3 \rightarrow 4 \rightarrow 5 \rightarrow 6 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * In the third example, ErnKor needs to swim two cells 'W', but can only swim one. Therefore, the answer is «NO».    * Sixth example: We jump from the shore into the water ($0 \rightarrow 6$) and swim one cell in the water ($6 \leadsto 7$). Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».

Buggy Code:
import java.util.*;
import java.io.*;
public class Main {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    public static void main(String[] args) throws IOException {
        int t = readInt();
        for(int x = 0; x < t; x++){
            int n = readInt();
            int k = readInt();
            int m = readInt();
            ArrayList<Character>ab = new ArrayList<>();
            ab.add(' ');
            char [] temp = next().toCharArray();
            for(int i = 0; i < n; i++)ab.add(temp[i]);
            int [] next = new int [n+1];
            Arrays.fill(next, -1);
            int cur = -1;
            for(int i = n; i >= 0; i--){
                next[i] = cur;
                if(i != 0 && ab.get(i) == 'L')cur = i;
            }
            int i = 0;
            boolean good = true;
            if(k >= n+1)System.out.println("YES");
            else{
                int swam = 0;
                while(i != n){
                    if(i == 0 || ab.get(i) == 'L'){
                        if(n-i+1 <= k)break;
                        else if(next[i] != -1 && next[i]-i <= k){
                            i = next[i];
                        }
                        else{
                            boolean dead = true;
                            for(int j = i+k; j >= i+1; j--){
                                if(ab.get(j) == 'W'){
                                    dead = false;
                                    i = j;
                                }
                            }
                            if(dead){
                                good = false;
                                break;
                            }
                        }
                    }
                    else{
                        boolean wow = false;
                        int j = i+1;
                        while(swam < m){
                            swam++;
                            if(j == n+1){
                                wow = true;
                                break;
                            }
                            if(ab.get(j) == 'C'){
                                break;
                            }
                            else if(ab.get(j) == 'L'){
                                wow = true;
                                i = j;
                            }
                        }
                        if(!wow){
                            good = false;
                            break;
                        }
                    }
                }
                if(good)System.out.println("YES");
                else System.out.println("NO");
            }
        }
    }
    static String next() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(br.readLine().trim());
        }
        return st.nextToken();
    }
    static int readInt() throws IOException {
        return Integer.parseInt(next());
    }
     static long readLong () throws IOException {
        return Long.parseLong(next());
    }
    static double readDouble () throws IOException {
        return Double.parseDouble(next());
    }
    static String readLine() throws IOException {
        return br.readLine().trim();
    }
}

**Instructions:**
- Focus on edge cases or scenarios that maximize the failure probability in faulty solutions.
- Due to the output length limit, you should generate a **small-scale** test input that is **complete and valid**.
- Output the test input directly, not code to generate it.

**Output format:**
```plaintext
{test input}
```

Think step by step.

Response:
To generate a challenging test input that exposes the bug in the given buggy code, we need to focus on edge cases and scenarios that maximize the failure probability. Here are some key points to consider:

1. **Maximum Swimming Limit (k):** Ensure that the value of `k` is such that ErnKor can just barely make it to the end, or slightly less, to test the boundary conditions.
2. **Jump Distance (m):** Use a value for `m` that is small to ensure that ErnKor needs to make multiple jumps, increasing the complexity of the problem.
3. **River Length (n):** Use a length that is just within the constraints to ensure the test case is valid and not too large.
4. **River Layout:** Create a layout that forces ErnKor to make optimal jumps and swims, including segments with logs, water, and crocodiles in strategic positions.

Let's construct a test case based on these considerations:

- **n = 10**: A reasonable length for the river.
- **m = 2**: A small jump distance to increase the number of jumps required.
- **k = 5**: A swimming limit that is just enough to make it through the river, but not much more.

We will create a river layout that forces ErnKor to make optimal decisions:

```plaintext
1
10 2 5
LWLCWLWLCW
```

### Explanation:
- **First Segment (L):** ErnKor can jump to the first log.
- **Second Segment (W):** ErnKor must swim this segment.
- **Third Segment (L):** ErnKor can jump to this log.
- **Fourth Segment (C):** ErnKor cannot land here, so he must jump over it.
- **Fifth Segment (W):** ErnKor must swim this segment.
- **Sixth Segment (L):** ErnKor can jump to this log.
- **Seventh Segment (W):** ErnKor must swim this segment.
- **Eighth Segment (L):** ErnKor can jump to this log.
- **Ninth Segment (C):** ErnKor cannot land here, so he must jump over it.
- **Tenth Segment (W):** ErnKor must swim this segment.

This layout ensures that ErnKor must make multiple jumps and swims, and it tests the boundary conditions of the swimming limit `k`. If the code correctly handles this scenario, it should output "YES" because ErnKor can reach the right bank without exceeding the swimming limit or landing on a crocodile.

### Final Test Input:
```plaintext
1
10 2 5
LWLCWLWLCW
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Test of Love
time_limit_ms: 2000
memory_limit_mb: 256
Description: ErnKor is ready to do anything for Julen, even to swim through crocodile- infested swamps. We decided to test this love. ErnKor will have to swim across a river with a width of $1$ meter and a length of $n$ meters.

The river is very cold. Therefore, in total (that is, throughout the entire swim from $0$ to $n+1$) ErnKor can swim in the water for no more than $k$ meters. For the sake of humanity, we have added not only crocodiles to the river, but also logs on which he can jump. Our test is as follows:

Initially, ErnKor is on the left bank and needs to reach the right bank. They are located at the $0$ and $n+1$ meters respectively. The river can be represented as $n$ segments, each with a length of $1$ meter. Each segment contains either a log 'L', a crocodile 'C', or just water 'W'. ErnKor can move as follows:

  * If he is on the surface (i.e., on the bank or on a log), he can jump forward for no more than $m$ ($1 \le m \le 10$) meters (he can jump on the bank, on a log, or in the water).    * If he is in the water, he can only swim to the next river segment (or to the bank if he is at the $n$-th meter).    * ErnKor cannot land in a segment with a crocodile in any way.

Determine if ErnKor can reach the right bank.

Input: The first line contains a single integer $t$ ($1 \le t \le 10^4$)  — the number of test cases.

The first line of each test case contains three numbers $n, m, k$ ($0 \le k \le 2 \cdot 10^5$, $1 \le n \le 2 \cdot 10^5$, $1 \le m \le 10$) — the length of the river, the distance ErnKor can jump, and the number of meters ErnKor can swim without freezing.

The second line of each test case contains a string $a$ of length $n$. $a_i$ denotes the object located at the $i$-th meter. ($a_i \in \\{$'W','C','L'$\\}$)

It is guaranteed that the sum of $n$ over all test cases does not exceed $2 \cdot 10^5$.

Output: For each test case, output "YES" if ErnKor can pass the test, and output "NO" otherwise.

You can output the answer in any case (upper or lower). For example, the strings "yEs", "yes", "Yes", and "YES" will be recognized as positive responses.

Examples:
input:
6
6 2 0
LWLLLW
6 1 1
LWLLLL
6 1 1
LWLLWL
6 2 15
LWLLCC
6 10 0
CCCCCC
6 6 1
WCCCCW
output:
YES
YES
NO
NO
YES
YES

Note: Let's consider examples:

  * First example: We jump from the shore to the first log ($0 \rightarrow 1$), from the first log to the second ($1 \rightarrow 3$), from the second to the fourth ($3 \rightarrow 5$), and from the last log to the shore ($5 \rightarrow 7$). So, we have $0 \rightarrow 1 \rightarrow 3 \rightarrow 5 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * Second example: $0 \rightarrow 1$, we jump into the water from the first log ($1 \rightarrow 2$), swim a cell to the log ($2 \leadsto 3$), $3 \rightarrow 4 \rightarrow 5 \rightarrow 6 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * In the third example, ErnKor needs to swim two cells 'W', but can only swim one. Therefore, the answer is «NO».    * Sixth example: We jump from the shore into the water ($0 \rightarrow 6$) and swim one cell in the water ($6 \leadsto 7$). Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».

Buggy Code:
#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define int long long
#define endl "\n"
#define all(x) (x).begin(),(x).end()
#define x first
#define y second
#define SZ(x) ((int)(x).size())
#define debug(a) cout<<#a<<' '<<a<<endl;
#define cut cout<<endl <<"-------------------"<<endl;

typedef long long ll;
typedef pair<int,int> pii;
typedef double db;
const int  N = 2e5 + 39;
const int  mod = 1e9 + 7;

void solve() {
    int n, m, k;
    cin >> n >> m >> k;

    string a;
    cin >> a;
    int j = 0;
    for (int i = 0 ; i < n ; i ++){ //

        while (j + 1 < m || a[i] == 'L'){
            j ++;
            if(a[i ] == 'L')j = 0;
            i ++;
        }
        if(a[i ] == 'W')k --;
        if(k < 0){
            cout << "NO" << endl;
            return ;
        }
        if(a[i ] == 'C'){
            cout << "NO" << endl;
            return ;
        }
        if(a[i ] == 'L')j = 0;
    }
    cout << "YES" << endl;
}
signed main (){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cin.tie(0);
	int t = 1;
    cin >> t;
	while (t --){
		solve ();
	}
    return 0;
}

**Instructions:**
- Focus on edge cases or scenarios that maximize the failure probability in faulty solutions.
- Due to the output length limit, you should generate a **small-scale** test input that is **complete and valid**.
- Output the test input directly, not code to generate it.

**Output format:**
```plaintext
{test input}
```

Think step by step.

Response:
```plaintext
1
10 2 1
LWCLWCLWCL
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Test of Love
time_limit_ms: 2000
memory_limit_mb: 256
Description: ErnKor is ready to do anything for Julen, even to swim through crocodile- infested swamps. We decided to test this love. ErnKor will have to swim across a river with a width of $1$ meter and a length of $n$ meters.

The river is very cold. Therefore, in total (that is, throughout the entire swim from $0$ to $n+1$) ErnKor can swim in the water for no more than $k$ meters. For the sake of humanity, we have added not only crocodiles to the river, but also logs on which he can jump. Our test is as follows:

Initially, ErnKor is on the left bank and needs to reach the right bank. They are located at the $0$ and $n+1$ meters respectively. The river can be represented as $n$ segments, each with a length of $1$ meter. Each segment contains either a log 'L', a crocodile 'C', or just water 'W'. ErnKor can move as follows:

  * If he is on the surface (i.e., on the bank or on a log), he can jump forward for no more than $m$ ($1 \le m \le 10$) meters (he can jump on the bank, on a log, or in the water).    * If he is in the water, he can only swim to the next river segment (or to the bank if he is at the $n$-th meter).    * ErnKor cannot land in a segment with a crocodile in any way.

Determine if ErnKor can reach the right bank.

Input: The first line contains a single integer $t$ ($1 \le t \le 10^4$)  — the number of test cases.

The first line of each test case contains three numbers $n, m, k$ ($0 \le k \le 2 \cdot 10^5$, $1 \le n \le 2 \cdot 10^5$, $1 \le m \le 10$) — the length of the river, the distance ErnKor can jump, and the number of meters ErnKor can swim without freezing.

The second line of each test case contains a string $a$ of length $n$. $a_i$ denotes the object located at the $i$-th meter. ($a_i \in \\{$'W','C','L'$\\}$)

It is guaranteed that the sum of $n$ over all test cases does not exceed $2 \cdot 10^5$.

Output: For each test case, output "YES" if ErnKor can pass the test, and output "NO" otherwise.

You can output the answer in any case (upper or lower). For example, the strings "yEs", "yes", "Yes", and "YES" will be recognized as positive responses.

Examples:
input:
6
6 2 0
LWLLLW
6 1 1
LWLLLL
6 1 1
LWLLWL
6 2 15
LWLLCC
6 10 0
CCCCCC
6 6 1
WCCCCW
output:
YES
YES
NO
NO
YES
YES

Note: Let's consider examples:

  * First example: We jump from the shore to the first log ($0 \rightarrow 1$), from the first log to the second ($1 \rightarrow 3$), from the second to the fourth ($3 \rightarrow 5$), and from the last log to the shore ($5 \rightarrow 7$). So, we have $0 \rightarrow 1 \rightarrow 3 \rightarrow 5 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * Second example: $0 \rightarrow 1$, we jump into the water from the first log ($1 \rightarrow 2$), swim a cell to the log ($2 \leadsto 3$), $3 \rightarrow 4 \rightarrow 5 \rightarrow 6 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * In the third example, ErnKor needs to swim two cells 'W', but can only swim one. Therefore, the answer is «NO».    * Sixth example: We jump from the shore into the water ($0 \rightarrow 6$) and swim one cell in the water ($6 \leadsto 7$). Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».

Buggy Code:
#include <bits/stdc++.h>
using namespace std;

int main()
{
    int i, t;
    cin >> t;
    while (t--)
    {
        int n, m, k;
        cin >> n >> m >> k;

        string v;
        cin >> v;

        vector<int> logs;
        logs.push_back(0);

        vector<int> croc(n + 2, 0);

        int ctr = 1;

        for (int i = 0; i < n; i++)
        {
            if (v[i] == 'L')
            {
                ctr++;
                logs.push_back(i + 1);
            }

            if (v[i] == 'C')
                croc[ctr] = i + 1;
        }

        logs.push_back(n + 1);

        int cur = 0;
        ctr = 0;
        for (int next : logs)
        {
            // cout << cur << " " << next << " " << k << " " << croc[ctr] << endl;
            if (next - cur <= m)
            {
                cur = next;
                ctr++;
            }

            else
            {
                if (croc[ctr] == 0)
                {
                    if (k >= (next - cur - 1))
                    {
                        k = k - (next - cur - 1);
                        cur = next;
                        ctr++;
                    }

                    else
                        break;
                }

                else
                {
                    if (((croc[ctr] + 1) <= m) && (k >= (next - croc[ctr] - 1)))
                    {
                        k = k - (next - croc[ctr] - 1);
                        cur = next;
                        ctr++;
                    }

                    else
                        break;
                }
            }
        }

        if (cur == n + 1)
            cout << "YES" << endl;
        else
            cout << "NO" << endl;
    }

    return 0;
}

**Instructions:**
- Focus on edge cases or scenarios that maximize the failure probability in faulty solutions.
- Due to the output length limit, you should generate a **small-scale** test input that is **complete and valid**.
- Output the test input directly, not code to generate it.

**Output format:**
```plaintext
{test input}
```

Think step by step.

Response:
```plaintext
1
10 1 9
LWLWLWLWLW
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Test of Love
time_limit_ms: 2000
memory_limit_mb: 256
Description: ErnKor is ready to do anything for Julen, even to swim through crocodile- infested swamps. We decided to test this love. ErnKor will have to swim across a river with a width of $1$ meter and a length of $n$ meters.

The river is very cold. Therefore, in total (that is, throughout the entire swim from $0$ to $n+1$) ErnKor can swim in the water for no more than $k$ meters. For the sake of humanity, we have added not only crocodiles to the river, but also logs on which he can jump. Our test is as follows:

Initially, ErnKor is on the left bank and needs to reach the right bank. They are located at the $0$ and $n+1$ meters respectively. The river can be represented as $n$ segments, each with a length of $1$ meter. Each segment contains either a log 'L', a crocodile 'C', or just water 'W'. ErnKor can move as follows:

  * If he is on the surface (i.e., on the bank or on a log), he can jump forward for no more than $m$ ($1 \le m \le 10$) meters (he can jump on the bank, on a log, or in the water).    * If he is in the water, he can only swim to the next river segment (or to the bank if he is at the $n$-th meter).    * ErnKor cannot land in a segment with a crocodile in any way.

Determine if ErnKor can reach the right bank.

Input: The first line contains a single integer $t$ ($1 \le t \le 10^4$)  — the number of test cases.

The first line of each test case contains three numbers $n, m, k$ ($0 \le k \le 2 \cdot 10^5$, $1 \le n \le 2 \cdot 10^5$, $1 \le m \le 10$) — the length of the river, the distance ErnKor can jump, and the number of meters ErnKor can swim without freezing.

The second line of each test case contains a string $a$ of length $n$. $a_i$ denotes the object located at the $i$-th meter. ($a_i \in \\{$'W','C','L'$\\}$)

It is guaranteed that the sum of $n$ over all test cases does not exceed $2 \cdot 10^5$.

Output: For each test case, output "YES" if ErnKor can pass the test, and output "NO" otherwise.

You can output the answer in any case (upper or lower). For example, the strings "yEs", "yes", "Yes", and "YES" will be recognized as positive responses.

Examples:
input:
6
6 2 0
LWLLLW
6 1 1
LWLLLL
6 1 1
LWLLWL
6 2 15
LWLLCC
6 10 0
CCCCCC
6 6 1
WCCCCW
output:
YES
YES
NO
NO
YES
YES

Note: Let's consider examples:

  * First example: We jump from the shore to the first log ($0 \rightarrow 1$), from the first log to the second ($1 \rightarrow 3$), from the second to the fourth ($3 \rightarrow 5$), and from the last log to the shore ($5 \rightarrow 7$). So, we have $0 \rightarrow 1 \rightarrow 3 \rightarrow 5 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * Second example: $0 \rightarrow 1$, we jump into the water from the first log ($1 \rightarrow 2$), swim a cell to the log ($2 \leadsto 3$), $3 \rightarrow 4 \rightarrow 5 \rightarrow 6 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * In the third example, ErnKor needs to swim two cells 'W', but can only swim one. Therefore, the answer is «NO».    * Sixth example: We jump from the shore into the water ($0 \rightarrow 6$) and swim one cell in the water ($6 \leadsto 7$). Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».

Buggy Code:
import bisect

def main():
    test_cases = int(input())
    while test_cases:
        solve()
        test_cases -= 1

def solve():
    n, m, k = map(int, input().split())
    bank = input()
    if m > n:
        print("YES")
        return
    map_in = dict()
    map_in["L"] = []
    map_in["W"] = []
    map_in["C"] = []
    for i, el in enumerate(bank):
        map_in[el].append(i)
    for key in map_in:
        map_in[key].append(n)
    pos = -1
    start = True
    # take optimal move
    while pos < n-1:
        # if there are logs
        if map_in["L"][bisect.bisect_left(map_in["L"], pos+1)] < n or start:

            # if nearest log is availabe
            if map_in["L"][bisect.bisect_left(map_in["L"], pos+1)] - pos <= m:
                pos = map_in["L"][bisect.bisect_left(map_in["L"], pos+1)]

                # if i can jump remaining
                if pos + m >= n:
                    print("YES")
                    return

            else:
                # farthest available water
                if (
                    map_in["W"][bisect.bisect_left(map_in["W"], pos + m)] - pos <= m
                    and k
                ):
                    pos = map_in["W"][bisect.bisect_left(map_in["W"], pos + m)]
                    k -= 1
                # no water available
                else:
                    print("NO")
                    return
            start = False
        # no near logs
        else:
            for i in range(pos + 1, len(bank)):

                if not k:
                    print("NO")
                    return

                if bank[i] == "C":
                    print("NO")
                    return
                k -= 1
                if bank[i] == "L":
                    pos = i
                    break
        if pos == n-1:
            if k:
                print("YES")
                return
    print("YES")

main()

**Instructions:**
- Focus on edge cases or scenarios that maximize the failure probability in faulty solutions.
- Due to the output length limit, you should generate a **small-scale** test input that is **complete and valid**.
- Output the test input directly, not code to generate it.

**Output format:**
```plaintext
{test input}
```

Think step by step.

Response:
```plaintext
1
10 2 1
LWCLWCLWCL
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Test of Love
time_limit_ms: 2000
memory_limit_mb: 256
Description: ErnKor is ready to do anything for Julen, even to swim through crocodile- infested swamps. We decided to test this love. ErnKor will have to swim across a river with a width of $1$ meter and a length of $n$ meters.

The river is very cold. Therefore, in total (that is, throughout the entire swim from $0$ to $n+1$) ErnKor can swim in the water for no more than $k$ meters. For the sake of humanity, we have added not only crocodiles to the river, but also logs on which he can jump. Our test is as follows:

Initially, ErnKor is on the left bank and needs to reach the right bank. They are located at the $0$ and $n+1$ meters respectively. The river can be represented as $n$ segments, each with a length of $1$ meter. Each segment contains either a log 'L', a crocodile 'C', or just water 'W'. ErnKor can move as follows:

  * If he is on the surface (i.e., on the bank or on a log), he can jump forward for no more than $m$ ($1 \le m \le 10$) meters (he can jump on the bank, on a log, or in the water).    * If he is in the water, he can only swim to the next river segment (or to the bank if he is at the $n$-th meter).    * ErnKor cannot land in a segment with a crocodile in any way.

Determine if ErnKor can reach the right bank.

Input: The first line contains a single integer $t$ ($1 \le t \le 10^4$)  — the number of test cases.

The first line of each test case contains three numbers $n, m, k$ ($0 \le k \le 2 \cdot 10^5$, $1 \le n \le 2 \cdot 10^5$, $1 \le m \le 10$) — the length of the river, the distance ErnKor can jump, and the number of meters ErnKor can swim without freezing.

The second line of each test case contains a string $a$ of length $n$. $a_i$ denotes the object located at the $i$-th meter. ($a_i \in \\{$'W','C','L'$\\}$)

It is guaranteed that the sum of $n$ over all test cases does not exceed $2 \cdot 10^5$.

Output: For each test case, output "YES" if ErnKor can pass the test, and output "NO" otherwise.

You can output the answer in any case (upper or lower). For example, the strings "yEs", "yes", "Yes", and "YES" will be recognized as positive responses.

Examples:
input:
6
6 2 0
LWLLLW
6 1 1
LWLLLL
6 1 1
LWLLWL
6 2 15
LWLLCC
6 10 0
CCCCCC
6 6 1
WCCCCW
output:
YES
YES
NO
NO
YES
YES

Note: Let's consider examples:

  * First example: We jump from the shore to the first log ($0 \rightarrow 1$), from the first log to the second ($1 \rightarrow 3$), from the second to the fourth ($3 \rightarrow 5$), and from the last log to the shore ($5 \rightarrow 7$). So, we have $0 \rightarrow 1 \rightarrow 3 \rightarrow 5 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * Second example: $0 \rightarrow 1$, we jump into the water from the first log ($1 \rightarrow 2$), swim a cell to the log ($2 \leadsto 3$), $3 \rightarrow 4 \rightarrow 5 \rightarrow 6 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * In the third example, ErnKor needs to swim two cells 'W', but can only swim one. Therefore, the answer is «NO».    * Sixth example: We jump from the shore into the water ($0 \rightarrow 6$) and swim one cell in the water ($6 \leadsto 7$). Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».

Buggy Code:
t = int(input())
for i in range(t):
    n, m, k = map(int, input().split())
    a = input()
    c_count = 0
    b = 0
    d = 0
    flags = False
    for j in a:
        if j == 'C':
            if flags:
                b += d
                d = 0
                flags = False
            b += 1
        elif j == 'W':
            d += 1
            flags = True
        else:
            if b > c_count:
                c_count = b
                b = 0
    if b > c_count:
        c_count = b
        b = 0
    if c_count >= m:
        print('NO')
        continue
    c = 0
    w_count = 0
    flags = False
    for j in a:
        if j == 'W' or j == 'C':
            c += 1
            flags = True
        else:
            if flags:
                w_count += c - m + 1
                c = 0
                flags = False
    w_count += c - m + 1
    c = 0
    if w_count > k:
        print('NO')
        continue
    print('YES')

**Instructions:**
- Focus on edge cases or scenarios that maximize the failure probability in faulty solutions.
- Due to the output length limit, you should generate a **small-scale** test input that is **complete and valid**.
- Output the test input directly, not code to generate it.

**Output format:**
```plaintext
{test input}
```

Think step by step.

Response:
```plaintext
1
10 2 2
LWWCWLWLWW
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Test of Love
time_limit_ms: 2000
memory_limit_mb: 256
Description: ErnKor is ready to do anything for Julen, even to swim through crocodile- infested swamps. We decided to test this love. ErnKor will have to swim across a river with a width of $1$ meter and a length of $n$ meters.

The river is very cold. Therefore, in total (that is, throughout the entire swim from $0$ to $n+1$) ErnKor can swim in the water for no more than $k$ meters. For the sake of humanity, we have added not only crocodiles to the river, but also logs on which he can jump. Our test is as follows:

Initially, ErnKor is on the left bank and needs to reach the right bank. They are located at the $0$ and $n+1$ meters respectively. The river can be represented as $n$ segments, each with a length of $1$ meter. Each segment contains either a log 'L', a crocodile 'C', or just water 'W'. ErnKor can move as follows:

  * If he is on the surface (i.e., on the bank or on a log), he can jump forward for no more than $m$ ($1 \le m \le 10$) meters (he can jump on the bank, on a log, or in the water).    * If he is in the water, he can only swim to the next river segment (or to the bank if he is at the $n$-th meter).    * ErnKor cannot land in a segment with a crocodile in any way.

Determine if ErnKor can reach the right bank.

Input: The first line contains a single integer $t$ ($1 \le t \le 10^4$)  — the number of test cases.

The first line of each test case contains three numbers $n, m, k$ ($0 \le k \le 2 \cdot 10^5$, $1 \le n \le 2 \cdot 10^5$, $1 \le m \le 10$) — the length of the river, the distance ErnKor can jump, and the number of meters ErnKor can swim without freezing.

The second line of each test case contains a string $a$ of length $n$. $a_i$ denotes the object located at the $i$-th meter. ($a_i \in \\{$'W','C','L'$\\}$)

It is guaranteed that the sum of $n$ over all test cases does not exceed $2 \cdot 10^5$.

Output: For each test case, output "YES" if ErnKor can pass the test, and output "NO" otherwise.

You can output the answer in any case (upper or lower). For example, the strings "yEs", "yes", "Yes", and "YES" will be recognized as positive responses.

Examples:
input:
6
6 2 0
LWLLLW
6 1 1
LWLLLL
6 1 1
LWLLWL
6 2 15
LWLLCC
6 10 0
CCCCCC
6 6 1
WCCCCW
output:
YES
YES
NO
NO
YES
YES

Note: Let's consider examples:

  * First example: We jump from the shore to the first log ($0 \rightarrow 1$), from the first log to the second ($1 \rightarrow 3$), from the second to the fourth ($3 \rightarrow 5$), and from the last log to the shore ($5 \rightarrow 7$). So, we have $0 \rightarrow 1 \rightarrow 3 \rightarrow 5 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * Second example: $0 \rightarrow 1$, we jump into the water from the first log ($1 \rightarrow 2$), swim a cell to the log ($2 \leadsto 3$), $3 \rightarrow 4 \rightarrow 5 \rightarrow 6 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * In the third example, ErnKor needs to swim two cells 'W', but can only swim one. Therefore, the answer is «NO».    * Sixth example: We jump from the shore into the water ($0 \rightarrow 6$) and swim one cell in the water ($6 \leadsto 7$). Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».

Buggy Code:
import java.util.Scanner;

public class Test_of_Love {

	public static void main(String[] args) {

		Scanner s=new Scanner(System.in);
		int t=Integer.parseInt(s.nextLine());

		while(t--!=0)
		{
			String[] str=s.nextLine().split(" ");
 			int n=Integer.parseInt(str[0])+1;
			int m=Integer.parseInt(str[1]);
			int k=Integer.parseInt(str[2]);

			String gh="L"+s.nextLine();
			int pos=0;

			while(pos<n) {

				if(gh.charAt(pos)=='L')
				{

//					System.out.println(1+" "+pos);
					int jump=m-1;
					pos++;
//					System.out.println(2+" "+pos);
					while(pos<n && gh.charAt(pos)=='C'&&jump>0) {

						pos++;
						jump--;
					}
//					System.out.println(3+" "+pos);
					if(pos<n&&gh.charAt(pos)!='L') {

						if(gh.charAt(pos)=='C')
						{
							break;
						}
						else if(gh.charAt(pos)=='W')
						{
//							System.out.println(4+" "+pos+" "+jump);
							while(pos<n && gh.charAt(pos)=='W'&&(jump>0||k>0))
							{

								pos++;
								if(jump>0)jump--;
								else k--;
								if(k<0)break;
							}
//							System.out.println(5+" "+pos+" "+jump);
							if(pos<n&&(k<=0&&jump<=0)&&gh.charAt(pos)!='L')break;

							while(pos<n && gh.charAt(pos)=='C' && jump>0) {

								pos++;
								jump--;
							}
							if(pos<n&& gh.charAt(pos)=='C')break;
//							System.out.println(6+" "+pos);
							while(pos<n && gh.charAt(pos)=='W')
							{

								pos++;
								if(jump>0)jump--;
								else k--;
								if(k<0)break;
							}
//							System.out.println(7+" "+pos+" "+jump);
							if(pos<n&&(k<0||gh.charAt(pos)=='C'))break;

						}

					}
				}
				else if(gh.charAt(pos)=='W')
				{
					if(k>0) {
						k--;
						pos++;

//						System.out.println('W'+" "+k+" "+pos);
					}
					else {
						break;
					}
				}
				else
				{
//					System.out.println("C");
					break;
				}
			}
			if(pos>=n)
			{
				System.out.println("YES");
			}
			else {
				System.out.println("NO");
			}

		}

	}

}

**Instructions:**
- Focus on edge cases or scenarios that maximize the failure probability in faulty solutions.
- Due to the output length limit, you should generate a **small-scale** test input that is **complete and valid**.
- Output the test input directly, not code to generate it.

**Output format:**
```plaintext
{test input}
```

Think step by step.

Response:
```plaintext
3
10 3 2
LWLCWLCWWL
5 1 0
LWLCW
7 2 1
LWLCWLC
```

3
10 3 2
LWLCWLCWWL
5 1 0
LWLCW
7 2 1
LWLCWLC


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Test of Love
time_limit_ms: 2000
memory_limit_mb: 256
Description: ErnKor is ready to do anything for Julen, even to swim through crocodile- infested swamps. We decided to test this love. ErnKor will have to swim across a river with a width of $1$ meter and a length of $n$ meters.

The river is very cold. Therefore, in total (that is, throughout the entire swim from $0$ to $n+1$) ErnKor can swim in the water for no more than $k$ meters. For the sake of humanity, we have added not only crocodiles to the river, but also logs on which he can jump. Our test is as follows:

Initially, ErnKor is on the left bank and needs to reach the right bank. They are located at the $0$ and $n+1$ meters respectively. The river can be represented as $n$ segments, each with a length of $1$ meter. Each segment contains either a log 'L', a crocodile 'C', or just water 'W'. ErnKor can move as follows:

  * If he is on the surface (i.e., on the bank or on a log), he can jump forward for no more than $m$ ($1 \le m \le 10$) meters (he can jump on the bank, on a log, or in the water).    * If he is in the water, he can only swim to the next river segment (or to the bank if he is at the $n$-th meter).    * ErnKor cannot land in a segment with a crocodile in any way.

Determine if ErnKor can reach the right bank.

Input: The first line contains a single integer $t$ ($1 \le t \le 10^4$)  — the number of test cases.

The first line of each test case contains three numbers $n, m, k$ ($0 \le k \le 2 \cdot 10^5$, $1 \le n \le 2 \cdot 10^5$, $1 \le m \le 10$) — the length of the river, the distance ErnKor can jump, and the number of meters ErnKor can swim without freezing.

The second line of each test case contains a string $a$ of length $n$. $a_i$ denotes the object located at the $i$-th meter. ($a_i \in \\{$'W','C','L'$\\}$)

It is guaranteed that the sum of $n$ over all test cases does not exceed $2 \cdot 10^5$.

Output: For each test case, output "YES" if ErnKor can pass the test, and output "NO" otherwise.

You can output the answer in any case (upper or lower). For example, the strings "yEs", "yes", "Yes", and "YES" will be recognized as positive responses.

Examples:
input:
6
6 2 0
LWLLLW
6 1 1
LWLLLL
6 1 1
LWLLWL
6 2 15
LWLLCC
6 10 0
CCCCCC
6 6 1
WCCCCW
output:
YES
YES
NO
NO
YES
YES

Note: Let's consider examples:

  * First example: We jump from the shore to the first log ($0 \rightarrow 1$), from the first log to the second ($1 \rightarrow 3$), from the second to the fourth ($3 \rightarrow 5$), and from the last log to the shore ($5 \rightarrow 7$). So, we have $0 \rightarrow 1 \rightarrow 3 \rightarrow 5 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * Second example: $0 \rightarrow 1$, we jump into the water from the first log ($1 \rightarrow 2$), swim a cell to the log ($2 \leadsto 3$), $3 \rightarrow 4 \rightarrow 5 \rightarrow 6 \rightarrow 7$. Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».    * In the third example, ErnKor needs to swim two cells 'W', but can only swim one. Therefore, the answer is «NO».    * Sixth example: We jump from the shore into the water ($0 \rightarrow 6$) and swim one cell in the water ($6 \leadsto 7$). Since we did not encounter a crocodile and swam no more than k meters, the answer is «YES».

Buggy Code:
import java.util.*;

public class RiverCrossing {
    public static boolean canCross(String s, int n, int m, int k) {
        // Queue to store the current position and the number of swims used so far
        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[]{-1, 0}); // Start from the left bank (-1 position) with 0 swims

        boolean[] visited = new boolean[n + 1]; // To keep track of visited positions
        visited[-1 + 1] = true; // Mark the starting position as visited

        while (!queue.isEmpty()) {
            int[] current = queue.poll();
            int pos = current[0];
            int swims = current[1];

            // Try all possible jumps from the current position
            for (int jump = 1; jump <= m; jump++) {
                int newPos = pos + jump;

                // If the new position is beyond the right bank
                if (newPos >= n) {
                    return true;
                }

                // If the new position is a crocodile, skip it
                if (s.charAt(newPos) == 'C') {
                    continue;
                }

                // If the new position is water, check the swim limit
                if (s.charAt(newPos) == 'W' && swims + 1 > k) {
                    continue;
                }

                // If the new position is a log or water within swim limit
                if (!visited[newPos + 1]) {
                    queue.add(new int[]{newPos, s.charAt(newPos) == 'W' ? swims + 1 : swims});
                    visited[newPos + 1] = true;
                }
            }
        }

        return false; // If no path found
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int t = scanner.nextInt();
        while (t-- > 0) {
            int n = scanner.nextInt();
            int m = scanner.nextInt();
            int k = scanner.nextInt();
            scanner.nextLine(); // Consume the newline character
            String s = scanner.nextLine();

            boolean result = canCross(s, n, m, k);
            System.out.println(result ? "YES" : "NO");
        }
        scanner.close();
    }
}

**Instructions:**
- Focus on edge cases or scenarios that maximize the failure probability in faulty solutions.
- Due to the output length limit, you should generate a **small-scale** test input that is **complete and valid**.
- Output the test input directly, not code to generate it.

**Output format:**
```plaintext
{test input}
```

Think step by step.

Response:
```plaintext
1
10 2 1
LWCCCCCCCC
```