#include <iostream>
#include <set>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <stack>
#include <vector>
#include <queue>

using namespace std;

#define INF 999999
#define pb push_back
#define mp make_pair

typedef pair<int, int> pi;




const int MAXV = 50005, MAXE = 10500000, oo = (1 << 25);
int E, last[MAXV], nextssss[MAXE], adj[MAXE], level[MAXV], now[MAXV], Q[MAXV], source, sink;
int cap[MAXE], flow[MAXE];


void add_edge (int u, int v, int c)
{

    cap[E] = c, flow[E] = 0, adj[E] = v, nextssss[E] = last[u], last[u] = E++;
    cap[E] =0, flow[E] = 0, adj[E] = u, nextssss[E] = last[v], last[v] = E++;
}

#define RES(e)  (cap[e] - flow[e])

bool bfs (int s, int t)
{
    memset(level, -1, sizeof level);
    level[s] = 0;
    Q[0] = s;

    for (int ql = 0, qr = 1; ql < qr && level[t] == - 1; ++ql)
    {
        int u = Q[ql];

        for (int e = last[u]; e != -1; e = nextssss[e])
        {
            int v = adj[e];

            if (level[v] == -1 && RES(e) > 0)
            {
                level[v] = level[u] + 1;
                Q[qr++] = v;
            }
        }
    }

    return level[t] != -1;
}

int dfs (int u, int curr)
{
    if (u == sink)
        return curr;

    for (int e = now[u]; e != -1; now[u] = e = nextssss[e])
    {
        int v = adj[e];

        if (level[v] == level[u] + 1 && RES(e) > 0)
        {
            int ans = dfs(v, min(curr, RES(e)));

            if (ans > 0)
            {
                flow[e] += ans;
                flow[e ^ 1] -= ans;
                return ans;
            }
        }
    }

    return 0;
}

int max_flow ()
{
    int ans = 0, res;

    while (bfs(source, sink))
    {
        memcpy(now, last, sizeof now);

        while ((res = dfs(source, oo)) > 0)
            ans += res;
    }

    return ans;
}

int T;
int A[5000], B[5000];
int na, nb;
int m;

int flow_a(){

    source = 1999;
    sink = 2000;


    E = 0;
    memset(last, -1, sizeof last);

    for(int i = 0 ; i < m; i++){
        add_edge(601+i, sink, 1);
    //    add_edge(sink, 601+i, 1);
    }

    for(int i = na - 1, j = 0; i >= 0; i--, j++){

        if(j < m){
            add_edge(source, 1 + i, 1);
         //   add_edge(1+i, source, 1);
        }

        for(int k = 0; k < nb; k++){
            int diff = abs(A[i] - B[k]);

            if(diff < T){
                add_edge(1+i, 601 + k, 1);
                add_edge(601+k, 1+i, 1);
            }
        }

    }

    return max_flow();
}

int flow_b(){

    source = 0;
    sink = 2000;

    E = 0;
    memset(last, -1, sizeof last);

    for(int i = 0 ; i < m; i++){
        add_edge(601+i, sink, 1);
      //  add_edge(sink, 601+i, 1);
    }

    for(int i = nb - 1, j = 0; i >= 0; i--, j++){

        if(j < m){
            add_edge(source, 1 + i, 1);
        //    add_edge(1+i, source, 1);
        }

        for(int k = 0; k < na; k++){
            int diff = abs(B[i] - A[k]);

            if(diff < T){
                add_edge(1+i, 601 + k, 1);
                add_edge(601+k, 1+i, 1);
            }
        }

    }

    return max_flow();
}


int main()
{

    scanf("%d %d %d %d", &m, &na, &nb, &T);

    for(int i = 0 ; i < na; i++)
        scanf("%d", &A[i]);

    for(int i = 0; i < nb; i++)
        scanf("%d", &B[i]);

    sort(A, A+na);
    sort(B, B+nb);

    if( flow_a() == m || flow_b() == m)
        printf("S\n");
    else
        printf("N\n");

    return 0;
}