CodeEff/ECCO huggingface dataset:
# Original solution
import sys
input = sys.stdin.readline


class BIT:
    def __init__(self, n):
        self.size = n
        self.array = [0] * (n + 1)
        self.e = [0] * n

    def sum(self, i):
        s = 0
        tmp = i
        while tmp > 0:
            s += self.array[tmp]
            tmp -= tmp & -tmp
        return s

    def add(self, i, x):
        self.e[i] += x
        tmp = i + 1
        while tmp <= self.size:
            self.array[tmp] += x
            tmp += tmp & -tmp


def main():
    n, q = map(int, input().split())
    *C, = map(lambda x: int(x) - 1, input().split())
    P = [0] * n
    N = [0] * n
    for i in range(n)[::-1]:
        if P[C[i]]:
            N[i] = P[C[i]]
        P[C[i]] = i
    F = [0] * n
    B = BIT(n)
    for i in range(n):
        if F[C[i]] == 0:
            B.add(i, 1)
            F[C[i]] = 1
    XY = sorted([(tuple(map(int, input().split())), j) for j in range(q)])
    a = 0
    lst = [0] * q
    for (x, y), j in XY:
        for i in range(a, x - 1):
            B.add(N[i], 1)
        a = x - 1
        lst[j] = B.sum(y) - B.sum(x - 1)
    print(*lst, sep="\n")


main()


# Optimized solution
import sys
input = sys.stdin.readline


class BIT:
    def __init__(self, n):
        self.array = [0] * (n + 1)
        self.size = n

    def sum(self, i):
        s = 0
        tmp = i
        while tmp > 0:
            s += self.array[tmp]
            tmp -= tmp & -tmp
        return s

    def add(self, i, x):
        tmp = i + 1
        while tmp <= self.size:
            self.array[tmp] += x
            tmp += tmp & -tmp


def main():
    n, q = map(int, input().split())
    *C, = map(lambda x: int(x) - 1, input().split())
    P = [0] * n
    N = [None] * n
    for i in range(n)[::-1]:
        if P[C[i]]:
            N[i] = P[C[i]]
        P[C[i]] = i
    F = [0] * n
    B = BIT(n)
    for i in range(n):
        if F[C[i]] == 0:
            B.add(i, 1)
            F[C[i]] = 1
    XY = [tuple(map(int, input().split())) for j in range(q)]
    ids = list(range(q))
    ids.sort(key=lambda j: XY[j][0])
    a = 0
    lst = [0] * q
    for j in ids:
        x, y = XY[j]
        for i in range(a, x - 1):
            if N[i]:
                B.add(N[i], 1)
        a = x - 1
        lst[j] = B.sum(y) - B.sum(x - 1)
    print(*lst, sep="\n")


main()
# Original solution
class BIT:
    def __init__(self, n):
        self.array = [0] * (n + 1)
        self.size = n

    def sum(self, i):
        s = 0
        tmp = i
        while tmp > 0:
            s += self.array[tmp]
            tmp -= tmp & -tmp
        return s

    def add(self, i, x):
        tmp = i + 1
        while tmp <= self.size:
            self.array[tmp] += x
            tmp += tmp & -tmp


def main():
    n, q = map(int, input().split())
    *C, = map(lambda x: int(x) - 1, input().split())
    P = [0] * n
    N = [None] * n
    for i in range(n)[::-1]:
        if P[C[i]]:
            N[i] = P[C[i]]
        P[C[i]] = i
    F = [0] * n
    B = BIT(n)
    for i in range(n):
        if F[C[i]] == 0:
            B.add(i, 1)
            F[C[i]] = 1
    XY = [tuple(map(int, input().split())) for j in range(q)]
    ids = list(range(q))
    ids.sort(key=lambda j: XY[j][0])
    a = 0
    lst = [0] * q
    for j in ids:
        x, y = XY[j]
        for i in range(a, x - 1):
            if N[i]:
                B.add(N[i], 1)
        a = x - 1
        lst[j] = B.sum(y) - B.sum(x - 1)
    print(*lst, sep="\n")


main()


# Optimized solution
import sys
input = sys.stdin.readline


class BIT:
    def __init__(self, n):
        self.array = [0] * (n + 1)
        self.size = n

    def sum(self, i):
        s = 0
        tmp = i
        while tmp > 0:
            s += self.array[tmp]
            tmp -= tmp & -tmp
        return s

    def add(self, i, x):
        tmp = i + 1
        while tmp <= self.size:
            self.array[tmp] += x
            tmp += tmp & -tmp


n, q = map(int, input().split())
*C, = map(lambda x: int(x) - 1, input().split())
P = [0] * n
N = [None] * n
for i in range(n)[::-1]:
    if P[C[i]]:
        N[i] = P[C[i]]
    P[C[i]] = i
F = [0] * n
B = BIT(n)
for i in range(n):
    if F[C[i]] == 0:
        B.add(i, 1)
        F[C[i]] = 1
XY = [tuple(map(int, input().split())) for j in range(q)]
ids = list(range(q))
ids.sort(key=lambda j: XY[j][0])
a = 0
lst = [0] * q
for j in ids:
    x, y = XY[j]
    for i in range(a, x - 1):
        if N[i]:
            B.add(N[i], 1)
    a = x - 1
    lst[j] = B.sum(y) - B.sum(x - 1)
print(*lst, sep="\n")
# Original solution
N,M,X,Y=list(map(int,input().split()))

x=list(map(int,input().split()))
y=list(map(int,input().split()))

x.sort()
y.sort()


if y[0]>x[N-1] and y[0]>X and x[N-1]<Y:
  print('No War')
else:
  print('War')

# Optimized solution
N,M,X,Y=list(map(int,input().split()))
 
x=list(map(int,input().split()))
y=list(map(int,input().split()))
 
x.sort()
y.sort()
 
 
for i in range(x[N-1]+1,y[0]+1):
  if i>X and i<=Y:
    print('No War')
    exit()
print('War')
# Original solution
# coding: utf-8
N, M, X, Y = list(map(int, input().split()))

x = max(list(map(int, input().split())))
y = min(list(map(int, input().split())))

ans = "War"
for z in range(X+1, Y+1):
    if x < z <= y:
        ans = "No War"
print(ans)

# Optimized solution
# coding: utf-8
N, M, X, Y = list(map(int, input().split()))

lst_x = list(map(int, input().split()))
lst_x.append(X)
lst_y = list(map(int, input().split()))
lst_y.append(Y)

x = max(lst_x)
y = min(lst_y)

ans = "War"
if x < y:
        ans = "No War"
print(ans)
# Original solution
n,m,X,Y = list(map(int,input().split()))
x = max(list(map(int,input().split())))
y = min(list(map(int,input().split())))
if X<x<y<=Y:print('No War')
else:print('War')

# Optimized solution
n,m,x,y = list(map(int,input().split()))
x_max = sorted(list(map(int,input().split())))[-1]
y_min = sorted(list(map(int,input().split())))[0]

if x<=x_max<y_min<=y:
    print('No War')
else:
    print('War')
# Original solution
n,m,x,y=list(map(int,input().split()));a,b=list(map(int,input().split())),list(map(int,input().split()));a.sort();b.sort();print(("No War"if max(a[-1],x)<min(y,b[0])else"War"))

# Optimized solution
n,m,x,y=list(map(int,input().split()))
x=list(map(int,input().split()))+[x]
y=list(map(int,input().split()))+[y]
if max(x)<min(y):print("No War")
else:print("War")
# Original solution
# 2019-11-10 15:45:20(JST)
import sys
# import collections
# import math
# from string import ascii_lowercase, ascii_uppercase, digits
# from bisect import bisect_left as bi_l, bisect_right as bi_r
# import itertools
# from functools import reduce
# import operator as op
# from scipy.misc import comb # float
# import numpy as np 

def main():
    n, m, X, Y = (int(i) for i in sys.stdin.readline().split())
    x = [int(x) for x in sys.stdin.readline().split()]
    y = [int(y) for y in sys.stdin.readline().split()]
    max_x = max(x + [X])
    min_y = min(y + [Y])
    if Y - X < 1 or min_y - max_x < 1:
        ans = 'War'
    else:
        ans = 'No War'
    
    print(ans)
    
if __name__ == "__main__":
    main()


# Optimized solution
import sys

n, m, X, Y = list(map(int, sys.stdin.readline().split()))
*x, = list(map(int, sys.stdin.readline().split()))
*y, = list(map(int, sys.stdin.readline().split()))

def main():
    return 'No War' if max(X, max(x)) < min(Y, min(y)) else 'War'

if __name__ == '__main__':
    ans = main()
    print(ans)
# Original solution
N,M,X,Y=list(map(int,input().split()))
x=max(list(map(int,input().split())))
y=min(list(map(int,input().split())))
P=0
for i in range(X+1,Y+1) :
  if X < i and i <=Y and x < i and i <= y :
    print("No War")
    break
else:
  print("War")

# Optimized solution
N,M,X,Y=list(map(int,input().split()))
x=max(list(map(int,input().split())))
y=min(list(map(int,input().split())))
P=0
for i in range(X+1,Y+1) :
  if  x < i and i <= y :
    print("No War")
    break
else:
  print("War")
# Original solution
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(10000)


def read_int():
    return int(input())


def read_int_n():
    return list(map(int, input().split()))


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(N, M, X, Y, x, y):
    mx = max(x)
    my = min(y)

    error_print(mx, my)
    if mx < my and (my > X and mx < Y):
        return 'No War'
    return 'War'


def main():
    N, M, X, Y = read_int_n()
    x = read_int_n()
    y = read_int_n()
    print(slv(N, M, X, Y, x, y))


if __name__ == '__main__':
    main()


# Optimized solution
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(10000)


def read_int():
    return int(input())


def read_int_n():
    return list(map(int, input().split()))


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(N, M, X, Y, x, y):
    mx = max(x)
    my = min(y)

    error_print(mx, my)
    if mx >= my:
        return 'War'

    for i in range(mx+1, my+1):
        if X < i <= Y:
            return 'No War'
    return 'War'


def main():
    N, M, X, Y = read_int_n()
    x = read_int_n()
    y = read_int_n()
    print(slv(N, M, X, Y, x, y))


if __name__ == '__main__':
    main()
# Original solution
n,m,x,y = list(map(int,input().split()))
xl = list(map(int,input().split()))
yl = list(map(int,input().split()))
xl.sort(reverse = True)
yl.sort()

if xl[0] < yl[0]:
    p = yl[0]
    while p > x:
        if x < p and p <= y:
            print('No War')
            exit(0)
    print('War')
else:
    print('War')

# Optimized solution
n,m,x,y = list(map(int,input().split()))
xl = list(map(int,input().split()))
yl = list(map(int,input().split()))
xl.append(x)
yl.append(y)
xl.sort()
yl.sort()

if xl[-1] < yl[0]:
    print('No War')
else:
    print('War')
# Original solution
n,m,X,Y = list(map(int, input().split()))
x = list(map(int, input().split()))
y = list(map(int, input().split()))
x.append(X)
y.append(Y)
x.sort()
y.sort()
if x[-1] < y[0]:
        print("No War")
else:
        print("War")

# Optimized solution
n,m,X,Y = list(map(int, input().split()))
x = list(map(int, input().split()))
y = list(map(int, input().split()))
x.append(X)
y.append(Y)
if max(x) < min(y):
        print("No War")
else:
        print("War")
# Original solution
n,m,x,y=list(map(int,input().split()))
xl=list(map(int,input().split()))
yl=list(map(int,input().split()))

xl.append(x)
yl.append(y)
if max(xl) < min(yl) and x < y:
    print('No War')
else:
    print('War')

# Optimized solution
n,m,x,y=list(map(int,input().split()))
xl=list(map(int,input().split()))
yl=list(map(int,input().split()))

xl.append(x)
yl.append(y)
if max(xl) < min(yl):
    print('No War')
else:
    print('War')
# Original solution
n,m,x,y = list(map(int,input().split()))
xs = max(list(map(int,input().split())))
ys = min(list(map(int,input().split())))
ans = 'War'
if xs+1 <= ys:
    for i in range(xs+1,ys+1):
        if x < i <= y:
            ans = 'No War'
            break
print(ans)

# Optimized solution
n, m, x, y = list(map(int, input().split()))
xs = list(map(int, input().split()))
ys = list(map(int, input().split()))
xs.append(x)
ys.append(y)
print(('No War' if max(xs) < min(ys) else 'War'))
# Original solution
N,M,X,Y = list(map(int, input().split()))
Xx = [int(x) for x in input().split()]
Yy = [int(x) for x in input().split()]

mxx = max(Xx)
mny = min(Yy)
if mxx < mny and X < mny and mxx < Y:
    print("No War")
else:
    print("War")


# Optimized solution
N,M,X,Y = list(map(int, input().split()))
Xx = [int(x) for x in input().split()]
Yy = [int(x) for x in input().split()]

def f():
    mxx = max(Xx)
    mny = min(Yy)
    for z in range(Y, X, -1):
        if mxx < z and z <= mny:
            return "No War"
    return "War"
print((f()))
# Original solution
n,m,x,y= list(map(int,input().split()))
lix=list(map(int,input().split()))
liy=list(map(int,input().split()))
lix.append(x)
liy.append(y)
if max(lix) < min(liy):
  print("No War")
else:
  print("War")


# Optimized solution
n,m,x,y= list(map(int,input().split()))
lix=list(map(int,input().split()))
liy=list(map(int,input().split()))
lix.append(x)
liy.append(y)
lix.sort()
liy.sort()
if lix[n] < liy[0]:
  print("No War")
else:
  print("War")
# Original solution
N,M,X,Y=list(map(int,input().split()))
x=list(map(int,input().split()))
y=list(map(int,input().split()))
can=False
for Z in range(X+1,Y+1):
    if max(x)<Z<=min(y):
        can=True
if can:
    print("No War")
else:
    print("War")

# Optimized solution
N,M,X,Y=list(map(int,input().split()))
x=list(map(int,input().split()))
y=list(map(int,input().split()))
xmin=max(x)
ymin=min(y)
for i in range(X+1,Y+1):
    if xmin<i<=ymin:
        print("No War")
        quit()
print("War")
# Original solution
N, M, X, Y = list(map(int, input().split()))
x = list(map(int, input().split()))
y = list(map(int, input().split()))
ans = 1

if X >= Y:
    ans = 1
elif X < Y:
    z = list(range(X+1, Y+1))
    for i in z:
        if max(x) < i and i <= min(y):
            ans = 0
     
    
if ans == 0:
     print('No War')
        
else:
    print('War')

# Optimized solution
N, M, X, Y = list(map(int, input().split()))
x = list(map(int, input().split()))
y = list(map(int, input().split()))

zx = list(range(max(x)+1,101))
zy = list(range(-100, min(y)+1))
kanou = set(zx) & set(zy)
if len(kanou) == 0:
    print('War')
else:
    for i in kanou:
        if X < i <= Y:
            print('No War')
            break
    else:
        print('War')
# Original solution
if __name__ == '__main__':
	n,m,X,Y = list(map(int,input().split()))
	x = list(map(int,input().split()))
	y = list(map(int,input().split()))
 
	x_max = max(x)
	y_min = min(y)

	flg = False
	for Z in range(X+1,Y+1):
		if x_max < Z <= y_min:
			flg = True
			break

	if flg:
		print("No War")
	else:
		print("War")

# Optimized solution
if __name__ == '__main__':
	n,m,x,y = list(map(int,input().split()))
	X = list(map(int,input().split()))
	Y = list(map(int,input().split()))
	X.sort()
	Y.sort()

	flg = False
	#xの場所がYのFROM-に入っていないこと
	if (Y[0] <= x):
		flg = True
	#yの場所がXのFROM-に入っていないこと
	elif (y <= X[n-1]):
		flg = True
	#Xの右端とYの左端が交わらないこと
	elif (X[n-1] >= Y[0]):
		flg = True
 
	if flg:
		print("War")
	else:
		print("No War")
# Original solution
def nl(): return list(map(int, input().split()))
# print('Yes' if a else 'No')

N, M, X, Y = nl()
x = nl()
y = nl()

flg = False
for i in range(X + 1, Y + 1):
    if max(x) < i and i <= min(y):
        flg = True
        break

print(('No War' if flg else 'War'))





# Optimized solution
N, M, X, Y = list(map(int, input().split()))
x = list(map(int, input().split())) + [X]
y = list(map(int, input().split())) + [Y]

x_max = max(x)
y_min = min(y)

if x_max >= y_min:
    war_happen = True
else:
    war_happen = False

print(('War' if war_happen else 'No War'))
# Original solution
n, m, xx, yy = list(map(int, input().split()))
x = sorted(list(map(int, input().split())))
y = sorted(list(map(int, input().split())))
if x[-1] < y[0]:
    if xx < y[0] and yy > x[-1]:
        print("No War")
    else:
        print("War")
else:
    print("War")

# Optimized solution
n, m, xx, yy = list(map(int, input().split()))
x = sorted(list(map(int, input().split())))
y = sorted(list(map(int, input().split())))
for i in range(xx + 1, yy):
    if x[-1] < i <= y[0]:
        print("No War")
        break
else:
    print("War")
# Original solution
A=list(map(int,input().split()))
X=list(map(int,input().split()))
Y=list(map(int,input().split()))

x=max(X)
y=min(Y)

if x<y and A[2]<A[3] and A[2]<y and x<A[3]:
    print("No War")
else:
    print("War")


# Optimized solution
N,M,X,Y=list(map(int,input().split()))
x=list(map(int,input().split()))
y=list(map(int,input().split()))

x=x+[X]
y=y+[Y]

if max(x)<min(y):
    print("No War")
else:
    print("War")
# Original solution
N,M,X,Y = [int(x) for x in input().split()]

xl = [int(x) for x in input().split()]
yl = [int(x) for x in input().split()]

xl.sort()
yl.sort()

xmax = xl[-1]
ymin = yl[0]

war = 'War'
nowar = 'No War'

isOk = False

if xmax < ymin:
    isOk = True
else:
    print(war)
    exit()


if X < ymin and Y > xmax:
    isOk = True
else:
    print(war)
    exit()

print(nowar)


# Optimized solution
N,M,X,Y = [int(x) for x in input().split()]

xl = [int(x) for x in input().split()]
yl = [int(x) for x in input().split()]

xl.sort()
yl.sort()

xmax = xl[-1]
ymin = yl[0]

war = 'War'
nowar = 'No War'

kyokai = xmax + 1

isOk = False

if xmax < ymin:
    isOk = True
else:
    print(war)
    exit()

if kyokai <= ymin:
    pass
else:
    print(war)
    exit()

if X < kyokai:
    pass
else:
    print(war)
    exit()

if kyokai <= Y:
    pass
else:
    print(war)
    exit()


print(nowar)
# Original solution
def bogosort(l):
  import random
  while 1:
    random.shuffle(l)
    for i in range(1,len(l)):
      if l[i]<l[i-1]:
        break
    else:
      return l
i=lambda:list(map(int,input().split()))
n,m,x,y=i()
if bogosort(i()+[x])[-1]<bogosort(i()+[y])[0]:
    print('No War')
else:
    print('War')

# Optimized solution
(*z,X,Y),x,y=eval('map(int,input().split()),'*3);print(('No War'[3*(max(X,*x)>=min(Y,*y)):]))
# Original solution
def main():
    import sys
    input = sys.stdin.readline
    n, m, x, y = list(map(int, input().rstrip('\n').split()))
    X = list(map(int, input().rstrip('\n').split()))
    Y = list(map(int, input().rstrip('\n').split()))
    mx = max(X)
    my = min(Y)
    for z in range(x + 1, y + 1):
        if mx < z <= my:
            print("No War")
            exit()
    print("War")


if __name__ == '__main__':
    main()


# Optimized solution
def slove():
    import sys
    input = sys.stdin.readline
    n, m, x, y = list(map(int, input().rstrip('\n').split()))
    mx = max(list(map(int, input().rstrip('\n').split())))
    my = min(list(map(int, input().rstrip('\n').split())))
    for i in range(x + 1, y + 1):
        if mx < i <= my:
            print("No War")
            exit()
    print("War")


if __name__ == '__main__':
    slove()
# Original solution
n,m,x,y = list(map(int,input().split()))

x1 = max([int(i) for i in input().split()]) + 1
y1 = min([int(i) for i in input().split()])

if x1 <= y1 and x1 <= y and y1 > x:
    print('No War')
else:
    print('War')

# Optimized solution
n,m,x,y = list(map(int,input().split()))

x1 = max(list(map(int,input().split()))) + 1
y1 = min(list(map(int,input().split())))

if x1 <= y1 and x1 <= y and y1 > x:
    print('No War')
else:
    print('War')
# Original solution
def m_i():
    return list(map(int, input().split()))
N,M,X,Y = m_i()
Z = max(m_i()) + 1
min_y = min(m_i())
print(("No War" if (X < Z) and (Z <= min_y) and (Z <= Y) else "War"))

# Optimized solution
def m_i():
    return list(map(int, input().split()))
N,M,X,Y = m_i()
Z = max(m_i()) + 1
min_y = min(m_i())
print(("No War" if (X < Z) and (Z <= min(min_y,Y)) else "War"))
# Original solution
N, M, X, Y = list(map(int, input().split()))
x = list(map(int, input().split()))
y = list(map(int, input().split()))

ans = 'War'

for z in range(X+1, Y+1):
    if len(list([x for x in x if x < z])) == N and len(list([x for x in y if x >= z])) == M:
        ans = 'No War'
        break

print(ans)


# Optimized solution
N, M, X, Y = list(map(int, input().split()))
x = list(map(int, input().split()))
y = list(map(int, input().split()))

ans = 'War'

for z in range(X+1, Y+1):
    if max(x) < z and min(y) >= z:
        ans = 'No War'
        break

print(ans)
# Original solution
n, m, x, y = list(map(int, input().split()))
xs = list(map(int, input().split()))
ys = list(map(int, input().split()))
print(("No War" if max([x] + list(xs)) < min([y] + list(ys)) else "War"))

# Optimized solution
n, m, x, y = list(map(int, input().split()))
xs = list(map(int, input().split()))
ys = list(map(int, input().split()))
print(("No War" if max(x, *xs) < min(y, *ys) else "War"))
# Original solution
n,m,x,y = list(map(int,input().split()))
X = list(map(int,input().split()))
Y = list(map(int,input().split()))
X = sorted(X)
Y = sorted(Y)
for i in range(x+1,y+1):
    if X[-1]<i and Y[0]>=i:
        print('No War')
        exit()
print('War')


# Optimized solution
n,m,x,y = list(map(int,input().split()))
a = list(map(int,input().split()))
b = list(map(int,input().split()))
a = max(a)
b = min(b)
for z in range(x+1,y+1):
    if a < z <= b:
        print('No War')
        exit()
print('War')
# Original solution
N,M,X,Y = list(map(int,input().split()))
x_list = list(map(int,input().split()))
y_list = list(map(int,input().split()))

for i in range(max(x_list)+1,min(y_list)+1):
  if i > X and i <= Y and max(x_list) < i and min(y_list) >= i:
    print('No War')
    break
else:
  print('War')

# Optimized solution
n,m,X,Y = list(map(int,input().split()))
x = sorted(map(int,input().split())) + [X]
y = sorted(map(int,input().split())) + [Y]
print(("No War" if max(x) < min(y) else "War"))
# Original solution
N, M, X, Y = list(map(int, input().split()))
xlist = list(map(int, input().split()))
ylist = list(map(int, input().split()))
xmax = max(xlist)
ymin = min(ylist)
if xmax<ymin:
    for z in range(xmax+1, ymin+1):
        if X<z<=Y:
            print("No War")
            break
    else:
        print("War")
else:
    print("War")


# Optimized solution
N, M, X, Y = list(map(int, input().split()))
xs = list(map(int, input().split()))
xs.append(X)
ys = list(map(int, input().split()))
ys.append(Y)
xmax = max(xs)
ymin=  min(ys)
if xmax<ymin:
    print("No War")
else:
    print("War")
# Original solution
N, M, X, Y = list(map(int,input().split()))
x = list(map(int,input().split()))
y = list(map(int,input().split()))

max_x = max(x)
min_y = min(y)
for i in range(X+1, Y+1):
  if(max_x < i <= min_y):
    print("No War")
    break
else:
  print("War")

# Optimized solution
N, M, X, Y = list(map(int,input().split()))
x = sorted(list(map(int,input().split())))
y = sorted(list(map(int,input().split())))

for i in range(X+1, Y+1):
  if(x[-1] < i <= y[0]):
    print("No War")
    break
else:
  print("War")
# Original solution
n, m, X, Y = list(map(int, input().split()))
x = list(map(int, input().split()))
y = list(map(int, input().split()))

x.sort(reverse=True)
xmax = max(x[0], X)
y.sort()
ymin = min(y[0], Y)

if ymin - xmax > int(0):
    print("No War")
else:
    print("War")


# Optimized solution
n, m, X, Y = list(map(int, input().split()))
x = list(map(int, input().split()))
y = list(map(int, input().split()))

x.sort(reverse=True)
xmax = max(x[0], X)
y.sort()
ymin = min(y[0], Y)

if ymin - xmax > 0:
    print("No War")
else:
    print("War")
# Original solution
N,M,X,Y = list(map(int, input().split()))
x = list(map(int, input().split()))
y = list(map(int, input().split()))

if(max(x) < min(y) and X < min(y) and max(x) < Y ):
  print("No War")
else:
  print("War")

# Optimized solution
N,M,X,Y = list(map(int, input().split()))
x = list(map(int, input().split()))
y = list(map(int, input().split()))

x.append(X)
y.append(Y)

if(max(x) < min(y)):
  print("No War")
else:
  print("War")