There are n lanterns in a row. The lantern i is placed in position i and has power equal to p_i.

Each lantern can be directed to illuminate either some lanterns to the left or some lanterns to the right. If the i-th lantern is turned to the left, it illuminates all such lanterns j that j ∈ [i - p_i, i - 1]. Similarly, if it is turned to the right, it illuminates all such lanterns j that j ∈ [i + 1, i + p_i].

Your goal is to choose a direction for each lantern so each lantern is illuminated by at least one other lantern, or report that it is impossible.

Input

The first line contains one integer t (1 ≤ t ≤ 10000) — the number of test cases.

Each test case consists of two lines. The first line contains one integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of lanterns.

The second line contains n integers p_1, p_2, ..., p_n (0 ≤ p_i ≤ n) — the power of the i-th lantern.

The sum of n over all test cases does not exceed 3 ⋅ 10^5.

Output

For each test case, print the answer as follows:

If it is possible to direct all lanterns so that each lantern is illuminated, print YES in the first line and a string of n characters L and/or R (the i-th character is L if the i-th lantern is turned to the left, otherwise this character is R) in the second line. If there are multiple answers, you may print any of them.

If there is no answer, simply print NO for that test case.

Example

Input


4
8
0 0 3 1 1 1 1 2
2
1 1
2
2 2
2
0 1


Output


YES
RRLLLLRL
YES
RL
YES
RL
NO
/*
This Qstn is a dp qstn like u can figure it out but it has O(n^2) time 
In order to pass u need to do it in O(nlogn) 
So let me write the thought process for the O(n^2) naive dp nd then how to go for O(nlogn)

So if u are trying to build the answer for 0 to n-1 then it's obvious that the
first one will face right nd last one left
Now if first one is facing left and covers from 1 to i then somebody has to cover first 
let it be jth index lamp, in doing so it will cover all lamps from 0 to j-1 then all the lamps from 
0 to j-1 have to be placed right facing bcz it's pointless to face left

So on similar grounds u can build up ur answer like this 
try to calculate dp[i] -> the max prefix which can be completely covered by the first i people 
so when u are calculating it for first i then it's sure that ith one being last will facr left
Try to streamlin ur thought preocess into max prefix thing using first i otherwise 
u will end up in trap.

So u try to go over all the lamps to the left and find the one with dp[j]>=i-p[i]-1 then 
nd all of them in btwn must face right so dp[i]=max(dp[i-1],for each j max of right in btwn);
Now for 2nd part in dp it makes sense to find out the leftmost j satisfying it bcz it 
increases the overall domain for maximising right for in btwn 

So this can be done using a min segment tree
Like we can store dp[i] as index nd value as i so when we try to find greater than values than some 
point it has all the dp[j]'s satisfying it nd the leftmost j as the 2nd part 
nd also for the in btwn one's u can use a max segment tree 

So basically this Pblm is mix of segment trees and Dp

Also try to build segment tree using class or struct instead of creating 3 or more segment trees 
Nd instead of writing segment tree code maintian some library for it(can save few minutes)
*/

#include<bits/stdc++.h>
using namespace std;
#define ll int

ll a[300005];
ll p[300005];
ll dp[300005];
ll stmx[1200505];
ll stmn[1200505];
ll lt[300005];
ll rt[300005];

void updmx(ll node,ll l,ll r,ll indx,ll val){
    if(l>r || l>indx || r<indx){
        return;
    }
    if(l==r){
        stmx[node]=val;
        return;
    }
    ll mid=(l+r)/2;
    updmx(2*node+1,l,mid,indx,val);
    updmx(2*node+2,mid+1,r,indx,val);
    stmx[node]=max(stmx[2*node+1],stmx[2*node+2]);
}

ll querymx(ll node,ll l,ll r,ll ql,ll qr){
    if(l>r || l>qr || r<ql){
        return -5;
    }
    if(l>=ql && r<=qr){
        return stmx[node];
    }
    ll mid=(l+r)/2;
    return max(querymx(2*node+1,l,mid,ql,qr),querymx(2*node+2,mid+1,r,ql,qr));
}

void updmn(ll node,ll l,ll r,ll indx,ll val){
    if(l>r || l>indx || r<indx){
        return;
    }
    if(l==r){
        stmn[node]=min(val,stmn[node]);
        return;
    }
    ll mid=(l+r)/2;
    updmn(2*node+1,l,mid,indx,val);
    updmn(2*node+2,mid+1,r,indx,val);
    stmn[node]=min(stmn[2*node+1],stmn[2*node+2]);
}

ll querymn(ll node,ll l,ll r,ll ql,ll qr){
    if(l>r || l>qr || r<ql){
        return (ll)1e6;
    }
    if(l>=ql && r<=qr){
        return stmn[node];
    }
    ll mid=(l+r)/2;
    return min(querymn(2*node+1,l,mid,ql,qr),querymn(2*node+2,mid+1,r,ql,qr));
}

int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(NULL);
    cout.tie(NULL);
    
    ll t;
    cin>>t;
    
    while(t--){
        ll n;
        cin>>n;
        
        for(ll i=0;i<=4*n+5;i++){
            stmx[i]=-5;
            stmn[i]=(ll)1e6;
        }
        
        for(ll i=0;i<n;i++){
            cin>>a[i];
            dp[i]=0;
            p[i]=0;
            lt[i]=max(i-a[i],0);
            rt[i]=min(i+a[i],n-1);
            updmx(0,0,n-1,i,rt[i]);
        }
        
        // dp[i] is max prefix using first i elements
        updmn(0,0,n,0,-1);
        for(ll i=0;i<n;i++){
            ll indxj=querymn(0,0,n,lt[i],n);
            if(indxj<i){
                //cout<<indxj<<"\n";
                dp[i]=max(querymx(0,0,n-1,indxj+1,i-1),i-1)+1;
                p[i]=((indxj==-1)?0:indxj);
            }
            // if previously i is being covered from i-1 elements 
            // then u can just try to increase the previous prefix i.e dp[i-1]
            // by turning ith lamp to the right
            if(i-1>=0 && dp[i-1]>=i+1 && dp[i]<max(rt[i]+1,dp[i-1])){
                dp[i]=max(rt[i]+1,dp[i-1]);
                p[i]=-1;
            }
            
            if(i-1>=0 && dp[i-1]>dp[i]){
                dp[i]=dp[i-1];
                p[i]=-1;
            }
            //cout<<i<<"->"<<dp[i]<<" "<<p[i]<<"\n";
            updmn(0,0,n,dp[i],i);
        }
        
        if(dp[n-1]<n){
            cout<<"NO"<<"\n";
            continue;
        }
        
        cout<<"YES"<<"\n";
        // rebuild the answer, it must be done from end bcz
        // dng it from front the moves are not deterministic
        // but from back u will have exact idea to which index to move next
        string ans;
        ll indx=n-1;
        while(indx!=0){
            //cout<<indx<<" "<<p[indx]<<"\n";
            if(p[indx]==-1){
                ans+="R";
                indx--;
            }
            else{
                ans+="L";
                for(ll j=indx-1;j>p[indx];j--){
                    ans+="R";
                }
                indx=p[indx];
            }
        }
        ans+="R";
        reverse(ans.begin(),ans.end());
        cout<<ans<<"\n";
    }
}