#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("unroll-loops")
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define int long long
#define fr(i,a,b) for(int i = a ; i <= b ; ++i)
#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define trav(a, x) for(auto& a : x)
#define all(x) begin(x), end(x)
#define rall(x) (x).rbegin(), (x).rend()
#define sz(x) (int)(x).size()
#define pb push_back
#define fst first
#define snd second
using namespace __gnu_pbds;
using ordered_set =
 tree<int, null_type,less<int>,
 rb_tree_tag,tree_order_statistics_node_update>;
//find_by_order(k):returns iterator to kth element starting from 0
//order_of_key(k):returns count of elements strictly smaller than k
typedef long long ll;typedef pair<int, int> pii;
typedef vector<int> vi;typedef long double ld;
template<class T>
using min_heap = priority_queue<T,vector<T>,greater<T>>;
template<typename T> T gcd(T a, T b){return(b?__gcd(a,b):a);}
template<typename T> T lcm(T a, T b){return(a*(b/gcd(a,b)));}
template<class T> void re(T& x) { cin >> x; }
template<typename T>
void remdup(vector<T>& v) {
	sort(all(v)); v.erase(unique(all(v)), v.end());
}
template<typename T> void re(vector<T> &v) {trav(i,v) cin >> i;}
template<class H, class... T> void re(H& h, T&... t) { re(h); re(t...); }
void unsyncIO() { ios_base::sync_with_stdio(0); cin.tie(0); }
#ifdef np
#include "/home/wjex/cp/pr.h"
#else
#define trace(...)
#endif

constexpr int MOD = 1000000007;
constexpr int Nx = 7010; // check

void pre(){

}

// ref : https://codeforces.com/blog/entry/51163?#comment-350712

int n;
int dp[2][Nx+1]; // player id , current idx  -> 2*n states
int deg[2][Nx+1];
vi g[2];  // g[i] set of i-th person
vi se ;// #options

int fix(int pos){
	if(pos<0) pos+=n;
	return pos;
}

void bfs(int a, int b){
	queue<pii> q ;
	q.push({a,b});
	while(sz(q)){
		auto [player , idx] = q.front();
		//trace(player,idx);
		q.pop();
		if(dp[player][idx] == 0){ // losing state for curplayer
			for(auto it : g[1^player]){ // process of other player after we fix our state
				int curidx = fix(idx- it);
				//fix(curidx);
				//trace(player,curidx);
				if(dp[1^player][curidx] == -1){ // currently unmarked negihbours
						dp[1^player][curidx] = 1 ;
						q.push({1^player,curidx});
					}
			}
		}
		else{ // current player is winning
			for(auto it : g[1^player]){ // process of other player after we fix our state
					int curidx = fix(idx- it);
					//fix(curidx);
					//trace(curidx);
					if(dp[1^player][curidx] == -1){ // currently unmarked negihbours
						deg[1^player][curidx]++ ; // cnt of other neighbours , everystep wins for us
						if(deg[1^player][curidx] == se[1^player]){
							dp[1^player][curidx] = 0 ;
							q.push({1^player,curidx});
						}
				}
			}
		}
	}
}

void solve(){
	re(n) ;
	rep(i,0,2){
		int x ;
		re(x);
		se.pb(x);
		rep(j,0,x){
			int v ;
			re(v) ;
			g[i].pb(v);
		}
	}
	memset(dp,-1,sizeof dp);
	dp[0][0]=dp[1][0] = 0;
	bfs(0,0); // p1
	bfs(1,0); // p2
	rep(i,0,2){
		rep(j,1,n){
			//trace(dp[i][j]);
			if(dp[i][j]==1) cout << "Win ";
			if(dp[i][j]==0) cout << "Lose ";
			if(dp[i][j]==-1) cout << "Loop ";
		}
		cout << endl;
	}
}

signed main() {
	unsyncIO();
	int tt =1 ;
	//cin >> tt;
	rep(i,0,tt) solve();

#ifdef np
	cout <<endl<<endl<< "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("unroll-loops")
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define int long long
#define fr(i,a,b) for(int i = a ; i <= b ; ++i)
#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define trav(a, x) for(auto& a : x)
#define all(x) begin(x), end(x)
#define rall(x) (x).rbegin(), (x).rend()
#define sz(x) (int)(x).size()
#define pb push_back
#define fst first
#define snd second
using namespace __gnu_pbds;
using ordered_set =
 tree<int, null_type,less<int>,
 rb_tree_tag,tree_order_statistics_node_update>;
//find_by_order(k):returns iterator to kth element starting from 0
//order_of_key(k):returns count of elements strictly smaller than k
typedef long long ll;typedef pair<int, int> pii;
typedef vector<int> vi;typedef long double ld;
template<class T>
using min_heap = priority_queue<T,vector<T>,greater<T>>;
template<typename T> T gcd(T a, T b){return(b?__gcd(a,b):a);}
template<typename T> T lcm(T a, T b){return(a*(b/gcd(a,b)));}
template<class T> void re(T& x) { cin >> x; }
template<typename T>
void remdup(vector<T>& v) {
	sort(all(v)); v.erase(unique(all(v)), v.end());
}
template<typename T> void re(vector<T> &v) {trav(i,v) cin >> i;}
template<class H, class... T> void re(H& h, T&... t) { re(h); re(t...); }
void unsyncIO() { ios_base::sync_with_stdio(0); cin.tie(0); }
#ifdef np
#include "/home/wjex/cp/pr.h"
#else
#define trace(...)
#endif

constexpr int MOD = 1000000007;
constexpr int Nx = 7010; // check

void pre(){

}

// ref : https://codeforces.com/blog/entry/51163?#comment-350712

int n;
int dp[2][Nx+1]; // player id , current idx  -> 2*n states
int deg[2][Nx+1];
vi g[2];  // g[i] set of i-th person

int fix(int pos){
	if(pos<0) pos+=n;
	return pos;
}

void solve(){
	re(n) ;
	vi se ;// #options
	rep(i,0,2){
		int x ;
		re(x);
		se.pb(x);
		rep(j,0,x){
			int v ;
			re(v) ;
			g[i].pb(v);
		}
	}
	memset(dp,-1,sizeof dp);
	dp[0][0]=dp[1][0] = 0;
	queue<pii> q ;
	q.push({0,0});
	q.push({1,0});
	while(sz(q)){
		auto [player , idx] = q.front();
		//trace(player,idx);
		q.pop();
		if(dp[player][idx] == 0){ // losing state for curplayer
			for(auto it : g[1^player]){ // process of other player after we fix our state
				int curidx = fix(idx- it);
				//fix(curidx);
				//trace(player,curidx);
				if(dp[1^player][curidx] == -1){ // currently unmarked negihbours
						dp[1^player][curidx] = 1 ;
						q.push({1^player,curidx});
					}
			}
		}
		else{ // current player is winning
			for(auto it : g[1^player]){ // process of other player after we fix our state
					int curidx = fix(idx- it);
					//fix(curidx);
					//trace(curidx);
					if(dp[1^player][curidx] == -1){ // currently unmarked negihbours
						deg[1^player][curidx]++ ; // cnt of other neighbours , everystep wins for us
						if(deg[1^player][curidx] == se[1^player]){
							dp[1^player][curidx] = 0 ;
							q.push({1^player,curidx});
						}
				}
			}
		}
	}
	rep(i,0,2){
		rep(j,1,n){
			//trace(dp[i][j]);
			if(dp[i][j]==1) cout << "Win ";
			if(dp[i][j]==0) cout << "Lose ";
			if(dp[i][j]==-1) cout << "Loop ";
		}
		cout << endl;
	}
}

signed main() {
	unsyncIO();
	int tt =1 ;
	//cin >> tt;
	rep(i,0,tt) solve();

#ifdef np
	cout <<endl<<endl<< "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
	return 0;
}


#include <ctime>
#include <cstdio>
#include <algorithm>
#include <ctime>
#include <iostream>
#include <queue>
#include <bitset>
#include <string>
#include <cstring>
using namespace std;
const int N = 1e5;
int n;
vector<int>g[2];
bool vis[N][2], is_win[N][2];
int deg[N][2];
queue<pair<int, bool> >q;
int main() {
    scanf("%d", &n);
    int k;
    scanf("%d", &k);
    while (k -- ){
        int x;
        scanf("%d", &x);
        g[0].push_back(x);
    }
    scanf("%d", &k);
    while (k -- ){
        int x;
        scanf("%d", &x);
        g[1].push_back(x);
    }
    for (int i = 1; i < n; i ++)
        deg[i][0] = g[0].size(), deg[i][1] = g[1].size();
    q.push(make_pair(n, 0));
    q.push(make_pair(n, 1));
    while (!q.empty()) {
        pair<int, bool> u = q.front();
        q.pop();
        for (auto v: g[!u.second])
        {
            int x = (u.first - v + n) % n;
            if (!x) continue;
            if (!is_win[u.first][u.second] && !vis[x][!u.second]) {
                is_win[x][!u.second] = 1;
                q.push(make_pair(x, !u.second));
                vis[x][!u.second] = 1;
            }  else
                if (!(--deg[x][!u.second]) && !vis[x][!u.second])
                    q.push(make_pair(x, !u.second)),vis[x][!u.second] = 1;
        }
    }
    for (int sig = 0; sig < 2; sig ++) {
        for (int i = 1; i <n; i++)
        {
            if (is_win[i][sig])
                printf("Win ");
            else
                if (vis[i][sig])
                    printf("Lose ");
                else
                    printf("Loop ");
        }
        printf("\n");
    }
    return 0;
}


#include <ctime>
#include <cstdio>
#include <algorithm>
#include <ctime>
#include <iostream>
#include <queue>
#include <bitset>
#include <string>
#include <cstring>
using namespace std;
const int N = 1e5;
int n;
vector<int>g[2];
bool vis[N][2], is_win[N][2], in_queue[N][2];
int deg[N][2];
queue<pair<int, bool> >q;
int main() {
    scanf("%d", &n);
    int k;
    scanf("%d", &k);
    while (k -- ){
        int x;
        scanf("%d", &x);
        g[0].push_back(x);
    }
    scanf("%d", &k);
    while (k -- ){
        int x;
        scanf("%d", &x);
        g[1].push_back(x);
    }
    for (int i = 1; i < n; i ++)
        deg[i][0] = g[0].size(), deg[i][1] = g[1].size();
    q.push(make_pair(n, 0));
    q.push(make_pair(n, 1));
    while (!q.empty()) {
        pair<int, bool> u = q.front();
        q.pop();
        for (auto v: g[!u.second])
        {
            int x = (u.first - v + n) % n;
            if (!x) continue;
            if (!is_win[u.first][u.second]) {
                is_win[x][!u.second] = 1;
                q.push(make_pair(x, !u.second));
                in_queue[x][!u.second] = 1;
                vis[x][!u.second] = 1;
            }
            if (!(--deg[x][!u.second]) && ! in_queue[x][!u.second])
                q.push(make_pair(x, !u.second)), in_queue[x][!u.second] = 1,vis[x][!u.second] = 1;
        }
    }
    for (int sig = 0; sig < 2; sig ++) {
        for (int i = 1; i <n; i++)
        {
            if (is_win[i][sig])
                printf("Win ");
            else
                if (vis[i][sig])
                    printf("Lose ");
                else
                    printf("Loop ");
        }
        printf("\n");
    }
    return 0;
}


#include <ctime>
#include <cstdio>
#include <algorithm>
#include <ctime>
#include <iostream>
#include <queue>
#include <bitset>
#include <string>
#include <cstring>
using namespace std;
const int N = 1e5;
int n;
vector<int>g[2];
bool vis[N][2], is_win[N][2], in_queue[N][2];
int deg[N][2];
queue<pair<int, bool> >q;
int main() {
    scanf("%d", &n);
    int k;
    scanf("%d", &k);
    while (k -- ){
        int x;
        scanf("%d", &x);
        g[0].push_back(x);
    }
    scanf("%d", &k);
    while (k -- ){
        int x;
        scanf("%d", &x);
        g[1].push_back(x);
    }
    for (int i = 1; i < n; i ++)
        deg[i][0] = g[0].size(), deg[i][1] = g[1].size();
    q.push(make_pair(n, 0));
    q.push(make_pair(n, 1));
    while (!q.empty()) {
        pair<int, bool> u = q.front();
        q.pop();
        for (auto v: g[!u.second])
        {
            int x = (u.first - v + n) % n;
            if (!x) continue;
            vis[x][!u.second] = 1;
            if (!is_win[u.first][u.second]) {
                is_win[x][!u.second] = 1;
                q.push(make_pair(x, !u.second));
                in_queue[x][!u.second] = 1;
            }
            if (!(--deg[x][!u.second]) && ! in_queue[x][!u.second])
                q.push(make_pair(x, !u.second)), in_queue[x][!u.second] = 1;
        }
    }
    for (int sig = 0; sig < 2; sig ++) {
        for (int i = 1; i <n; i++)
        {
            if (is_win[i][sig])
                printf("Win ");
            else
                if (vis[i][sig])
                    printf("Lose ");
                else
                    printf("Loop ");
        }
        printf("\n");
    }
    return 0;
}


#include <bits/stdc++.h>

using namespace std;

#define _ ios_base::sync_with_stdio(0);cin.tie(0);
#define endl '\n'
#define f first
#define s second
#define pb push_back

typedef long long ll;
typedef pair<int, int> ii;

const int INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3fll;

int ent[7010][2];
int dp[7010][2];
int K[2];
vector<int> v, w;
int n;
bool flag = true;
void solve(int p, int at, int prev){
	if(dp[p][at]!=-1) return;
	if(p==0 and !flag) return;
	if(prev==0) {
		dp[p][at] = 1;
		if(at==1){ for(auto k : v) solve((p-k+n)%n, !at, 1);}
		else{ for(auto k : w) solve((p-k+n)%n, !at, 1);}
		return;
	}
	ent[p][at]++;

	if(ent[p][at]==K[at] or flag){
		flag = false;
		dp[p][at]=0;
		if(at==1){ for(auto k : v) solve((p-k+n)%n, !at, 0);}
		else{ for(auto k : w) solve((p-k+n)%n, !at, 0);}
	}
	return;
}

int main(){ _
	memset(dp, -1, sizeof(dp));
	memset(ent, 0, sizeof(ent));
	cin >> n;
	int k; cin >> k; K[0]=k;
	for(int i=0;i <k; i++){int a; cin >> a; v.pb(a);}
	cin >> k; K[1]=k;
	for(int i=0;i <k; i++){int a; cin >> a; w.pb(a);}

	solve(0, 1, 1);
	flag = true;
	solve(0, 0, 1);

	for(int i=1; i<n; i++){
		int a = dp[i][0];
		if(a==-1) cout << "Loop ";
		else if(a==0) cout << "Lose ";
		else cout << "Win ";
	}
	cout << endl;
	for(int i=1; i<n; i++){
		int a = dp[i][1];
		if(a==-1) cout << "Loop ";
		else if(a==0) cout << "Lose ";
		else cout << "Win ";
	}
	cout << endl;

	exit(0);
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define Foreach(i, c) for(__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define For(i,a,b) for(int (i)=(a);(i) < (b); ++(i))
#define rof(i,a,b) for(int (i)=(a);(i) > (b); --(i))
#define rep(i, c) for(auto &(i) : (c))
#define x first
#define y second
#define pb push_back
#define PB pop_back()
#define iOS ios_base::sync_with_stdio(false)
#define sqr(a) (((a) * (a)))
#define all(a) a.begin() , a.end()
#define error(x) cerr << #x << " = " << (x) <<endl
#define Error(a,b) cerr<<"( "<<#a<<" , "<<#b<<" ) = ( "<<(a)<<" , "<<(b)<<" )\n";
#define errop(a) cerr<<#a<<" = ( "<<((a).x)<<" , "<<((a).y)<<" )\n";
#define coud(a,b) cout<<fixed << setprecision((b)) << (a)
#define L(x) ((x)<<1)
#define R(x) (((x)<<1)+1)
#define umap unordered_map
#define double long double
typedef long long ll;
typedef pair<int,int>pii;
typedef vector<int> vi;
typedef complex<double> point;
template <typename T> using os =  tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template <class T>  inline void smax(T &x,T y){ x = max((x), (y));}
template <class T>  inline void smin(T &x,T y){ x = min((x), (y));}
const int maxn = 7000 + 10;
int n;
int mod(int x){
	while(x >= n)	x -= n;
	return x;
}
vi v[2];
int dp[maxn][2], deg[maxn][2]; // 1 for WIN and 2 for LOSE
void go(int i, int j){
	int op = !j;
	rep(x, v[op]){
		int p = mod(i + n - x);
		if(dp[p][op])	continue ;
		if(dp[i][j] == 1){
			-- deg[p][op];
			if(!deg[p][op]){
				dp[p][op] = 2;
				go(p, op);
			}
		}
		else{
			dp[p][op] = 1;
			go(p, op);
		}
	}
}
int main(){
	iOS;
	cin >> n;
	For(i,0,2){
		int k;
		cin >> k;
		while(k--){
			int a;
			cin >> a;
			v[i].pb(a);
		}
	}
	For(i,0,n)
		For(j,0,2)	deg[i][j] = (int)v[j].size();
	dp[0][0] = dp[0][1] = 2;
	go(0, 0);
	go(0, 1);
	For(j,0,2)
		For(i,1,n)
			cout << (dp[i][j]? dp[i][j] == 1? "Win": "Lose": "Loop") << " \n"[i + 1 == n];
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

class Analysis
{
private:

    int n;
    vector< vector<short> > g;
    vector<char> state;
    vector<char> used;
    vector<short> degree;

    void dfs (int v)
    {
        used[v] = true;
        for(auto x : g[v])
        {
            if(!used[x])
            {
                if(state[v] == -1)
                    state[x] = 1;
                else if(--degree[x] == 0)
                    state[x] = -1;
                else
                    continue;
                dfs(x);
            }
        }
    }
public:
    Analysis(int n)
        : n(n), g(n), state(n), used(n), degree(n) {}

    void addEdge(int u, int v)
    {
        g[v].push_back(u);
        degree[u]++;
    }

    void addState(int x, bool f)
    {
        if(f)
            state[x] = 1;
        else
            state[x] = -1;
    }

    vector<char> solve()
    {
        for(int i = 0; i < n; i++)
        {
            if(!used[i] && state[i])
            {
                dfs(i);
            }
        }
        return state;
    }
};
int n, k1, k2, x;
int main()
{
    ios_base::sync_with_stdio(0);
    cin >> n;
    cin >> k1;
    Analysis a(2 * n);
    for(int i = 0; i < k1; i++)
    {
        cin >> x;
        for(int i = 1; i < n; i++)
        {
            a.addEdge(i * 2, ((i + x + n) % n) * 2 + 1);
        }
    }
    cin >> k2;
    for(int i = 0; i < k2; i++)
    {
        cin >> x;
        for(int i = 1; i < n; i++)
        {
            a.addEdge(i * 2 + 1, ((i + x + n) % n) * 2);
        }
    }
    a.addState(0, 0);
    a.addState(1, 0);
    vector<char> sol = a.solve();
    for(int i = 2; i < 2 * n; i++)
    {
        if(i % 2 == 0)
        {
            if(sol[i] == -1)
                cout << "Lose ";
            else if(sol[i] == 0)
                cout << "Loop ";
            else
                cout << "Win ";
        }
    }
    cout << "\n";
    for(int i = 2; i < 2 * n; i++)
    {
        if(i % 2 == 1)
        {
            if(sol[i] == -1)
                cout << "Lose ";
            else if(sol[i] == 0)
                cout << "Loop ";
            else
                cout << "Win ";
        }
    }
    cout << "\n";
    return 0;
}


#include <bits/stdc++.h>

using namespace std;

class Analysis
{
private:

    int n;
    vector< vector<int> > g;
    vector<char> state;
    vector<char> used;
    vector<int> degree;

    void dfs (int v)
    {
        used[v] = true;
        for(auto x : g[v])
        {
            if(!used[x])
            {
                if(state[v] == -1)
                    state[x] = 1;
                else if(--degree[x] == 0)
                    state[x] = -1;
                else
                    continue;
                dfs(x);
            }
        }
    }
public:
    Analysis(int n)
        : n(n), g(n), state(n), used(n), degree(n) {}

    void addEdge(int u, int v)
    {
        g[v].push_back(u);
        degree[u]++;
    }

    void addState(int x, bool f)
    {
        if(f)
            state[x] = 1;
        else
            state[x] = -1;
    }

    vector<char> solve()
    {
        for(int i = 0; i < n; i++)
        {
            if(!used[i] && state[i])
            {
                dfs(i);
            }
        }
        return state;
    }
};
int n, k1, k2, x;
int main()
{
    ios_base::sync_with_stdio(0);
    cin >> n;
    cin >> k1;
    Analysis a(2 * n);
    for(int i = 0; i < k1; i++)
    {
        cin >> x;
        for(int i = 1; i < n; i++)
        {
            a.addEdge(i * 2, ((i + x + n) % n) * 2 + 1);
        }
    }
    cin >> k2;
    for(int i = 0; i < k2; i++)
    {
        cin >> x;
        for(int i = 1; i < n; i++)
        {
            a.addEdge(i * 2 + 1, ((i + x + n) % n) * 2);
        }
    }
    a.addState(0, 0);
    a.addState(1, 0);
    vector<char> sol = a.solve();
    for(int i = 2; i < 2 * n; i++)
    {
        if(i % 2 == 0)
        {
            if(sol[i] == -1)
                cout << "Lose ";
            else if(sol[i] == 0)
                cout << "Loop ";
            else
                cout << "Win ";
        }
    }
    cout << "\n";
    for(int i = 2; i < 2 * n; i++)
    {
        if(i % 2 == 1)
        {
            if(sol[i] == -1)
                cout << "Lose ";
            else if(sol[i] == 0)
                cout << "Loop ";
            else
                cout << "Win ";
        }
    }
    cout << "\n";
    return 0;
}


#include <bits/stdc++.h>

using namespace std;

class Analysis
{
private:

    int n;
    vector< vector<int> > g;
    vector<char> state;
    vector<char> used;
    vector<int> degree;

    void dfs (int v)
    {
        used[v] = true;
        for(auto x : g[v])
        {
            if(!used[x])
            {
                if(state[v] == -1)
                    state[x] = 1;
                else if(--degree[x] == 0)
                    state[x] = -1;
                else
                    continue;
                dfs(x);
            }
        }
    }
public:
    Analysis(int n)
        : n(n), g(n), state(n), used(n), degree(n) {}

    void addEdge(int u, int v)
    {
        g[v].push_back(u);
        degree[u]++;
    }

    void addState(int x, bool f)
    {
        if(f)
            state[x] = 1;
        else
            state[x] = -1;
    }

    vector<char> solve()
    {
        for(int i = 0; i < n; i++)
        {
            if(!used[i] && state[i])
            {
                dfs(i);
            }
        }
        return state;
    }
};

int n, k1, k2, x;
int main()
{
    ios_base::sync_with_stdio(0);
    cin >> n;
    cin >> k1;
    Analysis a(2 * n);
    for(int i = 0; i < k1; i++)
    {
        cin >> x;
        for(int i = 1; i < n; i++)
        {
            a.addEdge(i * 2, ((i + x + n) % n) * 2 + 1);
        }
    }
    cin >> k2;
    for(int i = 0; i < k2; i++)
    {
        cin >> x;
        for(int i = 1; i < n; i++)
        {
            a.addEdge(i * 2 + 1, ((i + x + n) % n) * 2);
        }
    }
    a.addState(0, 0);
    a.addState(1, 0);
    vector<char> sol = a.solve();
    for(int i = 2; i < 2 * n; i++)
    {
        if(i % 2 == 0)
        {
            if(sol[i] == -1)
                cout << "Lose ";
            else if(sol[i] == 0)
                cout << "Loop ";
            else
                cout << "Win ";
        }
    }
    cout << "\n";
    for(int i = 2; i < 2 * n; i++)
    {
        if(i % 2 == 1)
        {
            if(sol[i] == -1)
                cout << "Lose ";
            else if(sol[i] == 0)
                cout << "Loop ";
            else
                cout << "Win ";
        }
    }
    cout << "\n";
    return 0;
}


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

#define pb push_back
typedef vector<int> vi;

int n;

struct Player {
    vi moves, color, deg;
    queue<int> win, loose;
    Player () {}
    Player (int m, vi&& moves) :
        moves(moves),
        color(n, 0),
        deg(n, m)
    {}
    vi incoming (int u) {
        vi adj;
        for (int d : moves) {
            adj.pb(u - d < 0 ? u + n - d : u - d);
        }
        return adj;
    }
};

int main () {
    scanf("%d", &n);
    Player p[2];
    for (int i = 0; i < 2; i++) {
        int m;
        scanf("%d", &m);
        vi v(m);
        for (int i = 0; i < m; i++) {
            scanf("%d", &v[i]);
        }
        sort(v.begin(), v.end());
        v.resize(unique(v.begin(), v.end()) - v.begin());
        p[i] = Player(v.size(), move(v));
        p[i].color[0] = -1;
        p[i].loose.push(0);
    }
    bool keep = true;
    while (keep) {
        for (int i = 0; i < 2; i++) {
            while (!p[i].loose.empty()) {
                int u = p[i].loose.front();
                p[i].loose.pop();
                for (int v : p[1 - i].incoming(u)) {
                    if (p[1 - i].color[v] == 0) {
                        p[1 - i].color[v] = 1;
                        p[1 - i].win.push(v);
                    }
                }
            }
        }
        keep = false;
        for (int i = 0; i < 2; i++) {
            while (!p[i].win.empty()) {
                int u = p[i].win.front();
                p[i].win.pop();
                for (int v : p[1 - i].incoming(u)) {
                    if (--p[1 - i].deg[v] == 0 && p[1 - i].color[v] == 0) {
                        p[1 - i].color[v] = -1;
                        p[1 - i].loose.push(v);
                        keep = true;
                    }
                }
            }
        }
    }
    for (int i = 0; i < 2; i++) {
        for (int j = 1; j < n; j++) {
            switch (p[i].color[j]) {
                case -1:
                    printf("Lose ");
                    break;
                case 0:
                    printf("Loop ");
                    break;
                case 1:
                    printf("Win ");
                    break;
            }
        }
        printf("\n");
    }
}


#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("O3")
#pragma GCC optimize("fast-math")
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>

#define ff first
#define ss second
#define pb emplace_back
#define all(x) x.begin(),x.end()
#define rall(x) (x).rbegin(),(x).rend()
#define re return
#define mp make_pair
#define sz(x) ((int)(x).size())
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rrep(i, n) for (int i = (n) - 1; i >= 0; i--)
#define repx(i, x, n) for(int i = x; i < n; i++)
#define repd(i, x, n, d) for(int i = x; i < n; i += d)
#define rrepx(i, x, n) for(int i = n - 1; i >= x; i--)
#define rrepd(i, x, n, d) for(int i = n - 1; i >= x; i -= d)
#define unq(x); { sort(x.begin(), x.end()); x.resize(unique(x.begin(), x.end()) - x.begin()); }
#define sqr(x) ((x)*(x))

using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ld, ld> pdd;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pii> vii;
typedef vector<pll> vll;
typedef vector<string> vs;
typedef vector<ll> vl;
typedef vector<vl> vvl;

#define DEBUG 1
//#define FILES 1

#ifdef DEBUG
#define debug(x)   cerr << #x << " " << x << endl;
#define debug_p(x) cerr << #x << " " << x.ff << " " << x.ss << endl;
#define debug_v(x) {cerr << #x << " "; for (auto i : x) cerr << i << " "; cerr << endl;}
#define debug_vp(x) {cerr << #x << " "; for (auto i : x) cerr << '[' << i.ff << " " << i.ss << ']'; cerr << endl;}
#define debug_v_v(x) {cerr << #x << "/*\n"; for (auto i : x) { for (auto i2 : i) cerr << i2 << " "; cerr << '\n';} cerr << "*/" << #x << endl;}
#else
#define debug(x) 0;
#define debug_p(x) 0;
#define debug_v(x) 0;
#define debug_vp(x) 0;
#define debug_v_v(x) 0;
#endif

#ifdef FILES
#define files(in, out); { freopen(in, "r", stdin); freopen(out, "w", stdout);}
#else
#define files(in, out) 0;
#endif

const int INF = 1e9;
const ll INFll = 2e18;
const int BASE1 = 179;
const int BASE2 = 653;
const ll MOD = 998244353;
const int MAXA = 2000001;
const int MAXN = 101;
const int MAXLOG = 22;
const ll COST = 1000 * 1000 * 1000;
const ld PI = 3.1415926535;
const ld EPS = 1e-15;

int n;

void dfs(int id, int u, vvi& was, vi& siz, vvi& dp, vvi& a, vvi& deg) {
    was[id][u] = 1;
    int nado = id ^ 1;
    rep(i, siz[id ^ 1]) {
        int nu = (u - a[id ^ 1][i] + n) % n;
        if (!was[nado][nu])
        {
            if (dp[id][u] == -1)
            {
                dp[nado][nu] = 1;
                dfs(nado, nu, was, siz, dp, a, deg);
            }
            else
            {
                if (--deg[nado][nu] == 0) {
                    dp[nado][nu] = -1;
                    dfs(nado, nu, was, siz, dp, a, deg);
                }
            }
        }
    }
}

void solve() {
    cin >> n;
    vi siz(2);
    cin >> siz[0];
    vvi a(2);
    a[0].resize(siz[0]);
    rep(i, siz[0])
        cin >> a[0][i];
    cin >> siz[1];
    a[1].resize(siz[1]);
    rep(i, siz[1])
        cin >> a[1][i];

    vvi dp(2, vi(n + 1)), was(2, vi(n + 1)),
        deg(2, vi(n + 1, siz[0]));
    rep(i, n)
        deg[1][i] = siz[1];
    dp[0][n - 1] = -1;
    dp[1][n - 1] = -1;
    was[0][n - 1] = 1;
    was[1][n - 1] = 1;
    dfs(1, n - 1, was, siz, dp, a, deg);
    dfs(0, n - 1, was, siz, dp, a, deg);
    rep(j, 2) {
        rep(i, n - 1) {
            if (dp[j][i] == -1)
                cout << "Lose ";
            else if (dp[j][i] == 1)
                cout << "Win ";
            else
                cout << "Loop ";
        }
        cout << "\n";
    }
}

signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    int t = 1;
    //cin >> t;
    while (t--)
        solve();
    return 0;
}


#include<bits/stdc++.h>
#define REP(i,j,k) for(int i=j;i<k;++i)
#define RREP(i,j,k) for(int i=(int)j-1;i>=k;--i)
#define int long long
#define pb emplace_back
#define P pair<int,int>
#define F first
#define S second
#define ALL(x) x.begin(),x.end()
#define sz(a) (int)(a).size()
#define MX 7005
#define oo 1e18
#define L d*2
#define R d*2+1
#define mid (l+r>>1)
#define Ls l,mid,d*2
#define Rs mid+1,r,d*2+1
#define MIN(x,y) (x=min(x,(y)))
#define MAX(x,y) (x=max(x,(y)))
#define mo (int)(1e9+7)
#define IOS cin.tie(0) ,cout.tie(0), cout.sync_with_stdio(0)
using namespace std;
int n,k[2],a,ok[2][MX],s[2][MX];
vector<int> v[2];
queue<P> q;
main(){
	IOS;
	cin>>n;
	REP(j,0,2){
		cin>>k[j];
		REP(i,0,k[j]) cin>>a,v[j].pb(a),ok[j][n-a] = 1,q.push(P(j,n-a));
	}
	while(sz(q)){
		int x = q.front().F,y = q.front().S; q.pop();
		REP(i,0,k[x^1]){
			int yy = (y+n-v[x^1][i])%n;
			if(ok[x][y]==2){
				if(!ok[x^1][yy]) ok[x^1][yy] = 1,q.push(P(x^1,yy));
			}
			else{
				if(!ok[x^1][yy] && ++s[x^1][yy]==k[x^1])
					ok[x^1][yy] = 2, q.push(P(x^1,yy));
			}
		}
	}
	REP(j,0,2){
		REP(i,1,n){
			if(ok[j][i]==1) cout<<"Win ";
			else if(ok[j][i]==2) cout<<"Lose ";
			else cout<<"Loop ";
		}
		cout<<'\n';
	}
}


#include <iostream>
#include<vector>
using namespace std;
int n, k,a;
vector<vector<int>> v,v1,w;
void f(int x, int y)
{
	for (int i = 0; i < v[1 - x].size(); i++)
	{
		int p =  (y+ n - v[1 - x][i])%n;
		if (w[1-x][p])continue;
		if (w[x][y] == 1)
		{
			v1[1-x][p]--;
			if (!v1[1 - x][p])
			{
				w[1 - x][p] = 2;
				f(1 - x, p);
			}
		}
		else {
			w[1 - x][p] = 1;
			f(1 - x, p);
		}
	}

}

int main()
{

	cin >> n;
	v.resize(2,vector<int>());
	v1.resize(2, vector<int>(n));
	w.resize(2, vector<int>(n));
	cin >> k;
	for (int i = 0; i < k; i++)
	{
		cin >> a;
		v[0].push_back(a);

	}
	for (int i = 0; i < n; i++) v1[0][i] = k;
	cin >> k;
	for (int i = 0; i < k; i++)
	{
		cin >> a;
		v[1].push_back(a);
		v1[1].push_back(k);
	}
	for (int i = 0; i < n; i++) v1[1][i] = k;
	w[0][0] = 2;
	w[1][0] = 2;
	f(1, 0);
	f(0, 0);
	for (int i = 0; i < 2; i++)
	{
		for (int j = 1; j < n; j++)
		{
			if (w[i][j] == 0) cout << "Loop ";
			else if (w[i][j] == 1) cout << "Win ";
			else cout << "Lose ";
		}
		cout << "\n";
	}
}


#include<stdio.h>
#include<string.h>
#include <algorithm>
#include<queue>
#include<string>
#include <iostream>
#include<vector>
#include <map>
#include <stack>
#include<set>
using namespace std;
vector<int> v1;
vector<int> v2;
int a[7002];
int b[7002];
int check1[7002];
int check2[7002];
int main() {
	int n, i, j; scanf("%d", &n);
	int p, q, temp; scanf("%d", &p);
	for (i = 0; i < p; i++) {
		scanf("%d", &temp);
		if (check1[temp] != 1) {
			check1[temp] = 1;
			v1.push_back(temp);
		}
	}
	scanf("%d", &q);
	for (i = 0; i < q; i++) {
		scanf("%d", &temp);
		if (check2[temp] != 1) {
			check2[temp] = 1;
			v2.push_back(temp);
		}
	}
	int s1 = v1.size();
	for (i = 0; i < s1; i++) {
		a[(n - v1[i]) % n] = 1;
	}
	int s2 = v2.size();
	for (i = 0; i < s2; i++) {
		b[(n - v2[i]) % n] = 1;
	}
	int how = 14001 / (s1 + s2) + 5;
	while (how--) {
		int win = 0, lose = 0;
		for (i = 1; i < n; i++) {
			if (a[i] != 0)continue;
			win = 0, lose = 0;
			for (j = 0; j < s1; j++) {
				if (i + v1[j] == 0 || b[(i + v1[j]) % n] == -1) {
					win = 1;
					break;
				}
				else if (b[(i + v1[j]) % n] == 1)
					lose++;
			}
			if (win)a[i] = 1;
			else if (lose == s1)a[i] = -1;
		}
		for (i = 1; i < n; i++) {

			if (b[i] != 0)continue;
			win = 0, lose = 0;
			for (j = 0; j < s2; j++) {
				if (i + v2[j] == 0 || a[(i + v2[j]) % n] == -1) {
					win = 1;
					break;
				}
				else if (a[(i + v2[j]) % n] == 1)
					lose++;
			}
			if (win)b[i] = 1;
			else if (lose == s2)b[i] = -1;
		}
	}
	for (i = 1; i < n; i++) {
		if (a[i] == 1)printf("Win ");
		else if (a[i] == -1)printf("Lose ");
		else printf("Loop ");
	}
	printf("\n");
	for (i = 1; i < n; i++) {
		if (b[i] == 1)printf("Win ");
		else if (b[i] == -1)printf("Lose ");
		else printf("Loop ");
	}
}


#include<stdio.h>
#include<string.h>
#include <algorithm>
#include<queue>
#include<string>
#include <iostream>
#include<vector>
#include <map>
#include <stack>
#include<set>
using namespace std;
vector<int> v1;
vector<int> v2;
int a[7002];
int b[7002];
int check1[7002];
int check2[7002];
int main() {
	int n, i,j; scanf("%d", &n);
	int p, q,temp; scanf("%d", &p);
	for (i = 0; i < p; i++) {
		scanf("%d", &temp);
		if (check1[temp] != 1) {
			check1[temp] = 1;
			v1.push_back(temp);
		}
	}
	scanf("%d", &q);
	for (i = 0; i < q; i++) {
		scanf("%d", &temp);
		if (check2[temp] != 1) {
			check2[temp] = 1;
			v2.push_back(temp);
		}
	}
	int s1 = v1.size();
	for (i = 0; i < s1; i++) {
		a[(n - v1[i]) % n] = 1;
	}
	int s2 = v2.size();
	for (i = 0; i < s2; i++) {
		b[(n - v2[i]) % n] = 1;
	}
	int how = 14001/(s1+s2)+1;
	while (how--) {
		int win = 0, lose = 0;
		for (i = 1; i < n; i++) {
			if (a[i] != 0)continue;
			win = 0, lose = 0;
			for (j = 0; j < s1; j++) {
				if (i + v1[j] == 0 || b[(i + v1[j]) % n] == -1) {
					win = 1;
					break;
				}
				else if (b[(i + v1[j]) % n] == 1)
					lose++;
			}
			if (win)a[i] = 1;
			else if (lose == s1)a[i] = -1;
		}
		for (i = 1; i < n; i++) {

			if (b[i] != 0)continue;
			win = 0, lose = 0;
			for (j = 0; j < s2; j++) {
				if (i + v2[j] == 0 || a[(i + v2[j]) % n] == -1) {
					win = 1;
					break;
				}
				else if (a[(i + v2[j]) % n] == 1)
					lose++;
			}
			if (win)b[i] = 1;
			else if (lose == s2)b[i] = -1;
		}
	}
	for (i = 1; i < n; i++) {
		if (a[i] == 1)printf("Win ");
		else if (a[i] == -1)printf("Lose ");
		else printf("Loop ");
	}
	printf("\n");
	for (i = 1; i < n; i++) {
		if (b[i] == 1)printf("Win ");
		else if (b[i] == -1)printf("Lose ");
		else printf("Loop ");
	}
}


#include<stdio.h>
#include<string.h>
#include <algorithm>
#include<queue>
#include<string>
#include <iostream>
#include<vector>
#include <map>
#include <stack>
#include<set>
using namespace std;
const int lose = 1, win = 2;
int cur[2][7111];
int k[2];
int what[2][7111];
int dp[2][7111];
int n;
void f(int p, int q, int r) {
	if (dp[p][q])return;
	dp[p][q] = r;
	int i;
	if (r == lose) {
		for (i = 1; i <= k[!p]; i++) {
			f(!p, (q + n - what[!p][i]) % n, win);
		}
	}
	else {
		for (i = 1; i <= k[!p]; i++) {
			if(!--cur[!p][(q + n - what[!p][i])%n])
				f(!p, (q + n - what[!p][i]) % n, lose);
		}
	}
}
int main() {
	int i; scanf("%d", &n);
	scanf("%d", &k[0]);
	for (i = 1; i <= k[0]; i++)
		scanf("%d", &what[0][i]);
	for (i = 0; i < n; i++)
		cur[0][i] = k[0];
	scanf("%d", &k[1]);
	for (i = 1; i <= k[1]; i++)
		scanf("%d", &what[1][i]);
	for (i = 0; i < n; i++)
		cur[1][i] = k[1];
	dp[0][0] = lose, dp[1][0] = lose;

	for (i = 1; i <= k[0]; i++)
		f(0, (n-what[0][i])%n, win);
	for (i = 1; i <= k[1]; i++)
		f(1, (n - what[1][i]) % n, win);
	for (int x = 0; x < 2; x++) {
		for (i = 1; i < n; i++) {
			if (dp[x][i] == win)
				printf("Win ");
			else if (dp[x][i] == lose)
				printf("Lose ");
			else printf("Loop ");
		}
		printf("\n");
	}
}


#include<stdio.h>
#include<string.h>
#include <algorithm>
#include<queue>
#include<string>
#include <iostream>
#include<vector>
#include <map>
#include <stack>
#include<set>
using namespace std;
vector<int> v1;
vector<int> v2;
int a[7002];
int b[7002];
int check1[7002];
int check2[7002];
int main() {
	int n, i, j; scanf("%d", &n);
	int p, q, temp; scanf("%d", &p);
	for (i = 0; i < p; i++) {
		scanf("%d", &temp);
		if (check1[temp] != 1) {
			check1[temp] = 1;
			v1.push_back(temp);
		}
	}
	scanf("%d", &q);
	for (i = 0; i < q; i++) {
		scanf("%d", &temp);
		if (check2[temp] != 1) {
			check2[temp] = 1;
			v2.push_back(temp);
		}
	}
	int s1 = v1.size();
	for (i = 0; i < s1; i++) {
		a[(n - v1[i]) % n] = 1;
	}
	int s2 = v2.size();
	for (i = 0; i < s2; i++) {
		b[(n - v2[i]) % n] = 1;
	}
	int how = 14001 / (s1 + s2) + 100;
	while (how--) {
		int win = 0, lose = 0;
		for (i = 1; i < n; i++) {
			if (a[i] != 0)continue;
			win = 0, lose = 0;
			for (j = 0; j < s1; j++) {
				if (i + v1[j] == 0 || b[(i + v1[j]) % n] == -1) {
					win = 1;
					break;
				}
				else if (b[(i + v1[j]) % n] == 1)
					lose++;
			}
			if (win)a[i] = 1;
			else if (lose == s1)a[i] = -1;
		}
		for (i = 1; i < n; i++) {

			if (b[i] != 0)continue;
			win = 0, lose = 0;
			for (j = 0; j < s2; j++) {
				if (i + v2[j] == 0 || a[(i + v2[j]) % n] == -1) {
					win = 1;
					break;
				}
				else if (a[(i + v2[j]) % n] == 1)
					lose++;
			}
			if (win)b[i] = 1;
			else if (lose == s2)b[i] = -1;
		}
	}
	for (i = 1; i < n; i++) {
		if (a[i] == 1)printf("Win ");
		else if (a[i] == -1)printf("Lose ");
		else printf("Loop ");
	}
	printf("\n");
	for (i = 1; i < n; i++) {
		if (b[i] == 1)printf("Win ");
		else if (b[i] == -1)printf("Lose ");
		else printf("Loop ");
	}
}


#pragma comment(linker, "/STACK:216000000")
#include <iostream>
#include <cstdio>
#include <fstream>
#include <vector>
#include <string>
#include <queue>
#include <map>
#include <algorithm>
#include <numeric>
#include <set>
#include <bitset>
#include <sstream>
#include <array>
#include <iomanip>
#include <unordered_map>
#include <unordered_set>

using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
const ll MAX = 1000000LL * 1000000LL;
const ll MIN = numeric_limits<ll>::min();
const double PI = 3.14159265358979;
const ll MOD = 1000000007LL;

template<class T>
ostream& operator<<(ostream& out, vector<T>& v) {
	for (int i = 0; i < v.size(); ++i) out << v[i] << " ";
	return out;
}

template<class T>
istream& operator >> (istream& in, vector<T>& v) {
	for (int i = 0; i < v.size(); ++i) in >> v[i];
	return in;
}

template<class T>
T lexical_cast(string& s) {
	stringstream ss(s);
	T t;
	ss >> t;
	return t;
}

ll gcd(ll a, ll b) {
	return b ? gcd(b, a % b) : a;
}

ll cdiv(ll a, ll b) {
	return (a % b) ? (a / b + 1) : (a / b);
}

ll inv(ll n, ll mod) {
	ll pow = mod - 2;
	ll ans = 1;
	ll cur = n;
	while (pow > 0) {
		if (pow & 1) {
			ans *= cur;
			ans %= mod;
		}
		pow /= 2;
		cur *= cur;
		cur %= mod;
	}
	return ans;
}

template<class Cont> void sort(Cont& c) { sort(begin(c), end(c)); }
template<class Cont> void reverse(Cont& c) { reverse(begin(c), end(c)); }

/* ------------------------------------------------
------------------------------------------------- */

int sub(int a, int b, int mod) {
	return ((a - b) % mod + mod) % mod;
}

int main() {
	ios_base::sync_with_stdio(false);
#ifdef DEBUG
	ifstream cin{ "input.txt" };
	ofstream cout{ "output.txt" };
#endif
	int n;
	cin >> n;
	vector<vector<int>> s(2);
	for (int i = 0; i < 2; ++i) {
		int k;
		cin >> k;
		s[i] = vector<int>(k);
		cin >> s[i];
	}
	// type: 0 - undef, 1 - win, 2 - lose
	// second = how many win
	vector<vector<pair<int, int>>> states(2, vector<pair<int, int>>(n));
	states[0][0].first = 2;
	states[1][0].first = 2;
	queue<pair<int, int>> changed;
	changed.push(make_pair(0, 0));
	changed.push(make_pair(1, 0));
	while (!changed.empty()) {
		auto p = changed.front();
		changed.pop();
		for (int i = 0; i < s[1 ^ p.first].size(); ++i) {
			int v = sub(p.second, s[1 ^ p.first][i], n);
			if (states[1 ^ p.first][v].first > 0)
				continue;
			if (states[p.first][p.second].first == 2) {
				states[1 ^ p.first][v].first = 1;
				changed.push(make_pair(1 ^ p.first, v));
			}
			else if (states[p.first][p.second].first == 1){
				states[1 ^ p.first][v].second++;
				if (states[1 ^ p.first][v].second == s[1 ^ p.first].size()) {
					states[1 ^ p.first][v].first = 2;
					changed.push(make_pair(1 ^ p.first, v));
				}
			}
		}
	}
	for (int i = 0; i < 2; ++i) {
		for (int j = 1; j < n; ++j) {
			switch (states[i][j].first) {
			case 0:
				cout << "Loop ";
				break;
			case 1:
				cout << "Win ";
				break;
			case 2:
				cout << "Lose ";
				break;
			}
		}
		cout << endl;
	}
}


#include <algorithm>
#include <bitset>
#include <cassert>
#include <deque>
#include <queue>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <float.h>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<pi, int> pii;
typedef pair<ll, ll> pl;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pi> vp;
typedef vector<pii> vpi;
typedef vector<string> vs;
typedef set<int> si;
typedef map<int, int> mi;

const int MAX = 7001;

int n;
int k[2];
vi svec[2];

int dp[2][MAX];
int loses[2][MAX];

void solve(int p, int m)
{
	int p_prev = 1 - p;

	int res = dp[p][m];

	for (int i = 0, size = svec[p_prev].size(); i < size; ++i)
	{
		int prev_move = svec[p_prev][i];
		int m_prev = (m - prev_move + n) % n;

		if (!dp[p_prev][m_prev])
		{
			if (res == -1)
			{
				dp[p_prev][m_prev] = 1;
				solve(p_prev, m_prev);
			}
			else // res == 1
			{
				if (++loses[p_prev][m_prev] == size)
				{
					dp[p_prev][m_prev] = -1;
					solve(p_prev, m_prev);
				}
			}
		}
	}

}

string to_string(int res)
{
	switch (res)
	{
	case -1:
		return "Lose";
	case 0:
		return "Loop";
	case 1:
		return "Win";
	}
	return "";
}

int main()
{
	ios::sync_with_stdio(false);

	cin >> n;

	for (int i = 0; i < 2; ++i)
	{
		cin >> k[i];
		svec[i].resize(k[i]);
		for (int j = 0; j < k[i]; ++j)
		{
			cin >> svec[i][j];
		}
		dp[i][0] = -1;
	}

	for (int i = 0; i < 2; ++i)
		solve(i, 0);

	for (int i = 0; i < 2; ++i)
	{
		for (int j = 1; j < n; ++j)
			cout << to_string(dp[i][j]) << " ";
		cout << endl;
	}

	return 0;
}


#include <algorithm>
#include <bitset>
#include <cassert>
#include <deque>
#include <queue>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <float.h>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<pi, int> pii;
typedef pair<ll, ll> pl;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pi> vp;
typedef vector<pii> vpi;
typedef vector<string> vs;
typedef set<int> si;
typedef map<int, int> mi;

const int MAX = 7001;

int n;
int k[2];
vi svec[2];
vi sval[2];

int dp[2][MAX];

int solve(int p, int m)
{
	if (dp[p][m] != INT_MAX)
		return dp[p][m];

	if (sval[p][n - m])
		return 1;

	dp[p][m] = 0;

	int res = -1;
	for (int i = 0, size = svec[p].size(); i < size; ++i)
	{
		int curr = svec[p][i];
		res = max(res, -solve(1 - p, (m + curr + n) % n));
	}

	if (res)
		dp[p][m] = res;
	else
		dp[p][m] = INT_MAX;
	return res;
}

string to_string(int res)
{
	switch (res)
	{
	case -1:
		return "Lose";
	case 0:
		return "Loop";
	case 1:
		return "Win";
	}
	return "";
}

int main()
{
	ios::sync_with_stdio(false);

	cin >> n;

	cin >> k[0];
	svec[0].resize(k[0]);
	sval[0].resize(n);
	for (int i = 0; i < k[0]; ++i)
	{
		cin >> svec[0][i];
		++sval[0][svec[0][i]];
	}

	cin >> k[1];
	svec[1].resize(k[1]);
	sval[1].resize(n);
	for (int i = 0; i < k[1]; ++i)
	{
		cin >> svec[1][i];
		++sval[1][svec[1][i]];
	}

	sort(svec[0].begin(), svec[0].end());
	sort(svec[1].begin(), svec[1].end());
	for (int i = 0; i < 2; ++i)
		for (int j = 0; j < n; ++j)
			dp[i][j] = INT_MAX;

	for (int i = 0; i < n - 1; ++i)
		cout << to_string(solve(0, i + 1)) << " ";

	cout << endl;

	for (int i = 0; i < n - 1; ++i)
		cout << to_string(solve(1, i + 1)) << " ";

	cout << endl;

	return 0;
}


#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>

using namespace std;

const int MAXN = 7e3 + 10;
//const int MAXN = 10;

int n, k;
bool p12[MAXN], p21[MAXN];
int ans[2 * MAXN], s[2 * MAXN];
vector < int > gi[2 * MAXN];
bool used[2 * MAXN];

int main() {
	cin >> n;

	cin >> k;
	for (int i = 0; i < k; i++) {
		int x;
		cin >> x;
		if (! p12[x]) {
			for (int i = 1; i <= n; i++) {
				int v = (i + x - 1) % n + 1;
				gi[MAXN + v].push_back(i);
				s[i]++;
			}
			p12[x] = true;
		}
	}

	cin >> k;
	for (int i = 0; i < k; i++) {
		int x;
		cin >> x;
		if (! p21[x]) {
			for (int i = 1; i <= n; i++) {
				int v = (i + x - 1) % n + 1;
				gi[v].push_back(MAXN + i);
				s[MAXN + i]++;
			}
			p21[x] = true;
		}
	}

	ans[1] = -1;
	ans[MAXN + 1] = -1;

	queue < int > q;
	q.push(1);
	q.push(MAXN + 1);
	used[1] = true;
	used[MAXN + 1] = true;

	while (! q.empty()) {
		int v = q.front();
		q.pop();

		if (ans[v] <= 0) {
			ans[v] = -1;
			for (int i = 0; i < gi[v].size(); i++) {
				int w = gi[v][i];
				ans[w] = 1;
				if (! used[w]) {
					q.push(w);
					used[w] = true;
				}
			}
		} else {
			for (int i = 0; i < gi[v].size(); i++) {
				int w = gi[v][i];
				s[w]--;
				if (s[w] == 0 && ! used[w]) {
					q.push(w);
					used[w] = true;
				}
			}
		}
	}

	for (int i = 2; i <= n; i++) {
		if (ans[i] == -1) {
			printf("Lose ");
		} else if (ans[i] == 0) {
			printf("Loop ");
		} else {
			printf("Win ");
		}
	}
	cout << endl;
	for (int i = 2; i <= n; i++) {
		if (ans[MAXN + i] == -1) {
			printf("Lose ");
		} else if (ans[MAXN + i] == 0) {
			printf("Loop ");
		} else {
			printf("Win ");
		}
	}
	cout << endl;

	return 0;
}


#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>

using namespace std;

const int MAXN = 7e3 + 10;
//const int MAXN = 10;

int n, k, x;
vector < int > p12, p21;
int ans[2 * MAXN], s[2 * MAXN];
bool used[2 * MAXN];

vector < int > generate_gi(int w) {
	vector < int > res;

	if (w < MAXN) {
		for (int i = 0; i < p21.size(); i++) {
			int p = p21[i];
			int c = (w - p - 1 + n) % n + 1;
			res.push_back(MAXN + c);
		}
	} else {
		w -= MAXN;
		for (int i = 0; i < p12.size(); i++) {
			int p = p12[i];
			int c = (w - p - 1 + n) % n + 1;
			res.push_back(c);
		}
	}

	return res;
}

int main() {
	cin >> n;

	cin >> k;
	for (int i = 0; i < k; i++) {
		cin >> x;
		p12.push_back(x);
	}
	for (int i = 1; i <= n; i++) {
		s[i] = k;
	}

	cin >> k;
	for (int i = 0; i < k; i++) {
		cin >> x;
		p21.push_back(x);
	}
	for (int i = 1; i <= n; i++) {
		s[MAXN + i] = k;
	}

	ans[1] = -1;
	ans[MAXN + 1] = -1;

	queue < int > q;
	q.push(1);
	q.push(MAXN + 1);
	used[1] = true;
	used[MAXN + 1] = true;

	while (! q.empty()) {
		int v = q.front();
		q.pop();

		if (ans[v] <= 0) {
			ans[v] = -1;
			vector < int > gi_line = generate_gi(v);
			for (int i = 0; i < gi_line.size(); i++) {
				int w = gi_line[i];
				ans[w] = 1;
				if (! used[w]) {
					q.push(w);
					used[w] = true;
				}
			}
		} else {
			vector < int > gi_line = generate_gi(v);
			for (int i = 0; i < gi_line.size(); i++) {
				int w = gi_line[i];
				s[w]--;
				if (s[w] == 0 && ! used[w]) {
					q.push(w);
					used[w] = true;
				}
			}
		}
	}

	for (int i = 2; i <= n; i++) {
		if (ans[i] == -1) {
			printf("Lose ");
		} else if (ans[i] == 0) {
			printf("Loop ");
		} else {
			printf("Win ");
		}
	}
	cout << endl;
	for (int i = 2; i <= n; i++) {
		if (ans[MAXN + i] == -1) {
			printf("Lose ");
		} else if (ans[MAXN + i] == 0) {
			printf("Loop ");
		} else {
			printf("Win ");
		}
	}
	cout << endl;

	return 0;
}


#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>

using namespace std;

const int MAXN = 7e3 + 10;
//const int MAXN = 10;

int n, k;
bool p12[MAXN], p21[MAXN];
int ans[2 * MAXN], s[2 * MAXN];
vector < int > gi[2 * MAXN];
bool used[2 * MAXN];

int main() {
	cin >> n;

	cin >> k;
	for (int i = 0; i < k; i++) {
		int x;
		cin >> x;
		if (! p12[x]) {
			for (int i = 1; i <= n; i++) {
				int v = (i + x - 1) % n + 1;
				gi[MAXN + v].push_back(i);
				s[i]++;
			}
			p12[x] = true;
		}
	}

	cin >> k;
	for (int i = 0; i < k; i++) {
		int x;
		cin >> x;
		if (! p21[x]) {
			for (int i = 1; i <= n; i++) {
				int v = (i + x - 1) % n + 1;
				gi[v].push_back(MAXN + i);
				s[MAXN + i]++;
			}
			p21[x] = true;
		}
	}

	ans[1] = -1;
	ans[MAXN] = -1;

	queue < int > q;
	q.push(1);
	q.push(MAXN + 1);
	while (! q.empty()) {
		int v = q.front();
		q.pop();

		if (used[v]) {
			continue;
		}
		used[v] = true;

		if (ans[v] <= 0) {
			ans[v] = -1;
			for (int i = 0; i < gi[v].size(); i++) {
				int w = gi[v][i];
				ans[w] = 1;
				q.push(w);
			}
		} else {
			for (int i = 0; i < gi[v].size(); i++) {
				int w = gi[v][i];
				s[w]--;
				if (s[w] == 0) {
					q.push(w);
				}
			}
		}
	}

	for (int i = 2; i <= n; i++) {
		if (ans[i] == -1) {
			printf("Lose ");
		} else if (ans[i] == 0) {
			printf("Loop ");
		} else {
			printf("Win ");
		}
	}
	cout << endl;
	for (int i = 2; i <= n; i++) {
		if (ans[MAXN + i] == -1) {
			printf("Lose ");
		} else if (ans[MAXN + i] == 0) {
			printf("Loop ");
		} else {
			printf("Win ");
		}
	}
	cout << endl;

	return 0;
}


#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>

using namespace std;

const int MAXN = 7e3 + 10;
//const int MAXN = 10;

int n, k;
bool p12[MAXN], p21[MAXN];
int ans[2 * MAXN], s[2 * MAXN];
bool used[2 * MAXN];

vector < int > generate_gi(int w) {
	vector < int > res;

	if (w < MAXN) {
		for (int i = 1; i < MAXN; i++) {
			if (p21[i]) {
				int v = (w - i - 1 + n) % n + 1;
				res.push_back(MAXN + v);
			}
		}
	} else {
		for (int i = 1; i < MAXN; i++) {
			if (p12[i]) {
				int v = (w - i - 1 + n) % n + 1;
				res.push_back(v);
			}
		}
	}

	return res;
}

int main() {
	cin >> n;

	cin >> k;
	for (int i = 0; i < k; i++) {
		int x;
		cin >> x;
		if (! p12[x]) {
			for (int i = 1; i <= n; i++) {
				int v = (i + x - 1) % n + 1;
				s[i]++;
			}
			p12[x] = true;
		}
	}

	cin >> k;
	for (int i = 0; i < k; i++) {
		int x;
		cin >> x;
		if (! p21[x]) {
			for (int i = 1; i <= n; i++) {
				int v = (i + x - 1) % n + 1;
				s[MAXN + i]++;
			}
			p21[x] = true;
		}
	}

	ans[1] = -1;
	ans[MAXN + 1] = -1;

	queue < int > q;
	q.push(1);
	q.push(MAXN + 1);
	used[1] = true;
	used[MAXN + 1] = true;

	while (! q.empty()) {
		int v = q.front();
		q.pop();

		if (ans[v] <= 0) {
			ans[v] = -1;
			vector < int > gi_line = generate_gi(v);
			for (int i = 0; i < gi_line.size(); i++) {
				int w = gi_line[i];
				ans[w] = 1;
				if (! used[w]) {
					q.push(w);
					used[w] = true;
				}
			}
		} else {
			vector < int > gi_line = generate_gi(v);
			for (int i = 0; i < gi_line.size(); i++) {
				int w = gi_line[i];
				s[w]--;
				if (s[w] == 0 && ! used[w]) {
					q.push(w);
					used[w] = true;
				}
			}
		}
	}

	for (int i = 2; i <= n; i++) {
		if (ans[i] == -1) {
			printf("Lose ");
		} else if (ans[i] == 0) {
			printf("Loop ");
		} else {
			printf("Win ");
		}
	}
	cout << endl;
	for (int i = 2; i <= n; i++) {
		if (ans[MAXN + i] == -1) {
			printf("Lose ");
		} else if (ans[MAXN + i] == 0) {
			printf("Loop ");
		} else {
			printf("Win ");
		}
	}
	cout << endl;

	return 0;
}


#include <cstdio>

static const int N = 7007;
static const int Win = 10;
static const int Lose = 20;

int n;
int sz[2];
int s[2][N];
int w[2][N];
int m[2][N];
int qx[N*4], qy[N*4], qv[N*4];

int main()
{
	#ifndef ONLINE_JUDGE
		freopen("input.txt","r", stdin);
		freopen("output.txt", "w", stdout);
	#endif

	scanf( "%d", & n );

	for(int x = 0; x < 2; ++x)
	{
		scanf( "%d", &sz[ x ] );

		for(int y = 0; y < sz[x]; ++y)
		{
			scanf("%d",&s[x][y]);
		}

		for(int y = 0; y < n; ++y)
		   w[x][y] = sz[x];
	}

	m[0][0] = Lose;
	m[1][0] = Lose;

	for(int x = 0; x < 2; ++x)
	{
		for(int y = 0; y < sz[ x ]; ++y)
		{
			int h = 0, t = 0;

			qx[ t ] = x;
			qy[ t ] = s[ x ][ y ];
			qv[ t ] = Win;
			++t;

			while( h < t )
			{
				int x,y,v;
				x = qx[h];
				y = qy[h];
				v = qv[h];
				++h;

				m[x][y] = v;
				if (v == Lose)
				{
					for(int i = 0; i < sz[!x]; ++i)
					{
						int yy = (  y + s[!x][i] ) % n;
						if (! m[ !x ] [ yy ] )
					    {
							qx[t] = !x;
							qy[t] = yy;
							qv[t] = Win;
							++t;
					    }
					}
				}
				else // v == Win
				{
					for(int i = 0; i < sz[!x]; ++i)
					{
						int yy = ( y + s[!x][i] ) % n;
						if ( ! --w[!x][yy] )
						{
							if ( ! m[!x][ yy]  )
							{
								qx[t] = !x;
								qy[t] = yy;
								qv[t] = Lose;
								++t;
							}
						}
					}
				}
			}
		}
	}

	// print
	for(int x = 0; x < 2; ++x)
	{
		for(int y = n - 1; y >= 1; --y)
		{
			if (m[x][y] == Win)printf("Win ");
			else if (m[x][y] == Lose)printf("Lose ");
			else printf("Loop ");
		}
		printf("\n");
	}
}


#include <cstdio>

static const int N = 7007;
static const int Win = 10;
static const int Lose = 20;

int n;
int sz[2];
int s[2][N];
int w[2][N];
int m[2][N];

void upd(int x, int y , int v)
{
	if (m[x][y])return;
	m[x][y] = v;
	if (v == Lose)
	   for(int i= 0; i < sz[!x]; ++i)
	      upd(!x, (y + s[!x][i])%n, Win);
	else
	   for(int i = 0; i < sz[!x]; ++i)
	     if ( ! --w[!x][(y+s[!x][i])%n] )
	        upd(!x, (y+s[!x][i])%n, Lose);
}
int main()
{
	#ifndef ONLINE_JUDGE
		freopen("input.txt","r", stdin);
		freopen("output.txt", "w", stdout);
	#endif

	scanf( "%d", & n );

	for(int x = 0; x < 2; ++x)
	{
		scanf( "%d", &sz[ x ] );

		for(int y = 0; y < sz[x]; ++y)
		{
			scanf("%d",&s[x][y]);
		}

		for(int y = 0; y < n; ++y)
		   w[x][y] = sz[x];
	}

	m[0][0] = Lose;
	m[1][0] = Lose;

	for(int x = 0; x < 2; ++x)
	{
		for(int y = 0; y < sz[ x ]; ++y)
		{
			upd(x,s[x][y], Win);continue;

		}
	}

	// print
	for(int x = 0; x < 2; ++x)
	{
		for(int y = n - 1; y >= 1; --y)
		{
			if (m[x][y] == Win)printf("Win ");
			else if (m[x][y] == Lose)printf("Lose ");
			else printf("Loop ");
		}
		printf("\n");
	}
}


#define _CRT_SECURE_NO_DEPRECATE

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cctype>
#include <cstring>
#include <ctime>

#include <iostream>
#include <algorithm>
#include <vector>
#include <deque>
#include <list>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <sstream>

typedef long long int64;
typedef long long li;
typedef long double ld;

using namespace std;

#define forn(i, n) for(int i = 0; i < int(n); ++i)
#define fore(i, l, r) for(int i = int(l); i < int(r); ++i)
#define forb(i, n) for(int i = int(n) - 1; i >= 0; --i)

#define fr first
#define sc second
#define mp make_pair
//#define pb push_back

const li INF = 1000000007;
double e = 0.0000001;
const double pi=3.1415926535897932384626433832795;

int main(){
//	freopen("input.txt", "r", stdin);
//	freopen("output.txt", "w", stdout);
	int n;
	cin >> n;
	vector<int> a, b;
	int k;
	cin >> k;
	forn(i, k){
		int c;
		cin >> c;
		a.push_back(c);
	}
	cin >> k;
	forn(i, k){
		int c;
		cin >> c;
		b.push_back(c);
	}
	vector<int> q(n, 0);
	vector<int> w(n, 0);
	forn(o, 5){

		for (int i = n - 2; i >= 0; i--){
			bool pb = 0;
			bool pr = 0;
			bool v = 0;
			forn(j, a.size()){
				if (i + a[j] == n - 1){
					pb = 1;
					break;
				}
				if (w[(i + a[j]) % n] == -1){
					pb = 1;
				}
				if (w[(i + a[j]) % n] == 1){
					pr = 1;
				}
				if (w[(i + a[j]) % n] == 0){
					v = 1;
				}
			}
			if (!v && !pb && pr){
				q[i] = -1;
			}
			if (pb){
				q[i] = 1;
			}

			pb = 0;
			pr = 0;
			v = 0;
			forn(j, b.size()){
				if (i + b[j] == n - 1){
					pb = 1;
					break;
				}
				if (q[(i + b[j]) % n] == -1){
					pb = 1;
				}
				if (q[(i + b[j]) % n] == 1){
					pr = 1;
				}
				if (q[(i + b[j]) % n] == 0){
					v = 1;
				}
			}
			if (!v && !pb && pr){
				w[i] = -1;
			}
			if (pb){
				w[i] = 1;
			}
		}
	}
	forn(i, n - 1){
		if (q[i] == 1){
			cout << "Win" << ' ';
		}
		if (q[i] == -1){
			cout << "Lose" << ' ';
		}
		if (q[i] == 0){
			cout << "Loop" << ' ';
		}
	}
	cout << endl;
	forn(i, n - 1){
		if (w[i] == 1){
			cout << "Win" << ' ';
		}
		if (w[i] == -1){
			cout << "Lose" << ' ';
		}
		if (w[i] == 0){
			cout << "Loop" << ' ';
		}
	}
    return 0;
}


#define _CRT_SECURE_NO_DEPRECATE

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cctype>
#include <cstring>
#include <ctime>

#include <iostream>
#include <algorithm>
#include <vector>
#include <deque>
#include <list>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <sstream>

typedef long long int64;
typedef long long li;
typedef long double ld;

using namespace std;

#define forn(i, n) for(int i = 0; i < int(n); ++i)
#define fore(i, l, r) for(int i = int(l); i < int(r); ++i)
#define forb(i, n) for(int i = int(n) - 1; i >= 0; --i)

#define fr first
#define sc second
#define mp make_pair
//#define pb push_back

const li INF = 1000000007;
double e = 0.0000001;
const double pi=3.1415926535897932384626433832795;

int main(){
//	freopen("input.txt", "r", stdin);
//	freopen("output.txt", "w", stdout);
	int n;
	cin >> n;
	if (n == 1){
		return 0;
	}
	vector<int> a, b;
	int k;
	cin >> k;
	forn(i, k){
		int c;
		cin >> c;
		a.push_back(c);
	}
	cin >> k;
	forn(i, k){
		int c;
		cin >> c;
		b.push_back(c);
	}
	vector<int> q(n, 0);
	vector<int> w(n, 0);
	forn(o, 5){

		for (int i = n - 2; i >= 0; i--){
			bool pb = 0;
			bool pr = 0;
			bool v = 0;
			forn(j, a.size()){
				if (i + a[j] == n - 1){
					pb = 1;
					break;
				}
				if (w[(i + a[j]) % n] == -1){
					pb = 1;
				}
				if (w[(i + a[j]) % n] == 1){
					pr = 1;
				}
				if (w[(i + a[j]) % n] == 0){
					v = 1;
				}
			}
			if (!v && !pb && pr){
				q[i] = -1;
			}
			if (pb){
				q[i] = 1;
			}

			pb = 0;
			pr = 0;
			v = 0;
			forn(j, b.size()){
				if (i + b[j] == n - 1){
					pb = 1;
					break;
				}
				if (q[(i + b[j]) % n] == -1){
					pb = 1;
				}
				if (q[(i + b[j]) % n] == 1){
					pr = 1;
				}
				if (q[(i + b[j]) % n] == 0){
					v = 1;
				}
			}
			if (!v && !pb && pr){
				w[i] = -1;
			}
			if (pb){
				w[i] = 1;
			}
		}
	}
	forn(i, n - 1){
		if (q[i] == 1){
			cout << "Win" << ' ';
		}
		if (q[i] == -1){
			cout << "Lose" << ' ';
		}
		if (q[i] == 0){
			cout << "Loop" << ' ';
		}
	}
	cout << endl;
	forn(i, n - 1){
		if (w[i] == 1){
			cout << "Win" << ' ';
		}
		if (w[i] == -1){
			cout << "Lose" << ' ';
		}
		if (w[i] == 0){
			cout << "Loop" << ' ';
		}
	}
    return 0;
}


#define _CRT_SECURE_NO_DEPRECATE

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cctype>
#include <cstring>
#include <ctime>

#include <iostream>
#include <algorithm>
#include <vector>
#include <deque>
#include <list>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <sstream>

typedef long long int64;
typedef long long li;
typedef long double ld;

using namespace std;

#define forn(i, n) for(int i = 0; i < int(n); ++i)
#define fore(i, l, r) for(int i = int(l); i < int(r); ++i)
#define forb(i, n) for(int i = int(n) - 1; i >= 0; --i)

#define fr first
#define sc second
#define mp make_pair
//#define pb push_back

const li INF = 1000000007;
double e = 0.0000001;
const double pi=3.1415926535897932384626433832795;

int main(){
//	freopen("input.txt", "r", stdin);
//	freopen("output.txt", "w", stdout);
	int n;
	cin >> n;
	vector<int> a, b;
	int k;
	cin >> k;
	forn(i, k){
		int c;
		cin >> c;
		a.push_back(c);
	}
	cin >> k;
	forn(i, k){
		int c;
		cin >> c;
		b.push_back(c);
	}
	vector<int> q(n, 0);
	vector<int> w(n, 0);
	forn(o, 5){

		for (int i = n - 2; i >= 0; i--){
			bool pb = 0;
			bool pr = 0;
			bool v = 0;
			forn(j, a.size()){
				if (i + a[j] == n - 1){
					pb = 1;
					break;
				}
				if (w[(i + a[j]) % n] == -1){
					pb = 1;
				}
				if (w[(i + a[j]) % n] == 1){
					pr = 1;
				}
				if (w[(i + a[j]) % n] == 0){
					v = 1;
				}
			}
			if (!v && !pb && pr){
				q[i] = -1;
			}
			if (pb){
				q[i] = 1;
			}

			pb = 0;
			pr = 0;
			v = 0;
			forn(j, b.size()){
				if (i + b[j] == n - 1){
					pb = 1;
					break;
				}
				if (q[(i + b[j]) % n] == -1){
					pb = 1;
				}
				if (q[(i + b[j]) % n] == 1){
					pr = 1;
				}
				if (q[(i + b[j]) % n] == 0){
					v = 1;
				}
			}
			if (!v && !pb){
				w[i] = -1;
			}
			if (pb){
				w[i] = 1;
			}
		}
	}
	forn(i, n - 1){
		if (q[i] == 1){
			cout << "Win" << ' ';
		}
		if (q[i] == -1){
			cout << "Lose" << ' ';
		}
		if (q[i] == 0){
			cout << "Loop" << ' ';
		}
	}
	cout << endl;
	forn(i, n - 1){
		if (w[i] == 1){
			cout << "Win" << ' ';
		}
		if (w[i] == -1){
			cout << "Lose" << ' ';
		}
		if (w[i] == 0){
			cout << "Loop" << ' ';
		}
	}
    return 0;
}


#define _CRT_SECURE_NO_DEPRECATE

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cctype>
#include <cstring>
#include <ctime>

#include <iostream>
#include <algorithm>
#include <vector>
#include <deque>
#include <list>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <sstream>

typedef long long int64;
typedef long long li;
typedef long double ld;

using namespace std;

#define forn(i, n) for(int i = 0; i < int(n); ++i)
#define fore(i, l, r) for(int i = int(l); i < int(r); ++i)
#define forb(i, n) for(int i = int(n) - 1; i >= 0; --i)

#define fr first
#define sc second
#define mp make_pair
//#define pb push_back

const li INF = 1000000007;
double e = 0.0000001;
const double pi=3.1415926535897932384626433832795;

int main(){
//	freopen("input.txt", "r", stdin);
//	freopen("output.txt", "w", stdout);
	int n;
	cin >> n;
	if (n == 1){
		return 0;
	}
	vector<int> a, b;
	int k;
	cin >> k;
	forn(i, k){
		int c;
		cin >> c;
		a.push_back(c);
	}
	cin >> k;
	forn(i, k){
		int c;
		cin >> c;
		b.push_back(c);
	}
	vector<int> q(n, 0);
	vector<int> w(n, 0);
	forn(o, 5){

		for (int i = n - 2; i >= 0; i--){
			if (q[i] != 0){
				continue;
			}
			bool pb = 0;
			bool pr = 0;
			bool v = 0;
			forn(j, a.size()){
				if (i + a[j] == n - 1){
					pb = 1;
					break;
				}
				if (w[(i + a[j]) % n] == -1){
					pb = 1;
				}
				if (w[(i + a[j]) % n] == 1){
					pr = 1;
				}
				if (w[(i + a[j]) % n] == 0){
					v = 1;
				}
			}
			if (!v && !pb && pr){
				q[i] = -1;
			}
			if (pb){
				q[i] = 1;
			}

			if (w[i] != 0){
				continue;
			}
			pb = 0;
			pr = 0;
			v = 0;
			forn(j, b.size()){
				if (i + b[j] == n - 1){
					pb = 1;
					break;
				}
				if (q[(i + b[j]) % n] == -1){
					pb = 1;
				}
				if (q[(i + b[j]) % n] == 1){
					pr = 1;
				}
				if (q[(i + b[j]) % n] == 0){
					v = 1;
				}
			}
			if (!v && !pb && pr){
				w[i] = -1;
			}
			if (pb){
				w[i] = 1;
			}
		}
	}
	forn(i, n - 1){
		if (q[i] == 1){
			cout << "Win" << ' ';
		}
		if (q[i] == -1){
			cout << "Lose" << ' ';
		}
		if (q[i] == 0){
			cout << "Loop" << ' ';
		}
	}
	cout << endl;
	forn(i, n - 1){
		if (w[i] == 1){
			cout << "Win" << ' ';
		}
		if (w[i] == -1){
			cout << "Lose" << ' ';
		}
		if (w[i] == 0){
			cout << "Loop" << ' ';
		}
	}
    return 0;
}


#define _CRT_SECURE_NO_DEPRECATE

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cctype>
#include <cstring>
#include <ctime>

#include <iostream>
#include <algorithm>
#include <vector>
#include <deque>
#include <list>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <sstream>

typedef long long int64;
typedef long long li;
typedef long double ld;

using namespace std;

#define forn(i, n) for(int i = 0; i < int(n); ++i)
#define fore(i, l, r) for(int i = int(l); i < int(r); ++i)
#define forb(i, n) for(int i = int(n) - 1; i >= 0; --i)

#define fr first
#define sc second
#define mp make_pair
//#define pb push_back

const li INF = 1000000007;
double e = 0.0000001;
const double pi=3.1415926535897932384626433832795;

int main(){
//	freopen("input.txt", "r", stdin);
//	freopen("output.txt", "w", stdout);
	int n;
	cin >> n;
	if (n == 1){
		return 0;
	}
	vector<int> a, b;
	int k;
	cin >> k;
	forn(i, k){
		int c;
		cin >> c;
		a.push_back(c);
	}
	cin >> k;
	forn(i, k){
		int c;
		cin >> c;
		b.push_back(c);
	}
	vector<int> q(n, 0);
	vector<int> w(n, 0);
	for(;;){
		bool f = 0;
		for (int i = n - 2; i >= 0; i--){
			bool pb = 0;
			bool pr = 0;
			bool v = 0;
			if (q[i] == 0){
				forn(j, a.size()){
					if (i + a[j] == n - 1){
						pb = 1;
						break;
					}
					if (w[(i + a[j]) % n] == -1){
						pb = 1;
					}
					if (w[(i + a[j]) % n] == 1){
						pr = 1;
					}
					if (w[(i + a[j]) % n] == 0){
						v = 1;
					}
				}
				if (!v && !pb && pr){
					q[i] = -1;
					f = 1;
				}
				if (pb){
					q[i] = 1;
					f = 1;
				}
			}

			if (w[i] == 0){
				pb = 0;
				pr = 0;
				v = 0;
				forn(j, b.size()){
					if (i + b[j] == n - 1){
						pb = 1;
						break;
					}
					if (q[(i + b[j]) % n] == -1){
						pb = 1;
					}
					if (q[(i + b[j]) % n] == 1){
						pr = 1;
					}
					if (q[(i + b[j]) % n] == 0){
						v = 1;
					}
				}
				if (!v && !pb && pr){
					w[i] = -1;
					f = 1;
				}
				if (pb){
					w[i] = 1;
					f = 1;
				}
			}
		}
		if (!f){
			break;
		}
	}
	forn(i, n - 1){
		if (q[i] == 1){
			cout << "Win" << ' ';
		}
		if (q[i] == -1){
			cout << "Lose" << ' ';
		}
		if (q[i] == 0){
			cout << "Loop" << ' ';
		}
	}
	cout << endl;
	forn(i, n - 1){
		if (w[i] == 1){
			cout << "Win" << ' ';
		}
		if (w[i] == -1){
			cout << "Lose" << ' ';
		}
		if (w[i] == 0){
			cout << "Loop" << ' ';
		}
	}
    return 0;
}


#include <iostream>
#include <queue>
#include <vector>
#include <iostream>
#include <string>

#define целое int
#define целые int
#define возвращает
#define ничего void
#define плюс +
#define минус -
#define умножить *
#define делить /
#define на
#define это =
#define равно ==
#define и &&
#define или ||
#define дробь double
#define строка string
#define пара pair<
#define целого int
#define целых int
#define да ,
#define из
#define будет >
#define вектор vector<
#define правда true
#define ложь false
#define использую using
#define язык namespace
#define стандартный std
#define значит ;
#define если if(
#define тогда )
#define иначе else
#define вот {
#define все }
#define читаю cin>>
#define пишу cout <<
#define затем <<
#define потом >>
#define размера .resize(
#define к
#define сзади .push_back(
#define добавится )
#define станет )
#define массив [
#define элементов ]
#define меньше <
#define больше >
#define пробел " "
#define возвращаю return
#define программа main()
#define а a
#define бэ b
#define цэ c
#define дэ d
#define эс s
#define икс x
#define эн n
#define эм m
#define вэ v
#define пэ p
#define ай i
#define пока while(
#define делаю )
#define однозначно const
#define длины .size()
#define длина .size()
#define сумма sum
#define перенос endl
#define по
#define модулю %=
#define с
#define индексом [
#define элемент ]
#define один 1
#define одного 1
#define равен ==
#define строчной tolower(
#define вариант )
#define строчная islower(
#define буква )
#define символ char
#define увеличиваю ++
#define нулю 0
#define уменьшаю --
#define ноль 0
#define нулю 0
#define нуля 0
#define Эн N
#define Красава Winner
#define Лох Loser
#define игрок win
#define два 2
#define очередь queue<int>
#define в
#define добавим .push(
#define конец )
#define непустая .size()
#define верхушка .front()
#define вытащим .pop()
#define из
#define кто whoдэ
#define Никто None
#define чем
#define продолжаем continue
#define тоже ==
#define двух 2

использую язык стандартный значит

однозначно целое Эн это 7005 значит
целое эн значит
целых пэ массив из Эн элементов значит
целых кью массив из Эн элементов значит
целые а да бэ значит
целых дэ массив из Эн умножить на два элементов значит

однозначно целое Красава это один значит
однозначно целое Лох это два значит
однозначно целое Никто это ноль значит
целых игрок массив из Эн умножить на два элементов значит

возвращает целое программа
вот
	читаю эн потом а значит

	целое ай это ноль значит
	пока ай меньше а делаю
	вот
		читаю пэ с индексом ай элемент значит
		ай это ай плюс один значит
	все

	читаю бэ значит
	ай это ноль значит
	пока ай меньше бэ делаю
	вот
		читаю кью с индексом ай элемент значит
		ай это ай плюс один значит
	все

	очередь эс значит
	игрок с индексом ноль элемент это Лох значит
	игрок с индексом один элемент это Лох значит

	в эс добавим ноль в конец значит
	в эс добавим один в конец значит

	пока эс непустая делаю
	вот
		целое вэ это эс верхушка значит
		из эс вытащим значит

		целое кто это игрок с индексом вэ элемент значит

		целое икс это вэ значит
		икс по модулю два значит
		вэ это вэ делить на два значит

		целое ай это ноль значит
		если икс равен нулю тогда
		вот
			пока ай меньше а делаю
			вот
				целое тэ это вэ плюс эн минус пэ с индексом ай элемент значит
				ай увеличиваю значит
				тэ по модулю эн значит
				тэ это тэ умножить на два плюс один минус икс значит
				если игрок с индексом тэ элемент больше чем Никто тогда продолжаем значит

				если кто тоже Лох тогда
				вот
					игрок с индексом тэ элемент это Красава значит
					в эс добавим тэ в конец значит
				все иначе вот
					дэ с индексом тэ элемент уменьшаю значит
					если дэ с индексом тэ элемент равен минус а тогда
					вот
						игрок с индексом тэ элемент это Лох значит
						в эс добавим тэ в конец значит
					все
				все
			все
		все иначе вот
			пока ай меньше бэ делаю
			вот
				целое тэ это вэ плюс эн минус кью с индексом ай элемент значит
				ай увеличиваю значит
				тэ по модулю эн значит
				тэ это тэ умножить на два плюс один минус икс значит
				если игрок с индексом тэ элемент больше чем Никто тогда продолжаем значит

				если кто тоже Лох тогда
				вот
					игрок с индексом тэ элемент это Красава значит
					в эс добавим тэ в конец значит
				все иначе вот
					дэ с индексом тэ элемент уменьшаю значит
					если дэ с индексом тэ элемент равен минус бэ тогда
					вот
						игрок с индексом тэ элемент это Лох значит
						в эс добавим тэ в конец значит
					все
				все
			все
		все
	все

	целое икс это ноль значит

	пока икс меньше двух делаю
	вот
		ай это один умножить на два плюс один минус икс значит
		пока ай меньше эн умножить на два делаю
		вот
			целое вэ это игрок с индексом ай элемент значит
			ай это ай плюс два значит
			если вэ тоже Лох тогда
			вот
				пишу "Lose " значит
				продолжаем значит
			все
			если вэ тоже Красава тогда
			вот
				пишу "Win " значит
				продолжаем значит
			все
			пишу "Loop " значит
		все
		икс увеличиваю значит
		пишу "\n" значит
	все

	возвращаю ноль значит
все


#include <cstdlib>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <numeric>
#include <sstream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <unordered_set>
#include <unordered_map>
#include <functional>

using namespace std;

#define sz(X) ((int)(X).size())
#define pb push_back
#define mp make_pair
#define X first
#define Y second
#define all(X) (X).begin(),(X).end()
#define FOR(i, a, n) for(int i=(a), __ ## i=(n); i<__ ## i; i++)
#define REP(I,N) FOR(I,0,N)
#define PR(X) cout<<#X<<" = "<<(X)<<" "
#define PRL cout<<endl
#define PRV(X) {cout<<#X<<" = {";REP(__prv,sz(X)-1)cout<<(X)[__prv]<<",";if(sz(X))cout<<*(X).end();cout<<"}"<<endl;}

template<class T> ostream &operator<<(ostream &os, const vector<T> &vec)
{
	os << '{';
	REP(i, sz(vec))
	{
		os << vec[i];
		if (i + 1 != sz(vec))
			os << ',';
	}
	os << '}';
	return os;
}

template<class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &par)
{
	os << '(' << par.X << ',' << par.Y << ')';
	return os;
}

typedef long long lint;
typedef vector<int> VI;
typedef pair<int, int> PII;

int gcd(int x, int y)
{
	return y ? gcd(y, x % y) : abs(x);
}

template<class T> T sqr(T x)
{
	return x * x;
}

int  b[7003][2], deg[7003][2];
vector <int> vk[2];
int n;
int mod(int x) {
	while (x >= n)	x -= n;
	return x;
}

void rec(int x, int p) {
	int pp = !p;

	for (int i = 0; i < vk[pp].size(); i++) {
		int from = mod(x + n - vk[pp][i]);
		if (b[from][pp]) continue;

		if (b[x][p] == 1) {
			--deg[from][pp];
			if (!deg[from][pp]) {
				b[from][pp] = 2;
				rec(from, pp);
			}
		}
		else {
			b[from][pp] = 1;
			rec(from, pp);
		}
	}
}

int main()
{
	ios::sync_with_stdio(false);

	FILE *f, *g;
	//freopen_s(&f, "input.txt", "r", stdin);
	//freopen_s(&g, "output.txt", "w", stdout);

	cin >> n;

	int k1, k2;

	cin >> k1;
	vk[0].resize(k1);
	for (int i = 0; i < k1; i++)
		cin >> vk[0][i];

	cin >> k2;
	vk[1].resize(k2);
	for (int i = 0; i < k2; i++)
		cin >> vk[1][i];

	b[0][0] = 2;
	b[0][1] = 2;

	for (int i = 0; i < n; i++)
		for (int j = 0; j < 2; j++)
			deg[i][j] = (int)vk[j].size();

	rec(0, 0);
	rec(0, 1);

	for (int j = 0; j<2; j++)
		for (int i = 1 ; i < n; i++)
		cout << (b[i][j] ? b[i][j] == 1 ? "Win" : "Lose" : "Loop") << " \n"[i + 1 == n];

	return 0;
}


#define _CRT_SECURE_NO_WARNINGS
#include <vector>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <queue>
#include <math.h>
#include <numeric>
#include <map>
#include <set>
#include <stdio.h>
#include <complex>
#define ll long long
#define ff first
#define ss second
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pib pair<int, bool>
#define pdd pair<double, double>
#define pss pair<string, string>
#define ull unsigned long long
#pragma comment(linker, "/STACK:251777215")
using namespace std;
const ll maxn = 10011;
const ll maxk = 10;
const ll maxlen = 2502;
const ll maxseg = 262144;
const ll mod = 1e9 + 7;
const double pi = 3.141592653589793238462643383279502884;
const double eps = 1e-5;

int n, k[2];
int a[2][maxn];
int res[2][maxn];
int opp[] = { 1, 0 };
int mod_pos[maxseg];

int get_win(int cur, int add)
{
	return ((cur - add - 1) % n + n) % n + 1;
}

int get_lose(int cur, int add)
{
	return mod_pos[cur + add];
}

void iterate_win(int pos, int ind)
{
	for (int i = 0; i < k[ind]; ++i)
	{
		int to = get_win(pos, a[ind][i]);
		res[ind][to] = 2;
	}
}

bool iterate_lose(int pos, int ind)
{
	for (int i = 0; i < k[ind]; ++i)
	{
		int to = get_lose(pos, a[ind][i]);
		if (res[opp[ind]][to] != 2)
			return false;
	}
	res[ind][pos] = 1;
	return true;
}

bool global_lose()
{
	bool good = false;
	for (int i = n; i > 0; --i)
		for (int j = 0; j < 2; ++j)
			if (res[j][i] == 3)
				if (iterate_lose(i, j))
					iterate_win(i, opp[j]), good = true;
	return good;
}

int main()
{
	fill((int*)res, (int*)res + 2 * maxn, 3); // 1 - loose, 2 - win, 3 - loop
	cin >> n;
	res[0][1] = 1;
	res[1][1] = 1;
	for (int j = 0; j < 2; ++j)
	{
		cin >> k[j];
		for (int i = 0; i < k[j]; ++i)
			cin >> a[j][i];
	}
	for (int i = 1; i < maxseg; ++i)
		mod_pos[i] = (i - 1) % n + 1;

	iterate_win(1, 0);
	iterate_win(1, 1);
	int iters = 0;
	while (global_lose())
		iters++;
	for (int j = 0; j < 2; ++j)
	{
		for (int i = 2; i <= n; ++i)
		{
			if (res[j][i] == 1)
				cout << "Lose ";
			else if (res[j][i] == 2)
				cout << "Win ";
			else
				cout << "Loop ";
		}
		cout << '\n';
	}
	return 0;
}
/*
7000
3 1 2 3
1 1

*/


#define _CRT_SECURE_NO_WARNINGS
#include <vector>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <queue>
#include <math.h>
#include <numeric>
#include <map>
#include <set>
#include <stdio.h>
#include <complex>
#define ll long long
#define ff first
#define ss second
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pib pair<int, bool>
#define pdd pair<double, double>
#define pss pair<string, string>
#define ull unsigned long long
#pragma comment(linker, "/STACK:251777215")
using namespace std;
const ll maxn = 10011;
const ll maxk = 10;
const ll maxlen = 2502;
const ll maxseg = 262144;
const ll mod = 1e9 + 7;
const double pi = 3.141592653589793238462643383279502884;
const double eps = 1e-5;

int n, k[2];
int a[2][maxn];
int res[2][maxn];
int opp[] = { 1, 0 };
int mod_pos[maxseg];

void iterate_win(int pos, int ind)
{
	for (int i = 0; i < k[ind]; ++i)
		res[ind][mod_pos[pos - a[ind][i] + 2 * n]] = 2;
}

bool iterate_lose(int pos, int ind)
{
	for (int i = 0; i < k[ind]; ++i)
		if (res[opp[ind]][mod_pos[pos + a[ind][i]]] != 2)
			return false;
	res[ind][pos] = 1;
	return true;
}

bool global_lose()
{
	bool good = false;
	for (int i = n; i > 0; --i)
		for (int j = 0; j < 2; ++j)
			if (res[j][i] == 3)
				if (iterate_lose(i, j))
					iterate_win(i, opp[j]), good = true;
	return good;
}

int main()
{
	fill((int*)res, (int*)res + 2 * maxn, 3); // 1 - lose, 2 - win, 3 - loop
	cin >> n;
	res[0][1] = 1;
	res[1][1] = 1;
	for (int j = 0; j < 2; ++j)
	{
		scanf("%d", &k[j]);
		for (int i = 0; i < k[j]; ++i)
			scanf("%d", &a[j][i]);
	}
	for (int i = 1; i < maxseg; ++i)
		mod_pos[i] = (i - 1) % n + 1;

	iterate_win(1, 0);
	iterate_win(1, 1);
	while (global_lose());
	for (int j = 0; j < 2; ++j)
	{
		char buff[6 * maxn];
		int cur = 0;
		for (int i = 2; i <= n; ++i)
		{
			if (res[j][i] == 1)
				buff[cur] = 'L', buff[cur + 1] = 'o', buff[cur + 2] = 's', buff[cur + 3] = 'e', buff[cur + 4] = ' ', cur += 5;
			else if (res[j][i] == 2)
				buff[cur] = 'W', buff[cur + 1] = 'i', buff[cur + 2] = 'n', buff[cur + 3] = ' ', cur += 4;
			else
				buff[cur] = 'L', buff[cur + 1] = 'o', buff[cur + 2] = 'o', buff[cur + 3] = 'p', buff[cur + 4] = ' ', cur += 5;
		}
		buff[cur] = 0;
		puts(buff);
	}
	return 0;
}
/*
7000
3 1 2 3
1 1

*/


#define _CRT_SECURE_NO_WARNINGS
#include <vector>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <queue>
#include <math.h>
#include <numeric>
#include <map>
#include <set>
#include <stdio.h>
#include <complex>
#define ll long long
#define ff first
#define ss second
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pib pair<int, bool>
#define pdd pair<double, double>
#define pss pair<string, string>
#define ull unsigned long long
#pragma comment(linker, "/STACK:251777215")
using namespace std;
const ll maxn = 10011;
const ll maxk = 10;
const ll maxlen = 2502;
const ll maxseg = 262144;
const ll mod = 1e9 + 7;
const double pi = 3.141592653589793238462643383279502884;
const double eps = 1e-5;

int n, k[2];
int a[2][maxn];
int res[2][maxn];
int opp[] = { 1, 0 };
int mod_pos[maxseg];

int get_win(int cur, int add)
{
	return ((cur - add - 1) % n + n) % n + 1;
}

int get_lose(int cur, int add)
{
	return mod_pos[cur + add];
}

void iterate_win(int pos, int ind)
{
	for (int i = 0; i < k[ind]; ++i)
	{
		int to = get_win(pos, a[ind][i]);
		res[ind][to] = 2;
	}
}

bool iterate_lose(int pos, int ind)
{
	for (int i = 0; i < k[ind]; ++i)
	{
		int to = get_lose(pos, a[ind][i]);
		if (res[opp[ind]][to] != 2)
			return false;
	}
	res[ind][pos] = 1;
	return true;
}

bool global_lose()
{
	bool good = false;
	for (int i = 1; i <= n; ++i)
		for (int j = 0; j < 2; ++j)
			if (res[j][i] == 3)
				if (iterate_lose(i, j))
					iterate_win(i, opp[j]), good = true;
	return good;
}

int main()
{
	fill((int*)res, (int*)res + 2 * maxn, 3); // 1 - loose, 2 - win, 3 - loop
	cin >> n;
	res[0][1] = 1;
	res[1][1] = 1;
	for (int j = 0; j < 2; ++j)
	{
		cin >> k[j];
		for (int i = 0; i < k[j]; ++i)
			cin >> a[j][i];
	}
	for (int i = 1; i < maxseg; ++i)
		mod_pos[i] = (i - 1) % n + 1;

	iterate_win(1, 0);
	iterate_win(1, 1);
	int iters = 0;
	while (global_lose())
		iters++;
	for (int j = 0; j < 2; ++j)
	{
		for (int i = 2; i <= n; ++i)
		{
			if (res[j][i] == 1)
				cout << "Lose ";
			else if (res[j][i] == 2)
				cout << "Win ";
			else
				cout << "Loop ";
		}
		cout << '\n';
	}
	return 0;
}
/*
7000
3 1 2 3
1 1

*/


#define _CRT_SECURE_NO_WARNINGS
#include <vector>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <queue>
#include <math.h>
#include <numeric>
#include <map>
#include <set>
#include <stdio.h>
#include <complex>
#define ll long long
#define ff first
#define ss second
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pib pair<int, bool>
#define pdd pair<double, double>
#define pss pair<string, string>
#define ull unsigned long long
#pragma comment(linker, "/STACK:251777215")
using namespace std;
const ll maxn = 10011;
const ll maxk = 10;
const ll maxlen = 2502;
const ll maxseg = 262144;
const ll mod = 1e9 + 7;
const double pi = 3.141592653589793238462643383279502884;
const double eps = 1e-5;

int n, k[2];
int a[2][maxn];
int res[2][maxn];
int opp[] = { 1, 0 };

int get_win(int cur, int add)
{
	return ((cur - add - 1) % n + n) % n + 1;
}

int get_lose(int cur, int add)
{
	return (cur + add - 1) % n + 1;
}

void iterate_win(int pos, int ind)
{
	for (int i = 0; i < k[ind]; ++i)
	{
		int to = get_win(pos, a[ind][i]);
		res[ind][to] = 2;
	}
}

bool iterate_lose(int pos, int ind)
{
	for (int i = 0; i < k[ind]; ++i)
	{
		int to = get_lose(pos, a[ind][i]);
		if (res[opp[ind]][to] != 2)
			return false;
	}
	res[ind][pos] = 1;
	return true;
}

bool global_lose()
{
	bool good = false;
	for (int i = 1; i <= n; ++i)
		for (int j = 0; j < 2; ++j)
			if (res[j][i] == 3)
				if (iterate_lose(i, j))
					iterate_win(i, opp[j]), good = true;
	return good;
}

int main()
{
	fill((int*)res, (int*)res + 2 * maxn, 3); // 1 - loose, 2 - win, 3 - loop
	cin >> n;
	res[0][1] = 1;
	res[1][1] = 1;
	for (int j = 0; j < 2; ++j)
	{
		cin >> k[j];
		for (int i = 0; i < k[j]; ++i)
			cin >> a[j][i];
	}

	iterate_win(1, 0);
	iterate_win(1, 1);
	while (global_lose());
	for (int j = 0; j < 2; ++j)
	{
		for (int i = 2; i <= n; ++i)
		{
			if (res[j][i] == 1)
				cout << "Lose ";
			else if (res[j][i] == 2)
				cout << "Win ";
			else
				cout << "Loop ";
		}
		cout << '\n';
	}
	return 0;
}
/*
7000
3 1 2 3
1 1

*/


#define _CRT_SECURE_NO_WARNINGS
#include <vector>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <queue>
#include <math.h>
#include <numeric>
#include <map>
#include <set>
#include <stdio.h>
#include <complex>
#define ll long long
#define ff first
#define ss second
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pib pair<int, bool>
#define pdd pair<double, double>
#define pss pair<string, string>
#define ull unsigned long long
#pragma comment(linker, "/STACK:251777215")
using namespace std;
const ll maxn = 10011;
const ll maxk = 10;
const ll maxlen = 2502;
const ll maxseg = 262144;
const ll mod = 1e9 + 7;
const double pi = 3.141592653589793238462643383279502884;
const double eps = 1e-5;

int n, k[2];
int a[2][maxn];
int res[2][maxn];
int last[2][maxn];
int opp[] = { 1, 0 };
int mod_pos[maxseg];

void iterate_win(int pos, int ind);

int get_win(int cur, int add)
{
	return mod_pos[cur - add + 10 * n];
}

void try_win(int pos, int ind)
{
	for (int i = 0; i < k[ind]; ++i)
	{
		int to = get_win(pos, a[ind][i]);
		last[ind][to]--;
		if (last[ind][to] == 0)
			res[ind][to] = 1, iterate_win(pos, ind);
	}
}

void iterate_win(int pos, int ind)
{
	for (int i = 0; i < k[ind]; ++i)
	{
		int to = get_win(pos, a[ind][i]);
		if (res[ind][to] == 3)
		{
			res[ind][to] = 2;
			try_win(to, opp[ind]);
		}
	}
}

int main()
{
	fill((int*)res, (int*)res + 2 * maxn, 3); // 1 - loose, 2 - win, 3 - loop
	cin >> n;
	res[0][1] = 1;
	res[1][1] = 1;
	for (int j = 0; j < 2; ++j)
	{
		cin >> k[j];
		for (int i = 0; i < k[j]; ++i)
			cin >> a[j][i];
	}
	for (int i = 1; i < maxseg; ++i)
		mod_pos[i] = (i - 1) % n + 1;
	for (int i = 1; i <= n; ++i)
		for (int j = 0; j < 2; ++j)
			last[j][i] = k[j];
	last[0][1] = 0;
	last[1][1] = 0;
	iterate_win(1, 0);
	iterate_win(1, 1);

	for (int j = 0; j < 2; ++j)
	{
		for (int i = 2; i <= n; ++i)
		{
			if (res[j][i] == 1)
				cout << "Lose ";
			else if (res[j][i] == 2)
				cout << "Win ";
			else
				cout << "Loop ";
		}
		cout << '\n';
	}
	return 0;
}
/*
7000
3 1 2 3
1 1

*/


#define _CRT_SECURE_NO_WARNINGS
#include <vector>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <queue>
#include <math.h>
#include <numeric>
#include <map>
#include <set>
#include <stdio.h>
#include <complex>
#define ll long long
#define ff first
#define ss second
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pib pair<int, bool>
#define pdd pair<double, double>
#define pss pair<string, string>
#define ull unsigned long long
#pragma comment(linker, "/STACK:251777215")
using namespace std;
const ll maxn = 10011;
const ll maxk = 10;
const ll maxlen = 2502;
const ll maxseg = 262144;
const ll mod = 1e9 + 7;
const double pi = 3.141592653589793238462643383279502884;
const double eps = 1e-5;

int n, k[2];
int a[2][maxn];
int res[2][maxn];
int opp[] = { 1, 0 };
int mod_pos[maxseg];
int mod_neg[maxseg];

int get_win(int cur, int add)
{
	return mod_neg[-(cur - add - 1)] + 1;
}

int get_lose(int cur, int add)
{
	return mod_pos[cur + add - 1] + 1;
}

void iterate_win(int pos, int ind)
{
	for (int i = 0; i < k[ind]; ++i)
	{
		int to = get_win(pos, a[ind][i]);
		res[ind][to] = 2;
	}
}

bool iterate_lose(int pos, int ind)
{
	for (int i = 0; i < k[ind]; ++i)
	{
		int to = get_lose(pos, a[ind][i]);
		if (res[opp[ind]][to] != 2)
			return false;
	}
	res[ind][pos] = 1;
	return true;
}

bool global_lose()
{
	bool good = false;
	for (int i = 1; i <= n; ++i)
		for (int j = 0; j < 2; ++j)
			if (res[j][i] == 3)
				if (iterate_lose(i, j))
					iterate_win(i, opp[j]), good = true;
	return good;
}

int main()
{
	fill((int*)res, (int*)res + 2 * maxn, 3); // 1 - loose, 2 - win, 3 - loop
	cin >> n;
	for (int i = 0; i < maxseg; ++i)
		mod_pos[i] = (i) % n;
	for (int i = 0; i < maxseg; ++i)
		mod_neg[i] = ((-i) % n + n) % n;
	res[0][1] = 1;
	res[1][1] = 1;
	for (int j = 0; j < 2; ++j)
	{
		cin >> k[j];
		for (int i = 0; i < k[j]; ++i)
			cin >> a[j][i];
	}

	iterate_win(1, 0);
	iterate_win(1, 1);
	while (global_lose());
	for (int j = 0; j < 2; ++j)
	{
		for (int i = 2; i <= n; ++i)
		{
			if (res[j][i] == 1)
				cout << "Lose ";
			else if (res[j][i] == 2)
				cout << "Win ";
			else
				cout << "Loop ";
		}
		cout << '\n';
	}
	return 0;
}
/*
7000
3 1 2 3
1 1

*/


#define _CRT_SECURE_NO_WARNINGS
#include <vector>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <queue>
#include <math.h>
#include <numeric>
#include <map>
#include <set>
#include <stdio.h>
#include <complex>
#define ll long long
#define ff first
#define ss second
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pib pair<int, bool>
#define pdd pair<double, double>
#define pss pair<string, string>
#define ull unsigned long long
#pragma comment(linker, "/STACK:251777215")
using namespace std;
const ll maxn = 10011;
const ll maxk = 10;
const ll maxlen = 2502;
const ll maxseg = 262144;
const ll mod = 1e9 + 7;
const double pi = 3.141592653589793238462643383279502884;
const double eps = 1e-5;

int n, k[2];
int a[2][maxn];
int res[2][maxn];
int last[2][maxn];
int opp[] = { 1, 0 };
int mod_pos[maxseg];

void iterate_win(int pos, int ind);

int get_win(int cur, int add)
{
	return mod_pos[cur - add + 10 * n];
}

void try_win(int pos, int ind)
{
	for (int i = 0; i < k[ind]; ++i)
	{
		int to = get_win(pos, a[ind][i]);
		last[ind][to]--;
		if (last[ind][to] == 0)
			res[ind][to] = 1, iterate_win(pos, opp[ind]);
	}
}

void iterate_win(int pos, int ind)
{
	for (int i = 0; i < k[ind]; ++i)
	{
		int to = get_win(pos, a[ind][i]);
		if (res[ind][to] == 3)
		{
			res[ind][to] = 2;
			try_win(to, opp[ind]);
		}
	}
}

int main()
{
	fill((int*)res, (int*)res + 2 * maxn, 3); // 1 - loose, 2 - win, 3 - loop
	cin >> n;
	res[0][1] = 1;
	res[1][1] = 1;
	for (int j = 0; j < 2; ++j)
	{
		cin >> k[j];
		for (int i = 0; i < k[j]; ++i)
			cin >> a[j][i];
	}
	for (int i = 1; i < maxseg; ++i)
		mod_pos[i] = (i - 1) % n + 1;
	for (int i = 1; i <= n; ++i)
		for (int j = 0; j < 2; ++j)
			last[j][i] = k[j];
	last[0][1] = 0;
	last[1][1] = 0;
	iterate_win(1, 0);
	iterate_win(1, 1);

	for (int j = 0; j < 2; ++j)
	{
		for (int i = 2; i <= n; ++i)
		{
			if (res[j][i] == 1)
				cout << "Lose ";
			else if (res[j][i] == 2)
				cout << "Win ";
			else
				cout << "Loop ";
		}
		cout << '\n';
	}
	return 0;
}
/*
7000
3 1 2 3
1 1

*/


#define _CRT_SECURE_NO_WARNINGS
#include <vector>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <queue>
#include <math.h>
#include <numeric>
#include <map>
#include <set>
#include <stdio.h>
#include <complex>
#define ll long long
#define ff first
#define ss second
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pib pair<int, bool>
#define pdd pair<double, double>
#define pss pair<string, string>
#define ull unsigned long long
#pragma comment(linker, "/STACK:251777215")
using namespace std;
const ll maxn = 10011;
const ll maxk = 10;
const ll maxlen = 2502;
const ll maxseg = 262144;
const ll mod = 1e9 + 7;
const double pi = 3.141592653589793238462643383279502884;
const double eps = 1e-5;

int n, k[2];
int a[2][maxn];
int res[2][maxn];
int last[2][maxn];
int opp[] = { 1, 0 };
int mod_pos[maxseg];

void iterate_win(int pos, int ind);

int get_win(int cur, int add)
{
	return mod_pos[cur - add + 10 * n];
}

void try_win(int pos, int ind)
{
	for (int i = 0; i < k[ind]; ++i)
	{
		int to = get_win(pos, a[ind][i]);
		last[ind][to]--;
		if (last[ind][to] == 0)
			res[ind][to] = 1, iterate_win(to, opp[ind]);
	}
}

void iterate_win(int pos, int ind)
{
	for (int i = 0; i < k[ind]; ++i)
	{
		int to = get_win(pos, a[ind][i]);
		if (res[ind][to] == 3)
		{
			res[ind][to] = 2;
			try_win(to, opp[ind]);
		}
	}
}

int main()
{
	fill((int*)res, (int*)res + 2 * maxn, 3); // 1 - loose, 2 - win, 3 - loop
	cin >> n;
	res[0][1] = 1;
	res[1][1] = 1;
	for (int j = 0; j < 2; ++j)
	{
		cin >> k[j];
		for (int i = 0; i < k[j]; ++i)
			cin >> a[j][i];
	}
	for (int i = 1; i < maxseg; ++i)
		mod_pos[i] = (i - 1) % n + 1;
	for (int i = 1; i <= n; ++i)
		for (int j = 0; j < 2; ++j)
			last[j][i] = k[j];
	last[0][1] = 0;
	last[1][1] = 0;
	iterate_win(1, 0);
	iterate_win(1, 1);

	for (int j = 0; j < 2; ++j)
	{
		for (int i = 2; i <= n; ++i)
		{
			if (res[j][i] == 1)
				cout << "Lose ";
			else if (res[j][i] == 2)
				cout << "Win ";
			else
				cout << "Loop ";
		}
		cout << '\n';
	}
	return 0;
}
/*
7000
3 1 2 3
1 1

*/


#include <vector>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstring>
#include <limits>
#include <climits>
#include <cstdio>
#include <numeric>
#include <fstream>
#define ll long long
#define Fori(x) for(int i=0;i<x;i++)
#define Forj(x) for(int j=0;j<x;j++)
#define For1i(x) for(int i=1;i<=x;i++)
#define For1j(x) for(int j=1;j<=x;j++)
#define PI pair<int,int>

using namespace std;
const int INF = 2147483647;
const int mod = 1e9+7;
const double pi = acos(-1.0);

int a[2][7777];
int dp[2][7777];
int m[2];
int n;
struct node
{
	int p;
	int ind;
	int flag;
	node(int pp=0,int iind=0,int fflag=0){p=pp;ind=iind;flag=fflag;}
};
queue<node> que;
void work()
{
	dp[0][1] = -m[0];
	dp[1][1] = -m[1];
	que.push(node(0,1,-m[0]));
	que.push(node(1,1,-m[1]));
	while(!que.empty())
	{
		node tmp = que.front();
		que.pop();
		if(tmp.flag<0&&tmp.flag!=-m[tmp.p])
			continue;
		int p = tmp.p^1;
		int flag;
		if(tmp.flag<0)
			flag = 1;
		else
			flag = -1;
		Fori(m[p])
		{
			int ind = tmp.ind-a[p][i];
			if(ind<=0) ind+=n;
			if(dp[p][ind]==1||dp[p][ind]==-m[p])
				continue;
			if(flag==1)
				dp[p][ind] = flag;
			else
				dp[p][ind]--;
			if(dp[p][ind]==1||dp[p][ind]==-m[p])
			que.push(node(p,ind,dp[p][ind]));
		}

	}

}

void prin(int flag,int p)
{
	 if(flag==1)
		cout<<"Win ";
	else if(flag==-m[p])
		cout<<"Lose ";
	else
		cout<<"Loop ";
}
int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	cin>>n;
	cin>>m[0];
	Fori(m[0])
		cin>>a[0][i];
	cin>>m[1];
	Fori(m[1])
		cin>>a[1][i];
	work();
	for(int p=0;p<2;p++)
	{
		for(int i=2;i<=n;i++)
			prin(dp[p][i],p);
		cout<<endl;
	}
	return 0;
}


#include <stdio.h>
#include <iostream>
#include <math.h>
#include <vector>
#include <string>
#include <conio.h>
#include <algorithm>

using namespace std;

#define NMAX 10000

typedef long long ll;
typedef long double ld;

int n, m, k;
int a[NMAX], b[NMAX];
int g[NMAX][2];
int cnt[NMAX][2];
int nw[NMAX][2];

void main() {
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);
	cin >> k;
	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> a[i];
	}
	cin >> m;
	for (int i = 0; i < m; i++) {
		cin >> b[i];
	}
	sort(a, a + n);
	sort(b, b + m);
	nw[0][0] = 1;
	nw[0][1] = 1;
	g[0][0] = 2;
	g[0][1] = 2;
	bool need_do = true;
	while (need_do) {
		need_do = false;
		for (int i = 0; i < k; i++) {
			if (nw[i][0] == 1) {
				nw[i][0] = 2;
				if (g[i][0] == 2) {
					for (int j = 0; j < m; j++) {
						if (g[(i-b[j]+k)%k][1] == 0) {
							nw[(i-b[j]+k)%k][1] = 1;
							need_do = true;
							g[(i-b[j]+k)%k][1] = 1;
						}
					}
				}
				else {
					for (int j = 0; j < m; j++) {
						cnt[(i-b[j]+k)%k][1]++;
						if (cnt[(i-b[j]+k)%k][1] == m) {
							nw[(i-b[j]+k)%k][1] = 1;
							need_do = true;
							g[(i-b[j]+k)%k][1] = 2;
						}
					}
				}
			}
			if (nw[i][1] == 1) {
				/**/
				nw[i][1] = 2;
				if (g[i][1] == 2) {
					for (int j = 0; j < n; j++) {
						if (g[(i-a[j]+k)%k][0] == 0) {
							nw[(i-a[j]+k)%k][0] = 1;
							need_do = true;
							g[(i-a[j]+k)%k][0] = 1;
						}
					}
				}
				else {
					for (int j = 0; j < n; j++) {
						cnt[(i-a[j]+k)%k][0]++;
						if (cnt[(i-a[j]+k)%k][0] == n) {
							nw[(i-a[j]+k)%k][0] = 1;
							need_do = true;
							g[(i-a[j]+k)%k][0] = 2;
						}
					}
				}
				/**/
			}
		}
	}
	for (int i = 1; i < k; i++) {
		if (g[i][0] == 0)
			cout << "Loop ";
		else if (g[i][0] == 1)
			cout << "Win ";
		else
			cout << "Lose ";
	}
	cout << "\n";
	for (int i = 1; i < k; i++) {
		if (g[i][1] == 0)
			cout << "Loop ";
		else if (g[i][1] == 1)
			cout << "Win ";
		else
			cout << "Lose ";
	}
	cout << "\n";
}


#include <bits/stdc++.h>
#define fastio() ios_base::sync_with_stdio(false),cin.tie(NULL)
using namespace std;

int N;
int cntMv[2];
int moves[2][7003];
int canWin[2][7003];
int inDegree[2][7003];

const int LOSE = 1;
const int LOOP = 0;
const int WIN = 2;
const int NOTDET = 3;

int trans(int x){
    return x<0 ? x+N : x;
}
void go(int turn, int pos){
    for(int i = 0; i < cntMv[turn^1]; i++){
        int mov = moves[turn^1][i];
        int prev = trans(pos-mov);
        if(prev == 0 || canWin[turn^1][prev] != LOOP) continue;
        if(canWin[turn][pos] == LOSE) {
            canWin[turn^1][prev] = WIN;
            go(turn^1,prev);
        }
        else if(canWin[turn][pos] == WIN){
            inDegree[turn^1][prev]--;
            if(inDegree[turn^1][prev]==0) canWin[turn^1][prev] = LOSE, go(turn^1,prev);
        }
    }
}
int main() {
    fastio();
    cin >> N;
    cin >> cntMv[0];
    for(int i = 0 ; i < cntMv[0]; i++)
        cin >> moves[0][i];

    cin >> cntMv[1];
    for(int i = 0 ; i < cntMv[1]; i++)
        cin >> moves[1][i];

    for(int i = 0; i < 2; i++){
        for(int j = 0 ; j < N; j++){
            inDegree[i][j] = cntMv[i];
        }
    }

    canWin[0][0] = canWin[1][0] = LOSE;
    inDegree[0][0] = inDegree[1][0] = 0;
    go(0,0);
    go(1,0);

    for(int i = 0 ; i < 2; i++){
        for(int j = 1 ; j < N; j++){
            if(canWin[i][j] == WIN) cout << "Win ";
            else if(canWin[i][j] == LOOP) cout << "Loop ";
            else cout << "Lose ";

        }
        cout << "\n";
    }
    return 0;
}


#include <iostream>
#include <algorithm>
#include <vector>

#include <cstdlib>
#include <cstring>

using namespace std;

int N;
int cntMv[2];
int moves[2][7003];
int canWin[2][7003];
int inDegree[2][7003];

const int LOSE = 1;
const int LOOP = 0;
const int WIN = 2;
const int NOTDET = 3;

int trans(int x) {
	return x<0 ? x + N : x;
}
void go(int turn, int pos) {
	for (int i = 0; i < cntMv[turn ^ 1]; i++) {
		int mov = moves[turn ^ 1][i];
		int prev = trans(pos - mov);
		if (prev == 0 || canWin[turn ^ 1][prev] != LOOP) continue;
		if (canWin[turn][pos] == LOSE) {
			canWin[turn ^ 1][prev] = WIN;
			go(turn ^ 1, prev);
		}
		else if (canWin[turn][pos] == WIN) {
			inDegree[turn ^ 1][prev]--;
			if (inDegree[turn ^ 1][prev] == 0) canWin[turn ^ 1][prev] = LOSE, go(turn ^ 1, prev);
		}
	}
}
int main() {
	cin >> N;
	cin >> cntMv[0];
	for (int i = 0; i < cntMv[0]; i++)
		cin >> moves[0][i];

	cin >> cntMv[1];
	for (int i = 0; i < cntMv[1]; i++)
		cin >> moves[1][i];

	for (int i = 0; i < 2; i++) {
		for (int j = 0; j < N; j++) {
			inDegree[i][j] = cntMv[i];
		}
	}

	canWin[0][0] = canWin[1][0] = LOSE;
	inDegree[0][0] = inDegree[1][0] = 0;
	go(0, 0);
	go(1, 0);

	for (int i = 0; i < 2; i++) {
		for (int j = 1; j < N; j++) {
			if (canWin[i][j] == WIN) cout << "Win ";
			else if (canWin[i][j] == LOOP) cout << "Loop ";
			else cout << "Lose ";

		}
		cout << "\n";
	}
	return 0;
}

/*
using namespace std;
/*
	0 : Loop
	1 : Lose
	2 : Win
static int rick[7001], morty[7001];
static bool visited[7001];
vector<int> ricks_card, mortys_card;

int dfs(int index, bool flag)
{
	if (visited[index])
	{
		return 0;
	}
	visited[index] = true;

	for (size_t i = 0; i < length; i++)
	{
		if
	}
}

int main(int argc, const char *argv[])
{
	int n = 0, m = 0;

	cin >> n;

	memset(rick, 0, sizeof(rick));
	memset(morty, 0, sizeof(morty));

	cin >> m;

	for (int i = 0; i < m; i++)
	{
		int temp = 0;
		cin >> temp;
		ricks_card.push_back(temp);
	}

	cin >> m;

	for (int i = 0; i < m; i++)
	{
		int temp = 0;
		cin >> temp;
		mortys_card.push_back(temp);
	}

	sort(ricks_card.begin(), ricks_card.end());
	sort(mortys_card.begin(), mortys_card.end());

	for (size_t i = 0; i < ricks_card.size(); i++)
	{
		rick[(-ricks_card[i] + n) % n] = 2;
		morty[(-ricks_card[i] + n) % n] = 1;
	}
	for (size_t i = 0; i < mortys_card.size(); i++)
	{
		morty[(-mortys_card[i] + n) % n] = 2;
		rick[(-mortys_card[i] + n) % n] = 1;
	}

	return 0;
}
*/