Not so long ago company R2 bought company R1 and consequently, all its developments in the field of multicore processors. Now the R2 laboratory is testing one of the R1 processors.

The testing goes in n steps, at each step the processor gets some instructions, and then its temperature is measured. The head engineer in R2 is keeping a report record on the work of the processor: he writes down the minimum and the maximum measured temperature in his notebook. His assistant had to write down all temperatures into his notebook, but (for unknown reasons) he recorded only m.

The next day, the engineer's assistant filed in a report with all the m temperatures. However, the chief engineer doubts that the assistant wrote down everything correctly (naturally, the chief engineer doesn't doubt his notes). So he asked you to help him. Given numbers n, m, min, max and the list of m temperatures determine whether you can upgrade the set of m temperatures to the set of n temperatures (that is add n - m temperatures), so that the minimum temperature was min and the maximum one was max.


-----Input-----

The first line contains four integers n, m, min, max (1 ≤ m < n ≤ 100; 1 ≤ min < max ≤ 100). The second line contains m space-separated integers t_{i} (1 ≤ t_{i} ≤ 100) — the temperatures reported by the assistant.

Note, that the reported temperatures, and the temperatures you want to add can contain equal temperatures.


-----Output-----

If the data is consistent, print 'Correct' (without the quotes). Otherwise, print 'Incorrect' (without the quotes).


-----Examples-----
Input
2 1 1 2
1

Output
Correct

Input
3 1 1 3
2

Output
Correct

Input
2 1 1 3
2

Output
Incorrect



-----Note-----

In the first test sample one of the possible initial configurations of temperatures is [1, 2].

In the second test sample one of the possible initial configurations of temperatures is [2, 1, 3].

In the third test sample it is impossible to add one temperature to obtain the minimum equal to 1 and the maximum equal to 3.

Source: codeforces | Difficulty: EASY
Tags: Implementation


Solutions:
import re
import inspect
from sys import argv, exit

def rstr():
	return input()

def rstrs(splitchar=' '):
	return [i for i in input().split(splitchar)]

def rint():
	return int(input())

def rints(splitchar=' '):
	return [int(i) for i in rstrs(splitchar)]

def varnames(obj, namespace=globals()):
	return [name for name in namespace if namespace[name] is obj]

def pvar(var, override=False):
	prnt(varnames(var), var)

def prnt(*args, override=False):
	if '-v' in argv or override:
		print(*args)
pq = []

def penq(s):
	if not isinstance(s, str):
		s = str(s)
	pq.append(s)

def pdump():
	s = '\n'.join(pq).encode()
	os.write(1, s)

def __starting_point():
	(timesteps, ast, mn, mx) = rints()
	to_add = timesteps - ast
	asts = rints()
	for t in asts:
		if t < mn or t > mx:
			print('Incorrect')
			return
	if mn not in asts:
		if to_add == 0:
			print('Incorrect')
			return
		else:
			to_add -= 1
	if mx not in asts:
		if to_add == 0:
			print('Incorrect')
			return
		else:
			to_add -= 1
	print('Correct')
__starting_point()


(n, m, mi, ma) = tuple(map(int, str.split(input())))
ts = tuple(map(int, str.split(input())))
if max(ts) > ma or min(ts) < mi:
	ans = 'Incorrect'
else:
	count = 2
	if mi in ts:
		count -= 1
	if ma in ts:
		count -= 1
	if n - m >= count:
		ans = 'Correct'
	else:
		ans = 'Incorrect'
print(ans)


([n, m, min_t, max_t], t) = (list(map(int, input().split())), list(map(int, input().split())))
(min_m, max_m) = (min(t), max(t))
if min_m >= min_t and max_m <= max_t and (n - m >= (min_m != min_t) + (max_m != max_t)):
	print('Correct')
else:
	print('Incorrect')


(n, m, mn, mx) = input().split()
(n, m, mn, mx) = (int(n), int(m), int(mn), int(mx))
diff = n - m
tem = [int(x) for x in input().split()]
flag = 0
check = 0
for x in tem:
	if x == mn or x == mx:
		flag = 1
	if x < mn or x > mx:
		check = 1
if not check:
	if diff >= 2:
		print('Correct')
	elif diff == 1 and flag:
		print('Correct')
	else:
		print('Incorrect')
else:
	print('Incorrect')


R = lambda : map(int, input().split())
(n, m, a, b) = R()
t = list(R())
print('Incorrect' if n - m == 1 and min(t) != a and (max(t) != b) or min(t) < a or max(t) > b else 'Correct')


(n, m, mini, maxi) = map(int, input().split())
reported_temps = list(map(int, input().split()))
can_add = n - m
has_max = False
has_min = False
flag = True
for element in reported_temps:
	if element > maxi or element < mini:
		print('Incorrect')
		flag = False
		break
	elif element == maxi:
		has_max = True
	elif element == mini:
		has_min = True
if flag:
	if has_max and has_min:
		print('Correct')
	elif has_max:
		if can_add >= 1:
			print('Correct')
		else:
			print('Incorrect')
	elif has_min:
		if can_add >= 1:
			print('Correct')
		else:
			print('Incorrect')
	elif can_add >= 2:
		print('Correct')
	else:
		print('Incorrect')


(n, m, mi, ma) = map(int, input().split())
a = list(map(int, input().split()))
if any(list(map(lambda x: x > ma or x < mi, a))):
	print('Incorrect')
	exit(0)
c = 0
if mi not in a:
	c += 1
if ma not in a:
	c += 1
if c <= n - m:
	print('Correct')
else:
	print('Incorrect')


(n, m, mi, mx) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
if a[0] != mi:
	m += 1
if a[-1] != mx:
	m += 1
if a[0] < mi:
	m += n + 1
if a[-1] > mx:
	m += n + 1
print(['Incorrect', 'Correct'][m <= n])


(n, m, Min, Max) = map(int, input().split())
t = list(map(int, input().split()))
if min(t) >= Min and max(t) <= Max:
	if m + abs(len({Min, Max} & set(t)) - 2) <= n:
		print('Correct')
	else:
		print('Incorrect')
else:
	print('Incorrect')


mod = 1000000007
ii = lambda : int(input())
si = lambda : input()
dgl = lambda : list(map(int, input()))
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
ls = lambda : list(input())
(n, m, mn, mx) = f()
l = il()
mn1 = min(l)
mx1 = max(l)
if mn1 < mn or mx1 > mx:
	print('Incorrect')
elif mn1 == mn and mx1 == mx:
	print('Correct')
elif mn1 == mn and n - m >= 1 or (mx1 == mx and n - m >= 1):
	print('Correct')
elif n - m >= 2:
	print('Correct')
else:
	print('Incorrect')


x = [int(w) for w in input().split()]
t = [int(e) for e in input().split()]
if max(t) > x[3]:
	print('Incorrect')
elif min(t) < x[2]:
	print('Incorrect')
elif x[0] - x[1] == 1 and (min(t) != x[2] and max(t) != x[3]):
	print('Incorrect')
else:
	print('Correct')


(n, m, minn, maxx) = map(int, input().split())
L = list(map(int, input().split()))
r = 0
if minn not in L:
	L += [minn]
	r += 1
if maxx not in L:
	L += [maxx]
	r += 1
valid = True
for i in range(m):
	if L[i] < minn:
		valid = False
	if L[i] > maxx:
		valid = False
if r > n - m or not valid:
	print('Incorrect')
else:
	print('Correct')


(n, m, v1, v2) = map(int, input().split())
t = list(map(int, input().split()))
(t1, t2) = (min(t), max(t))
if t1 < v1 or t2 > v2:
	print('Incorrect')
elif (v1 < t1) + (v2 > t2) > n - m:
	print('Incorrect')
else:
	print('Correct')


(n, m, mn, mx) = list(map(int, input().split()))
temps = list(map(int, input().split()))
mnt = min(temps)
mxt = max(temps)
if mnt < mn or mxt > mx:
	print('Incorrect')
	return
if n - m > 1:
	print('Correct')
	return
mnp = mn in temps
mxp = mx in temps
if n - m == 1 and (mnp or mxp):
	print('Correct')
elif mnp and mxp:
	print('Correct')
else:
	print('Incorrect')


(n, m, mn, mx) = map(int, input().split())
M = []
M = list(map(int, input().split()))
if min(M) != mn:
	M.append(mn)
if max(M) != mx:
	M.append(mx)
M.sort()
if min(M) != mn or max(M) != mx or len(M) > n:
	print('Incorrect')
else:
	print('Correct')


cin = input
(n, m, ln, rn) = map(int, cin().split())
a = [int(v) for v in cin().split()]
if ln < min(a) <= max(a) < rn:
	print(['Incorrect', 'Correct'][n - m > 1])
else:
	print(['Correct', 'Incorrect'][min(a) < ln or max(a) > rn])


(n, m, mi, mx) = map(int, input().split())
t = list(map(int, input().split()))
a = min(t)
b = max(t)
u = 0
h = 0
if a == mi:
	h += 1
if a < mi:
	print('Incorrect')
	u += 1
if b == mx:
	h += 1
if b > mx and u == 0:
	print('Incorrect')
	u += 1
if u == 0:
	if h == 2:
		print('Correct')
	elif h == 1:
		if n - m >= 1:
			print('Correct')
		else:
			print('Incorrect')
	elif n - m >= 2:
		print('Correct')
	else:
		print('Incorrect')


(n, m, min_, max_) = map(int, input().split())
l = sorted(list(map(int, input().split())))
if l[0] < min_ or l[-1] > max_:
	print('Incorrect')
else:
	if l[-1] < max_:
		l.append(max_)
	if l[0] > min_:
		l.append(min_)
	if len(l) <= n:
		print('Correct')
	else:
		print('Incorrect')


(n, m, mn, mx) = map(int, input().split())
s = list(map(int, input().split()))
(am, ax) = (min(s), max(s))
if am < mn or ax > mx:
	print('Incorrect')
elif n - 1 == m and am != mn and (ax != mx):
	print('Incorrect')
else:
	print('Correct')


(n, k, s, b) = list(map(int, input().split()))
m = list(map(int, input().split()))
print(('Inc' if min(m) < s or max(m) > b or (max(m) != b) + (min(m) != s) > n - k else 'C') + 'orrect')


import sys
import string
from collections import Counter, defaultdict
from math import fsum, sqrt, gcd, ceil, factorial
from operator import *
from itertools import accumulate
inf = float('inf')
flush = lambda : sys.stdout.flush
comb = lambda x, y: factorial(x) // factorial(y) // factorial(x - y)
en = lambda x: list(enumerate(x))
ip = lambda : input()
ii = lambda : int(input())
r = lambda : map(int, input().split())
rr = lambda : list(r())
(a, b, c, d) = r()
arr = rr()
a -= b
if c not in arr:
	a -= 1
if d not in arr:
	a -= 1
if any((i < c for i in arr)) or any((i > d for i in arr)) or a < 0:
	print('Incorrect')
else:
	print('Correct')


import sys
from itertools import *
from math import *
MAX = 10000000

def solve():
	(n, m, ss, ll) = map(int, input().split())
	a = set(map(int, input().split()))
	wantothers = 0
	smallest = 100000000
	largest = -1
	for val in a:
		smallest = min(smallest, val)
		largest = max(largest, val)
	if smallest < ss or largest > ll:
		print('Incorrect')
		return
	if ss not in a:
		wantothers += 1
	if ll not in a:
		wantothers += 1
	print('Correct' if wantothers <= n - m else 'Incorrect')
if sys.hexversion == 50594544:
	sys.stdin = open('test.txt')
solve()


I = lambda : map(int, input().split())
(n, m, Tmin, Tmax) = I()
T = sorted(I())
print(('Inc' if T[0] < Tmin or T[-1] > Tmax or (n - m < 2 and T[0] != Tmin and (T[-1] != Tmax)) else 'C') + 'orrect')


a = lambda : list(map(int, input().split()))
(m, n, mi, ma) = a()
s = a()
se = set(s)
dl = m - n
if max(s) > ma:
	print('Incorrect')
elif min(s) < mi:
	print('Incorrect')
else:
	if ma not in se:
		dl -= 1
	if mi not in se:
		dl -= 1
	if dl < 0:
		print('Incorrect')
	else:
		print('Correct')


(n, m, min1, max1) = map(int, input().split())
a = list(map(int, input().split()))
c = 0
if max1 not in a:
	a.append(max1)
	c += 1
if min1 not in a:
	a.append(min1)
	c += 1
if n - m >= c and max(a) == max1 and (min(a) == min1):
	print('Correct')
else:
	print('Incorrect')


(n, m, a, b) = map(int, input().split())
t = list(map(int, input().split()))
(x, y) = (min(t), max(t))
print('Correct' if a <= x and y <= b and (len(t) + int(a < x) + int(y < b) <= n) else 'Incorrect')


I = lambda : list(map(int, input().split()))
(n, m, N, X) = I()
t = I()
r = min(t) != N
r += max(t) != X
print(['C', 'Inc'][m + r > n or min(t) < N or max(t) > X] + 'orrect')


(n, m, min, max) = map(int, input().split())
temps = list(map(int, input().split()))
temps.sort()
if temps[m - 1] > max:
	print('Incorrect')
elif temps[0] < min:
	print('Incorrect')
elif n - m >= 2 or n - m is 0:
	print('Correct')
else:
	hasMin = False
	hasMax = False
	if temps[0] is min:
		hasMin = True
	if temps[m - 1] is max:
		hasMax = True
	if hasMin and hasMax:
		print('Correct')
	elif (hasMin or hasMax) and n - m is 1:
		print('Correct')
	else:
		print('Incorrect')


from sys import stdin

def get_ints():
	return list(map(int, stdin.readline().strip().split()))
(n, m, mn, mx) = get_ints()
ar = get_ints()
toadd = n - m
amin = min(ar)
amax = max(ar)
if toadd == 1 and (amin != mn and amax != mx):
	print('Incorrect')
	exit()
if amin < mn or amax > mx:
	print('Incorrect')
	exit()
print('Correct')


(n, m, Min, Max) = map(int, input().strip().split(' '))
lst = list(map(int, input().strip().split(' ')))
lst.append(Min)
lst.append(Max)
if min(lst) != Min:
	print('Incorrect')
elif max(lst) != Max:
	print('Incorrect')
elif m + 1 == n:
	c = lst.count(Min)
	c1 = lst.count(Max)
	if c >= 2 or c1 >= 2:
		print('Correct')
	else:
		print('Incorrect')
else:
	print('Correct')


line = input()
(n_steps, m_records, min_v, max_v) = line.split()
(n_steps, m_records, min_v, max_v) = (int(n_steps), int(m_records), int(min_v), int(max_v))
line = input()
a = [int(i) for i in line.split()]
low = False
high = False
outbound = False
for i in a:
	if i == min_v:
		low = True
	if i == max_v:
		high = True
	if i > max_v or i < min_v:
		outbound = True
sub = 2
if high == True:
	sub = sub - 1
if low == True:
	sub = sub - 1
if n_steps - m_records - sub >= 0 and outbound == False:
	print('Correct')
else:
	print('Incorrect')


(n, m, mi, ma) = map(int, input().split())
k = n - m
counter = 2
s = list(map(int, input().split()))
if min(s) < mi:
	print('Incorrect')
	quit()
if max(s) > ma:
	print('Incorrect')
	quit()
if mi in s:
	counter -= 1
if ma in s:
	counter -= 1
if k >= counter:
	print('Correct')
else:
	print('Incorrect')


(n, m, min_a, max_a) = map(int, input().split())
a = list(map(int, input().split()))
if m <= n - 2:
	if min(a) >= min_a and max(a) <= max_a:
		print('Correct')
	else:
		print('Incorrect')
elif m == n - 1:
	if min(a) == min_a and max(a) <= max_a or (max(a) == max_a and min(a) >= min_a):
		print('Correct')
	else:
		print('Incorrect')
elif n == m:
	if min(a) == min_a and max(a) == max_a:
		print('Correct')
	else:
		print('Incorrect')
else:
	print('Incorrect')


(n, m, mini, maxi) = list(map(int, input().split()))
ar = list(map(int, input().split()))
minix = min(ar)
maxix = max(ar)
diff = n - m
if diff == 1 and (minix != mini and maxix != maxi):
	print('Incorrect')
	exit()
if minix < mini or maxix > maxi:
	print('Incorrect')
	exit()
print('Correct')


(n, m, minn, maxx) = map(int, input().split())
a = sorted(list(map(int, input().split())))
cnt = 0
if minn != a[0]:
	cnt += 1
if maxx != a[-1]:
	cnt += 1
if maxx < a[-1]:
	cnt += 10000000000000000000
if minn > a[0]:
	cnt += 10000000000000000000
if n - m >= cnt:
	print('Correct')
else:
	print('Incorrect')


(n, m, Min, Max) = map(int, input().split())
a = list(map(int, input().split()))
remain = n - m
cnt = 0
flag = 0
for i in a:
	if i == Min or i == Max:
		cnt += 1
	if i < Min or i > Max:
		flag = -1
cnt = 2 - cnt
if flag == -1:
	print('Incorrect')
elif n - m >= cnt:
	print('Correct')
else:
	print('Incorrect')


(n, m, l, r) = map(int, input().split())
a = list(map(int, input().split()))
if max(a) > r or min(a) < l:
	print('Incorrect')
elif n - m >= 2:
	print('Correct')
elif l not in a and r not in a and (l != r):
	print('Incorrect')
else:
	print('Correct')


strs = input().split(' ')
n = int(strs[0])
m = int(strs[1])
mini = int(strs[2])
maxi = int(strs[3])
a = list(map(int, input().split(' ')))
the_max = max(a)
the_min = min(a)
added = 2
if the_max == maxi:
	added -= 1
if the_min == mini:
	added -= 1
if the_max <= maxi and the_min >= mini and (n - m >= added):
	print('Correct')
else:
	print('Incorrect')


def main():
	(n, m, mn, mx) = map(int, input().split())
	A = list(map(int, input().split()))
	a = min(A)
	b = max(A)
	if a < mn or b > mx:
		print('Incorrect')
		return
	cnt = 0
	if a > mn:
		cnt += 1
	if b < mx:
		cnt += 1
	if m + cnt <= n:
		print('Correct')
	else:
		print('Incorrect')
main()


(n, _, small, big) = list(map(int, input().split()))
m = list(map(int, input().split()))
diff = n - _
rd = 0
if max(m) != big:
	rd += 1
if min(m) != small:
	rd += 1
if min(m) < small or max(m) > big:
	print('Incorrect')
	exit()
if rd <= diff:
	print('Correct')
else:
	print('Incorrect')


(n, m, mi, ma) = map(int, input().split())
k = list(map(int, input().split()))
if n - m > 1 and min(k) >= mi and (max(k) <= ma):
	print('Correct')
elif n - m == 1 and (min(k) == mi and max(k) <= ma) or (min(k) >= mi and max(k) == ma):
	print('Correct')
else:
	print('Incorrect')


(n, m, mmin, mmax) = map(int, input().split())
s = list(map(int, input().split()))
s = sorted(s)
if s[0] < mmin or s[m - 1] > mmax:
	print('Incorrect')
elif s[0] == mmin and s[m - 1] == mmax:
	print('Correct')
elif s[0] != mmin and s[m - 1] != mmax:
	if n - m < 2:
		print('Incorrect')
	else:
		print('Correct')
elif s[0] != mmin or s[m - 1] != mmax:
	if n - m < 1:
		print('Incorrect')
	else:
		print('Correct')


from math import *
from collections import deque
from copy import deepcopy
import sys

def inp():
	return sys.stdin.readline().rstrip('\r\n')

def multi():
	return map(int, input().split())

def strmulti():
	return map(str, inp().split())

def lis():
	return list(map(int, inp().split()))

def lcm(a, b):
	return a * b // gcd(a, b)

def ncr(n, r):
	return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))

def stringlis():
	return list(map(str, inp().split()))

def out(var):
	sys.stdout.write(str(var))

def printlist(a):
	print(' '.join((str(a[i]) for i in range(len(a)))))

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True
(n, m, mini, maxi) = multi()
a = lis()
if mini not in a:
	a.append(mini)
if maxi not in a:
	a.append(maxi)
if len(a) > n or max(a) != maxi or min(a) != mini:
	print('Incorrect')
else:
	print('Correct')


def poss(v, mint, maxt):
	m = len(v)
	is_min = 0
	is_max = 0
	for c in v:
		if c < mint or c > maxt:
			return 0
	for c in v:
		if c == maxt:
			is_max = 1
		if c == mint:
			is_min = 1
		if is_max and is_min:
			return 1
	if is_max and (not is_min) and (n - m > 0):
		return 1
	if not is_max and is_min and (n - m > 0):
		return 1
	if n - m > 1:
		return 1
	else:
		return 0
(n, m, mint, maxt) = map(int, input().split(' '))
v = list(map(int, input().split(' ')))
if poss(v, mint, maxt):
	print('Correct')
else:
	print('Incorrect')


(n, m, Min, Max) = [int(x) for x in input().split()]
t = [int(x) for x in input().split()]
shift = 0
if t.count(Max) != 0:
	shift += 1
if t.count(Min) != 0:
	shift += 1
if n - 2 == 0:
	if Min in t or Max in t:
		print('Correct')
	else:
		print('Incorrect')
elif max(t) <= Max and min(t) >= Min and (len(t) - shift + 2 <= n):
	print('Correct')
else:
	print('Incorrect')


(n, m, minimum, maximum) = list(map(int, input().split()))
list_of_m = list(map(int, input().split()))
maxi = max(list_of_m)
mini = min(list_of_m)
if maxi < maximum and mini > minimum:
	if n - m >= 2:
		print('Correct')
	else:
		print('Incorrect')
elif maxi == maximum and mini > minimum:
	if n - m >= 1:
		print('Correct')
	else:
		print('Incorrect')
elif maxi < maximum and mini == minimum:
	if n - m >= 1:
		print('Correct')
	else:
		print('Incorrect')
elif maxi == maximum and mini == minimum:
	print('Correct')
else:
	print('Incorrect')


(n, m, min_, max_) = map(int, input().split())
l = list(map(int, input().split()))
if max(set(l)) <= max_ and min(set(l)) >= min_:
	if min_ not in l and max_ not in l:
		if n - m >= 2:
			print('Correct')
		else:
			print('Incorrect')
	elif min_ not in l and max_ in l or (min_ in l and max_ not in l):
		if n - m >= 1:
			print('Correct')
		else:
			print('Incorrect')
	else:
		print('Correct')
else:
	print('Incorrect')


(a, b, c, d) = map(int, input().split())
z = list(map(int, input().split()))
k = z.copy()
if c in k:
	k.remove(c)
if d in k:
	k.remove(d)
if max(z) > d or min(z) < c or len(k) + 2 > a:
	print('Incorrect')
else:
	print('Correct')


x = 0
res = 0
(n, m, mn, mx) = list(map(int, input().split()))
lst = list(map(int, input().split()))
for i in range(m):
	if lst[i] < mn or lst[i] > mx:
		res = 'Incorrect'
		break
	if lst[i] == mn:
		x = 1
	elif lst[i] == mx:
		x = 1
if res == 'Incorrect':
	print(res)
elif n - m >= 2 - x:
	print('Correct')
else:
	print('Incorrect')


R = lambda : map(int, input().split())
(n, m, mi, ma) = R()
s = list(R())
a = {mi, ma}
b = set()
for i in s:
	if mi <= i <= ma:
		a.add(i)
		b.add(i)
	else:
		print('Incorrect')
		exit(0)
if len(a) > n:
	print('Incorrect')
elif m < n - 1:
	print('Correct')
elif len(a) - len(b) <= n - m:
	print('Correct')
else:
	print('Incorrect')


(n, m, a, b) = map(int, input().split())
s = list(map(int, input().split()))
(c, d) = (min(s), max(s))
if c < a or d > b:
	print('Incorrect')
elif n - 1 == m and c != a and (d != b):
	print('Incorrect')
else:
	print('Correct')


class CodeforcesTask413ASolution:

	def __init__(self):
		self.result = ''
		self.n_m_min_max = []
		self.measurements = []

	def read_input(self):
		self.n_m_min_max = [int(x) for x in input().split(' ')]
		self.measurements = [int(x) for x in input().split(' ')]

	def process_task(self):
		if max(self.measurements) <= self.n_m_min_max[3] and min(self.measurements) >= self.n_m_min_max[2]:
			to_add = 0
			if self.n_m_min_max[3] not in self.measurements:
				to_add += 1
			if self.n_m_min_max[2] not in self.measurements:
				to_add += 1
			if self.n_m_min_max[0] - self.n_m_min_max[1] >= to_add:
				self.result = 'Correct'
			else:
				self.result = 'Incorrect'
		else:
			self.result = 'Incorrect'

	def get_result(self):
		return self.result
Solution = CodeforcesTask413ASolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())


(n, m, mi, ma) = map(int, input().split())
t = list(map(int, input().split()))
mit = min(t)
mat = max(t)
if (mi <= mit and ma >= mat) and (n - m >= 2 or (n - m >= 1 and (mit == mi or mat == ma)) or (mit == mi and mat == ma)):
	print('Correct')
else:
	print('Incorrect')


import sys

def minp():
	return sys.stdin.readline().strip()

def mint():
	return int(minp())

def mints():
	return map(int, minp().split())
(n, m, mi, ma) = mints()
a = list(mints())
mii = min(a)
maa = max(a)
if mii > mi:
	m += 1
if maa < ma:
	m += 1
if mii < mi or maa > ma or m > n:
	print('Incorrect')
else:
	print('Correct')


(set_, hel, min_, max_) = map(int, input().split())
ll = [int(x) for x in input().split()]
Err = 0
ko = []
ko.append(min_)
ko.append(max_)
for i in range(len(ll)):
	if ll[i] == min_:
		continue
	elif ll[i] == max_:
		continue
	elif ll[i] < min_:
		Err = 2
	elif ll[i] > max_:
		Err = 2
	elif min_ <= ll[i] <= max_:
		ko.append(ll[i])
	elif set_ < len(ko):
		Err = 2
	else:
		Err = 2
	if Err >= set_:
		print('Incorrect')
		exit()
	elif Err == 2:
		print('Incorrect')
		exit()
if set_ < len(ko):
	Err = 2
if Err >= set_:
	print('Incorrect')
	exit()
elif Err == 2:
	print('Incorrect')
	exit()
print('Correct')


(n, m, minimum, maximum) = map(int, input().split())
seq = [int(i) for i in input().split()]
if max(seq) > maximum or min(seq) < minimum:
	print('Incorrect')
elif maximum not in seq and minimum not in seq:
	if n - m >= 2:
		print('Correct')
	else:
		print('Incorrect')
elif maximum in seq and minimum in seq:
	print('Correct')
elif n - m >= 1:
	print('Correct')
else:
	print('Incorrect')


(n, m, mi, ma) = map(int, input().split())
a = sorted(list(map(int, input().split())))
if n - m >= 2:
	if a[0] >= mi and a[-1] <= ma:
		print('Correct')
	else:
		print('Incorrect')
elif n - m == 1:
	if a[0] >= mi and a[-1] == ma or (a[0] == mi and a[-1] <= ma):
		print('Correct')
	else:
		print('Incorrect')
elif a[0] == mi and a[-1] == ma:
	print('Correct')
else:
	print('Incorrect')


cin = input
(n, m, mj, mx) = map(int, cin().split())
a = [int(v) for v in cin().split()]
(l, r) = (min(a), max(a))
if min(a) < mj or max(a) > mx:
	print('Incorrect')
elif mj < min(a) <= max(a) < mx:
	print(['Incorrect', 'Correct'][n - m > 1])
else:
	print('Correct')