You took a peek on Thanos wearing Infinity Gauntlet. In the Gauntlet there is a place for six Infinity Gems:  the Power Gem of purple color,  the Time Gem of green color,  the Space Gem of blue color,  the Soul Gem of orange color,  the Reality Gem of red color,  the Mind Gem of yellow color. 

Using colors of Gems you saw in the Gauntlet determine the names of absent Gems.


-----Input-----

In the first line of input there is one integer $n$ ($0 \le n \le 6$) — the number of Gems in Infinity Gauntlet.

In next $n$ lines there are colors of Gems you saw. Words used for colors are: purple, green, blue, orange, red, yellow. It is guaranteed that all the colors are distinct. All colors are given in lowercase English letters.


-----Output-----

In the first line output one integer $m$ ($0 \le m \le 6$) — the number of absent Gems.

Then in $m$ lines print the names of absent Gems, each on its own line. Words used for names are: Power, Time, Space, Soul, Reality, Mind. Names can be printed in any order. Keep the first letter uppercase, others lowercase.


-----Examples-----
Input
4
red
purple
yellow
orange

Output
2
Space
Time

Input
0

Output
6
Time
Mind
Soul
Power
Reality
Space



-----Note-----

In the first sample Thanos already has Reality, Power, Mind and Soul Gems, so he needs two more: Time and Space.

In the second sample Thanos doesn't have any Gems, so he needs all six.

Difficulty: EASY
Tags: Implementation
Expected Time Complexity: O(1)

Starter code:

Solutions:
n = int(input())
color = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
gem = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for i in range(n):
	s = input()
	if s == 'purple':
		gem.remove('Power')
	elif s == 'green':
		gem.remove('Time')
	elif s == 'blue':
		gem.remove('Space')
	elif s == 'orange':
		gem.remove('Soul')
	elif s == 'red':
		gem.remove('Reality')
	elif s == 'yellow':
		gem.remove('Mind')
x = len(gem)
print(x)
for i in range(x):
	print(gem[i])


d = {}
d['purple'] = 'Power'
d['green'] = 'Time'
d['blue'] = 'Space'
d['orange'] = 'Soul'
d['red'] = 'Reality'
d['yellow'] = 'Mind'
n = int(input().strip())
for i in range(n):
	color = input().strip()
	d.pop(color)
print(len(d))
for key in d:
	print(d[key])


n = int(input())
a = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for _ in range(n):
	s = input()
	a[s] = 1
print(6 - n)
for i in a:
	if a[i] != 1:
		print(a[i])


n = int(input())
a = []
d = {}
d['purple'] = 'Power'
d['green'] = 'Time'
d['blue'] = 'Space'
d['orange'] = 'Soul'
d['red'] = 'Reality'
d['yellow'] = 'Mind'
for i in range(n):
	a.append(input())
b = []
print(6 - n)
for i in d:
	if i not in a:
		print(d[i])


d = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
l = []
for i in d:
	l += [d[i]]
for _ in range(int(input())):
	c = input()
	l.remove(c)
print(len(l))
if len(l) != 0:
	for i in d:
		if d[i] in l:
			print(i)


n = int(input())
l = []
a = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
c = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for i in range(n):
	l.append(input())
x = 6 - len(l)
print(x)
for i in range(6):
	if a[i] not in l:
		print(c[i])


n = int(input())
lst = []
dic = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(n):
	w = input()
	lst.append(w)
miss = 0
misses = []
for word in dic.keys():
	if word not in lst:
		misses.append(dic[word])
		miss += 1
print(miss)
for m in misses:
	print(m)


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
for _ in range(n):
	del d[input()]
print(len(d))
print('\n'.join(d.values()))


a = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
b = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
n = int(input())
c = []
for i in range(n):
	c.append(input())
ans = []
for i in range(6):
	if b[i] in c:
		continue
	ans.append(a[i])
print(len(ans))
for i in ans:
	print(i)


mp = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
a = [input() for _ in range(n)]
b = filter(lambda x: x not in a, list(mp))
c = map(lambda x: mp[x], b)
m = 6 - n
print(m)
print('\n'.join(c))


n = int(input())
k = list()
for i in range(n):
	k.append(input())
print(6 - n)
if 'purple' not in k:
	print('Power')
if 'green' not in k:
	print('Time')
if 'blue' not in k:
	print('Space')
if 'orange' not in k:
	print('Soul')
if 'yellow' not in k:
	print('Mind')
if 'red' not in k:
	print('Reality')


dict = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
for i in range(n):
	col = input()
	del dict[col]
print(6 - n)
for i in dict.values():
	print(i)


num_colors = int(input())
print(6 - num_colors)
colors = []
for color in range(num_colors):
	color = input()
	colors.append(color)
if 'purple' not in colors:
	print('Power')
if 'green' not in colors:
	print('Time')
if 'blue' not in colors:
	print('Space')
if 'orange' not in colors:
	print('Soul')
if 'red' not in colors:
	print('Reality')
if 'yellow' not in colors:
	print('Mind')


n = int(input())
colors = ['purple', 'red', 'yellow', 'blue', 'orange', 'green']
gems = ['Power', 'Reality', 'Mind', 'Space', 'Soul', 'Time']
arr = []
for i in range(n):
	arr.append(input())
mis = []
for j in range(6):
	if colors[j] not in arr:
		mis.append(gems[j])
print(6 - n)
for i in mis:
	print(i)


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
a = set()
for i in range(0, n):
	s = input()
	d.pop(s)
print(len(d.values()))
for i in d.values():
	print(i)


n = int(input())
x = []
for i in range(n):
	x.append(input())
colours = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
stones = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
y = []
for i in range(6):
	if colours[i] not in x:
		y.append(stones[i])
print(len(y))
for i in y:
	print(i)


s = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
a = int(input())
for i in range(a):
	s.remove(d[input()])
print(len(s))
for i in s:
	print(i)


n = int(input())
mp = {'red': 0, 'purple': 0, 'yellow': 0, 'orange': 0, 'blue': 0, 'green': 0}
cnt = 6 - n
for i in range(n):
	tmp = input()
	mp[tmp] = 1
if cnt:
	print(cnt)
	if not mp['purple']:
		print('Power')
	if not mp['blue']:
		print('Space')
	if not mp['orange']:
		print('Soul')
	if not mp['yellow']:
		print('Mind')
	if not mp['green']:
		print('Time')
	if not mp['red']:
		print('Reality')
else:
	print(0)


m = {}
m['purple'] = 'Power'
m['green'] = 'Time'
m['blue'] = 'Space'
m['orange'] = 'Soul'
m['red'] = 'Reality'
m['yellow'] = 'Mind'
n = int(input())
s = set(m.values())
print(6 - n)
for i in range(n):
	s.remove(m[input()])
for i in s:
	print(i)


tanos = [['Power', 'purple'], ['Time', 'green'], ['Space', 'blue'], ['Soul', 'orange'], ['Reality', 'red'], ['Mind', 'yellow']]
otv = [0] * 6
n = int(input())
for i in range(n):
	color = input()
	for j in range(6):
		if color == tanos[j][1]:
			otv[j] = tanos[j][0]
print(6 - n)
for j in range(6):
	if otv[j] != tanos[j][0]:
		print(tanos[j][0])


colours = []
n = int(input())
for i in range(n):
	colours.append(input())
stones = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'yellow': 'Mind', 'red': 'Reality'}
print(6 - n)
for colour in stones.keys():
	if colour not in colours:
		print(stones[colour])


n = int(input())
l = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
for i in range(n):
	a = input()
	for b in l:
		if a == b:
			l.remove(a)
print(6 - n)
for i in l:
	if i == 'purple':
		print('Power')
	elif i == 'green':
		print('Time')
	elif i == 'blue':
		print('Space')
	elif i == 'orange':
		print('Soul')
	elif i == 'red':
		print('Reality')
	else:
		print('Mind')


n = input()
mapping = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
in_colors = set()
for _ in range(int(n)):
	s = input()
	in_colors.add(s)
no = set(mapping.keys()) - in_colors
print(len(no))
for a in no:
	print(mapping[a])


n = int(input())
ll = []
l = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
d = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
for u in range(n):
	s = input()
	ll.append(s)
dd = []
c = 0
for i in range(6):
	if d[i] not in ll:
		dd.append(l[i])
		c = c + 1
print(c)
for i in range(c):
	print(dd[i])


num = int(input())
colours = [input() for _ in range(num)]
all_colours = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
powers = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
gems = dict(zip(all_colours, powers))
print(6 - len(colours))
for colour in all_colours:
	if colour not in colours:
		print(gems[colour])


import sys
n = int(input())
colors = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(0, n):
	del colors[input()]
print(len(colors))
for x in colors.values():
	sys.stdout.write(x)
	sys.stdout.write('\n')


gauntlets = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
arr = []
for i in range(n):
	arr.append(input())
sol = []
for (k, v) in gauntlets.items():
	if k not in arr:
		sol.append(v)
print(len(sol))
for s in sol:
	print(s)


n = int(input())
lisofs = []
rocks = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for i in range(n):
	s = input()
	lisofs.append(s)
	if s == 'purple':
		rocks.remove('Power')
	elif s == 'green':
		rocks.remove('Time')
	elif s == 'blue':
		rocks.remove('Space')
	elif s == 'orange':
		rocks.remove('Soul')
	elif s == 'red':
		rocks.remove('Reality')
	else:
		rocks.remove('Mind')
print(6 - len(lisofs))
for j in range(len(rocks)):
	print(rocks[j])


n = int(input())
gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
l = 6
for _ in range(n):
	c = input()
	if c in gems and l > 0:
		del gems[c]
		l -= 1
print(l)
if l > 0:
	for c in gems:
		print(gems[c])


import sys
n = int(input())
lines = sys.stdin.readlines()
map = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
colors = list(map.keys())
for color in lines:
	color = color.strip()
	colors.remove(color)
print(6 - n)
for color in colors:
	print(map[color])


n = int(input())
mat = []
for _ in range(n):
	mat.append(input())
c_mat = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
n_mat = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
print(6 - len(mat))
for i in range(6):
	if not c_mat[i] in mat:
		print(n_mat[i])


n = input()
n = int(n)
mp = dict()
mp['red'] = 'Reality'
mp['yellow'] = 'Mind'
mp['orange'] = 'Soul'
mp['blue'] = 'Space'
mp['green'] = 'Time'
mp['purple'] = 'Power'
i = 0
while i < n:
	tmp = input()
	mp.pop(tmp)
	i += 1
print(len(mp))
for ele in mp:
	print(mp[ele])


x = int(input())
b = 0
g = 0
p = 0
b = 0
o = 0
r = 0
a = 0
for i in range(x):
	y = input()
	if y == 'purple':
		p = 1
	if y == 'green':
		g = 1
	if y == 'blue':
		b = 1
	if y == 'orange':
		o = 1
	if y == 'red':
		r = 1
	if y == 'yellow':
		a = 1
print(6 - x)
if p != 1:
	print('Power')
if g != 1:
	print('Time')
if b != 1:
	print('Space')
if o != 1:
	print('Soul')
if r != 1:
	print('Reality')
if a != 1:
	print('Mind')


D = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
T = int(input())
L = []
for i in range(T):
	L.append(input())
X = list(D.values())
Y = list(set(X) - set(L))
K = dict([(value, key) for (key, value) in D.items()])
print(len(Y))
for i in range(len(Y)):
	print(K.get(Y[i]))


n = int(input())
ar = ['Power', 'Space', 'Soul', 'Mind', 'Time', 'Reality']
ss = 'pboygr'
ar2 = [0] * 6
for i in range(n):
	s = input()
	ar2[ss.find(s[0])] = 1
print(6 - n)
for i in range(6):
	if ar2[i] == 0:
		print(ar[i])


import sys
n = int(sys.stdin.readline())
gauntlet = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
stone_list = [sys.stdin.readline().strip() for stone in range(n)]
print(len(gauntlet) - n)
for stone in gauntlet.keys():
	if stone not in stone_list:
		print(gauntlet[stone])


n = int(input())
gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
count = 6
missing = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for _ in range(n):
	s = input()
	missing.remove(gems[s])
	count -= 1
print(count)
for _ in missing:
	print(_)


n = int(input())
l = []
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(n):
	l.append(input())
d1 = dict.fromkeys(l)
print(6 - len(l))
for i in d:
	if i not in d1:
		print(d[i])


n = int(input())
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
print(6 - n)
print(*map(lambda x: d[x], set(d.keys()).difference([input() for _ in range(n)])), sep='\n')


d = {'red': 'Reality', 'purple': 'Power', 'yellow': 'Mind', 'orange': 'Soul', 'green': 'Time', 'blue': 'Space'}
l = ['red', 'purple', 'orange', 'green', 'yellow', 'blue']
n = int(input())
t = []
while n:
	tr = input()
	t.append(tr)
	n -= 1
s = list(set(l) - set(t))
print(len(s))
for i in s:
	print(d[i])


n = int(input())
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
s = set()
for i in range(n):
	s.add(input())
print(6 - n)
for key in d:
	if key in s:
		continue
	else:
		print(d[key])


n = int(input())
a = [0] * 6
for i in range(n):
	s = input()
	if s == 'purple':
		a[0] = 1
	elif s == 'green':
		a[1] = 1
	elif s == 'blue':
		a[2] = 1
	elif s == 'orange':
		a[3] = 1
	elif s == 'red':
		a[4] = 1
	elif s == 'yellow':
		a[5] = 1
print(6 - n)
for i in range(6):
	if a[i] == 0:
		i = int(i)
		if i == 0:
			print('Power')
		elif i == 1:
			print('Time')
		elif i == 2:
			print('Space')
		elif i == 3:
			print('Soul')
		elif i == 4:
			print('Reality')
		elif i == 5:
			print('Mind')


a = int(input())
c = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(a):
	c.pop(input())
print(6 - a)
for i in c:
	print(c[i])


n = int(input())
b = []
for i in range(n):
	b.append(input())
no = 6 - n
a = [['Power', 'purple'], ['Time', 'green'], ['Space', 'blue'], ['Soul', 'orange'], ['Reality', 'red'], ['Mind', 'yellow']]
js = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for i in range(n):
	if b[i] == 'purple':
		js[0] = '*'
	if b[i] == 'green':
		js[1] = '*'
	if b[i] == 'blue':
		js[2] = '*'
	if b[i] == 'orange':
		js[3] = '*'
	if b[i] == 'red':
		js[4] = '*'
	if b[i] == 'yellow':
		js[5] = '*'
print(no)
for i in range(len(js)):
	if js[i] != '*':
		print(js[i])


n = int(input())
colors = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
stones = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
check = [0, 0, 0, 0, 0, 0]
for i in range(n):
	s = input().strip()
	check[colors.index(s)] = 1
if check.count(1) != 6:
	print(check.count(0))
	for i in range(6):
		if check[i] == 0:
			print(stones[i])
else:
	print(0)


n = int(input())
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
f = {'purple', 'green', 'blue', 'orange', 'red', 'yellow'}
for i in range(n):
	f -= {input()}
print(len(f))
for i in f:
	print(d[i])


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
s = set()
n = int(input())
for _ in range(n):
	st = input()
	s.add(st)
print(6 - n)
for (key, value) in d.items():
	if key not in s:
		print(value)


d = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
d1 = dict()
s = set()
for key in d:
	d1[d[key]] = key
	s.add(d[key])
inp = set()
for _ in range(int(input())):
	inp.add(input())
s1 = s - inp
print(len(s1))
for clr in s1:
	print(d1[clr])


n = int(input())
dic = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(n):
	s = input()
	del dic[s]
print(len(dic))
for x in dic.values():
	print(x)


gauntlet = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
re = False
ye = False
ora = False
bl = False
gr = False
pu = False
n = int(input())
if n == 0:
	print('6', gauntlet['purple'], gauntlet['green'], gauntlet['blue'], gauntlet['orange'], gauntlet['red'], gauntlet['yellow'], sep='\n')
else:
	for i in range(n):
		s = input()
		if s == 'red':
			re = True
		elif s == 'yellow':
			ye = True
		elif s == 'purple':
			pu = True
		elif s == 'blue':
			bl = True
		elif s == 'green':
			gr = True
		elif s == 'orange':
			ora = True
	ans = 0
	if re == False:
		ans += 1
	if pu == False:
		ans += 1
	if gr == False:
		ans += 1
	if bl == False:
		ans += 1
	if ora == False:
		ans += 1
	if ye == False:
		ans += 1
	print(ans)
	if re == False:
		print(gauntlet['red'])
	if pu == False:
		print(gauntlet['purple'])
	if gr == False:
		print(gauntlet['green'])
	if bl == False:
		print(gauntlet['blue'])
	if ora == False:
		print(gauntlet['orange'])
	if ye == False:
		print(gauntlet['yellow'])


k = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
l = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
n = int(input())
a = []
for i in range(n):
	a.append(input())
if n == 0:
	print(6)
	for i in l:
		print(i)
	exit()
print(len(k) - len(a))
if a[0] in k:
	for i in range(len(l)):
		if k[i] not in a:
			print(l[i])
else:
	for i in range(len(l)):
		if l[i] not in a:
			print(l[i])


l = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
m = []
cnt = 0
for i in range(int(input())):
	a = input()
	if a in l:
		l.remove(a)
print(len(l))
for j in l:
	if j == 'purple':
		print('Power')
	elif j == 'green':
		print('Time')
	elif j == 'blue':
		print('Space')
	elif j == 'orange':
		print('Soul')
	elif j == 'red':
		print('Reality')
	else:
		print('Mind')


dic = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
first = []
second = []
for i in range(int(input())):
	first.append(input())
counter = 0
for i in dic:
	if i not in first:
		counter += 1
		second.append(dic[i])
print(counter)
for i in second:
	print(i)


n = int(input())
red = 0
orange = 0
yellow = 0
green = 0
blue = 0
purple = 0
for i in range(n):
	color = input()
	if color == 'red':
		red += 1
	elif color == 'orange':
		orange += 1
	elif color == 'yellow':
		yellow += 1
	elif color == 'green':
		green += 1
	elif color == 'blue':
		blue += 1
	else:
		purple += 1
print(6 - n)
if red == 0:
	print('Reality')
if orange == 0:
	print('Soul')
if yellow == 0:
	print('Mind')
if green == 0:
	print('Time')
if blue == 0:
	print('Space')
if purple == 0:
	print('Power')


def solve():
	d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
	ins = set()
	for _ in range(int(input())):
		ins.add(input())
	res = []
	for (x, y) in d.items():
		if x not in ins:
			res.append(y)
	print(len(res))
	for x in res:
		print(x)
solve()


from collections import Counter
gem = {'power': 'purple', 'time': 'green', 'space': 'blue', 'soul': 'orange', 'reality': 'red', 'mind': 'yellow'}
n = int(input())
pow = [i for i in gem.values()]
s = []
for i in range(n):
	temp = input()
	s.append(temp)
res = list((Counter(pow) - Counter(s)).elements())
m = []
for i in res:
	for (k, v) in gem.items():
		if i == v:
			m.append(k)
cap = [i.title() for i in m]
print(6 - n)
print(*cap, sep='\n')


colorPower = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
cases = int(input())
strings = ['dummy'] * cases
for i in range(cases):
	strings[i] = input()
for each in strings:
	if each in colorPower:
		colorPower.pop(each)
print(len(colorPower))
for each in colorPower:
	print(colorPower[each])


gems = {'purple': ['Power', 0], 'green': ['Time', 0], 'blue': ['Space', 0], 'orange': ['Soul', 0], 'red': ['Reality', 0], 'yellow': ['Mind', 0]}
n = int(input())
c = 0
for i in range(n):
	c += 1
	gems[input()][1] = 1
print(6 - c)
for x in gems:
	if not gems[x][1]:
		print(gems[x][0])


n = int(input())
m = 0
st = []
names = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
chk = [0, 0, 0, 0, 0, 0]
for i in range(n):
	a = input()
	st.append(a)
for i in range(n):
	if st[i] == 'purple':
		chk[0] = 1
	if st[i] == 'green':
		chk[1] = 1
	if st[i] == 'blue':
		chk[2] = 1
	if st[i] == 'orange':
		chk[3] = 1
	if st[i] == 'red':
		chk[4] = 1
	if st[i] == 'yellow':
		chk[5] = 1
for i in range(6):
	if chk[i] == 0:
		m += 1
print(m)
for i in range(6):
	if chk[i] == 0:
		print(names[i])


def solve():
	n = int(input())
	s = [input() for i in range(n)]
	p = (('purple', 'Power'), ('green', 'Time'), ('blue', 'Space'), ('orange', 'Soul'), ('red', 'Reality'), ('yellow', 'Mind'))
	ans = []
	for x in p:
		if x[0] not in s:
			ans.append(x[1])
	print(len(ans))
	for x in ans:
		print(x)
solve()


n = int(input())
d = {'red': 'Reality', 'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'yellow': 'Mind'}
l = []
for i in range(n):
	s = input()
	l.append(s)
print(len(d) - len(l))
for x in d:
	if x not in l:
		print(d[x])


import sys
S = [0] * 200009
n = int(input())
a = set((input() for i in range(n)))
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
cnt = []
for (key, val) in d.items():
	if key not in a:
		cnt.append(val)
print(len(cnt))
for item in cnt:
	print(item)


n = int(input())
color_name = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
used_color = []
used_number = 0
for _ in range(n):
	used_color.append(input().strip())
	used_number += 1
print(6 - used_number)
for color in color_name.keys():
	if color not in used_color:
		print(color_name[color])


stone = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
n = int(input())
for i in range(n):
	x = input()
	if x in stone:
		stone.remove(x)
print(len(stone))
for k in stone:
	if k == 'purple':
		print('Power')
	if k == 'green':
		print('Time')
	if k == 'blue':
		print('Space')
	if k == 'orange':
		print('Soul')
	if k == 'red':
		print('Reality')
	if k == 'yellow':
		print('Mind')


n = int(input())
l = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
ls = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
l1 = []
l2 = []
ans = 6 - n
for i in range(n):
	s = str(input())
	l1.append(s)
print(ans)
for i in range(len(l)):
	if l[i] not in l1:
		print(ls[i])


nogem = int(input())
absentgem = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for i in range(nogem):
	x = str(input())
	if x not in ['green', 'blue', 'orange', 'red', 'yellow']:
		absentgem.remove('Power')
	if x not in ['purple', 'blue', 'orange', 'red', 'yellow']:
		absentgem.remove('Time')
	if x not in ['purple', 'green', 'orange', 'red', 'yellow']:
		absentgem.remove('Space')
	if x not in ['purple', 'green', 'blue', 'red', 'yellow']:
		absentgem.remove('Soul')
	if x not in ['purple', 'green', 'blue', 'orange', 'yellow']:
		absentgem.remove('Reality')
	if x not in ['purple', 'green', 'blue', 'orange', 'red']:
		absentgem.remove('Mind')
abgem = 6 - nogem
print(abgem)
for i in range(abgem):
	print(absentgem[i])


n = int(input())
p = []
for i in range(0, n):
	x = input()
	p.append(x)
print(6 - n)
if 'red' not in p:
	print('Reality')
if 'green' not in p:
	print('Time')
if 'purple' not in p:
	print('Power')
if 'orange' not in p:
	print('Soul')
if 'blue' not in p:
	print('Space')
if 'yellow' not in p:
	print('Mind')


colors = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
m = int(input())
for i in range(m):
	color = input()
	del colors[color]
print(6 - m)
for color in colors:
	print(colors[color])


def max1(a):
	p = a[0]
	for x in a:
		if x > p:
			p = x
	return p

def preobr(x):
	if x % 2 == 1:
		return x + 1
	else:
		return x - 1

def prlist(a):
	for x in a:
		print(x, end=' ')

def dlin(n):
	k = 0
	while n > 0:
		n -= k
		k += 1
	return k - 1

def foundm(x, a):
	for i in range(len(a)):
		if x == a[i]:
			return i
	return -1
n = int(input())
fl1 = True
fl2 = True
fl3 = True
fl4 = True
fl5 = True
fl6 = True
for i in range(n):
	x = input()
	if x == 'purple':
		fl1 = False
	elif x == 'green':
		fl2 = False
	elif x == 'blue':
		fl3 = False
	elif x == 'orange':
		fl4 = False
	elif x == 'red':
		fl5 = False
	elif x == 'yellow':
		fl6 = False
print(6 - n)
for i in range(6 - n):
	if fl1:
		print('Power')
		fl1 = False
	elif fl2:
		print('Time')
		fl2 = False
	elif fl3:
		print('Space')
		fl3 = False
	elif fl4:
		print('Soul')
		fl4 = False
	elif fl5:
		print('Reality')
		fl5 = False
	elif fl6:
		print('Mind')
		fl6 = False


color = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
gauntlet = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
n = int(input())
l = []
for i in range(n):
	l.append(input())
print(6 - n)
for i in range(len(l)):
	for j in range(len(color)):
		if l[i] == color[j]:
			gauntlet[j] = -1
for i in range(len(gauntlet)):
	if gauntlet[i] != -1:
		print(gauntlet[i])


n = int(input())
infinity_stones = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
stones_got = []
for i in range(n):
	stones_got.append(input())
for key in stones_got:
	del infinity_stones[key]
print(len(infinity_stones))
for value in list(infinity_stones.values()):
	print(value, end='\n')


n = int(input())
mapping = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for _ in range(n):
	color = input()
	mapping.pop(color)
print(len(mapping))
for value in mapping.values():
	print(value)


dick = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
dick2 = {}
for key in dick.keys():
	dick2[key] = False
n = int(input())
for i in range(n):
	s = input()
	dick2[s] = True
ct = 0
for lol in dick2.keys():
	if dick2[lol] == False:
		ct += 1
print(ct)
for lol in dick2.keys():
	if dick2[lol] == False:
		print(dick[lol])


n = int(input())
l = []
for i in range(n):
	s = input()
	l.append(s[0])
print(6 - n)
l1 = ['p', 'g', 'b', 'o', 'r', 'y']
l2 = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for i in range(0, len(l1)):
	if l1[i] not in l:
		print(l2[i])


n = int(input())
arr = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
rra = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
for i in range(n):
	z = input()
	if z in rra:
		x = rra.index(z)
		del rra[x]
		del arr[x]
	else:
		continue
print(len(arr))
for i in arr:
	print(i)


def main():
	n = int(input())
	a = {}
	a['purple'] = 'Power'
	a['green'] = 'Time'
	a['blue'] = 'Space'
	a['orange'] = 'Soul'
	a['red'] = 'Reality'
	a['yellow'] = 'Mind'
	b = []
	for i in range(n):
		s = input()
		b.append(s)
	print(6 - n)
	for key in a:
		if key not in b:
			print(a[key])
main()


x = int(input())
l = [('Power', 'purple'), ('Time', 'green'), ('Space', 'blue'), ('Soul', 'orange'), ('Reality', 'red'), ('Mind', 'yellow')]
L = []
ll = []
for i in range(0, x):
	L.append(input())
for i in range(0, len(l)):
	flag = 0
	for j in range(0, len(L)):
		if l[i][1] == L[j]:
			flag = 1
			break
	if flag == 0:
		ll.append(l[i][0])
print(len(ll))
for j in ll:
	print(j)


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(int(input())):
	del d[input()]
print(len(d))
print(*[d[x] for x in d], sep='\n')


kamney = int(input())
perchatka = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(1, kamney + 1):
	str = input()
	perchatka.pop(str)
print(len(perchatka))
for value in perchatka.values():
	print(value)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, queue, copy
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def I():
	return int(sys.stdin.readline())

def LS():
	return sys.stdin.readline().split()

def S():
	return input()

def main():
	l1 = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
	l2 = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
	n = I()
	l3 = []
	for _ in range(n):
		l3.append(S())
	for x in l3:
		l1[l2.index(x)] = 'AAA'
	print(6 - len(l3))
	for (i, x) in enumerate(l1):
		if x == 'AAA':
			pass
		else:
			print(l1[i])
main()


n = int(input())
b = [str(input()) for i in range(0, n)]
dict = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'red': 'Reality', 'yellow': 'Mind', 'orange': 'Soul'}
b1 = []
for i in range(0, n):
	b1.append(dict[b[i]])
a = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for i in range(0, n):
	for e in a:
		if b1[i] == e:
			f = a.index(e)
			a.pop(f)
print(len(a))
for i in range(0, len(a)):
	print(a[i])


n = int(input())
q = {'purple', 'green', 'blue', 'orange', 'red', 'yellow'}
w = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(n):
	a = input()
	q.remove(a)
print(6 - n)
for i in q:
	print(w[i])


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
l3 = ['0'] * n
for _ in range(n):
	s = str(input())
	l3[_] = s
print(len(d) - len(l3))
for t in d:
	if t not in l3:
		print(d[t])


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
s = set(d.keys()) - set((input() for _ in range(n)))
print(len(s))
print('\n'.join((d[x] for x in s)))


p = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
print(6 - n)
for i in range(n):
	s = input()
	if s in p:
		p[s] = ''
for (k, v) in p.items():
	if v != '':
		print(v)


n = int(input())
di = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
arr = []
for i in range(n):
	s = input()
	arr.append(s)
arr = list(set(arr))
print(6 - len(arr))
ans = []
for i in di:
	if i not in arr:
		print(di[i])


stones = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
count = int(input())
for x in range(count):
	word = input()
	if word in stones:
		del stones[word]
print(len(stones))
for (k, v) in stones.items():
	print(v)


n = int(input())
inpL = []
for z in range(n):
	inpL.append(str(input()))
print(6 - n)
if 'purple' not in inpL:
	print('Power')
if 'green' not in inpL:
	print('Time')
if 'blue' not in inpL:
	print('Space')
if 'yellow' not in inpL:
	print('Mind')
if 'red' not in inpL:
	print('Reality')
if 'orange' not in inpL:
	print('Soul')


R = lambda : map(int, input().split())
n = int(input())
s = {}
s['purple'] = 'Power'
s['green'] = 'Time'
s['blue'] = 'Space'
s['orange'] = 'Soul'
s['red'] = 'Reality'
s['yellow'] = 'Mind'
l = []
while n:
	a = input()
	l.append(a)
	n -= 1
print(6 - len(l))
for k in s:
	if k not in l:
		print(s[k])


inf = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
d = {}
n = int(input())
for i in range(n):
	s = input()
	d[s] = inf[s]
print(len(inf) - n)
for (key, value) in inf.items():
	if key not in d:
		print(value)


a = int(input())
l = ['purple', 'red', 'green', 'blue', 'orange', 'yellow']
for i in range(a):
	x = input()
	l.remove(x)
print(len(l))
for i in l:
	if i == 'red':
		print('Reality')
	elif i == 'blue':
		print('Space')
	elif i == 'green':
		print('Time ')
	elif i == 'orange':
		print(' Soul')
	elif i == 'yellow':
		print('Mind ')
	else:
		print('Power')


n = int(input())
all_stones = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
thanos_have = [all_stones[input()] for i in range(n)]
names = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
print(6 - len(thanos_have))
for i in range(6):
	if names[i] not in thanos_have:
		print(names[i])


n = int(input())
a = [['purple', 'Power'], ['green', 'Time'], ['blue', 'Space'], ['orange', 'Soul'], ['red', 'Reality'], ['yellow', 'Mind']]
print(6 - n)
for i in range(n):
	b = input()
	for j in range(len(a)):
		if a[j][0] == b:
			del a[j]
			break
for i in range(len(a)):
	print(a[i][1])


x = int(input())
y = []
a = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
for i in range(x):
	y.append(input())
c = {key for (key, val) in a.items() if val not in y}
print(len(c))
for i in c:
	print(i, end='\n')


t = int(input())
List = []
for _ in range(t):
	List.append(input())
print(6 - t)
Dict = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
if 'red' not in List:
	print(Dict['red'])
if 'purple' not in List:
	print(Dict['purple'])
if 'yellow' not in List:
	print(Dict['yellow'])
if 'orange' not in List:
	print(Dict['orange'])
if 'blue' not in List:
	print(Dict['blue'])
if 'green' not in List:
	print(Dict['green'])


n = int(input())
arr = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
arr2 = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
d = {}
for i in range(n):
	s = input()
	d[s] = 1
print(6 - n)
for i in range(len(arr)):
	if arr[i] not in d:
		print(arr2[i])


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
temp = set()
for i in range(n):
	temp |= {d[input()]}
ans = set()
for i in d:
	ans |= {d[i]}
ans = ans - temp
print(len(ans))
for i in ans:
	print(i)


import re
n = int(input())
ans = 'PowerTimeSpaceSoulRealityMind'
c = 6
for i in range(n):
	str = input()
	if str == 'red':
		ans = ans.replace('Reality', '')
		c -= 1
	elif str == 'yellow':
		ans = ans.replace('Mind', '')
		c -= 1
	elif str == 'orange':
		ans = ans.replace('Soul', '')
		c -= 1
	elif str == 'blue':
		ans = ans.replace('Space', '')
		c -= 1
	elif str == 'green':
		ans = ans.replace('Time', '')
		c -= 1
	elif str == 'purple':
		ans = ans.replace('Power', '')
		c -= 1
print(c)
ans = re.findall('[A-Z][^A-Z]*', ans)
for i in range(c):
	print(ans[i])


name = ['Time', 'Mind', 'Soul', 'Power', 'Reality', 'Space']
c = ['green', 'yellow', 'orange', 'purple', 'red', 'blue']
n = int(input())
for i in range(n):
	name[c.index(str(input()))] = 1
print(6 - n)
for i in range(len(name)):
	if name[i] != 1:
		print(name[i])


import os
import sys
import math
n = int(input())
d = {'green': 'Time', 'blue': 'Space', 'purple': 'Power', 'red': 'Reality', 'yellow': 'Mind', 'orange': 'Soul'}
if n == 0:
	print('6')
	for x in d:
		print(d[x])
else:
	while n:
		s = str(input())
		d.pop(s)
		n -= 1
	print(len(d))
	for x in d:
		print(d[x])


glover = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
k = list(glover.keys())
v = list(glover.values())
for _ in range(int(input())):
	k.remove(input())
print(len(k))
print(*[glover[x] for x in k], sep='\n')


dic = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
l = []
for i in range(0, n):
	l.append(input())
print(6 - n)
for key in dic:
	if key not in l:
		print(dic[key])


t = [['purple', 'Power'], ['green', 'Time'], ['blue', 'Space'], ['orange', 'Soul'], ['red', 'Reality'], ['yellow', 'Mind']]
n = int(input())
for i in range(n):
	s = input()
	for j in t:
		if j[0] == s:
			j[0] = 'NOP'
print(6 - n)
for i in t:
	if i[0] == 'NOP':
		continue
	print(i[1])


n = int(input())
Marvel = dict(purple='Power', green='Time', blue='Space', orange='Soul', red='Reality', yellow='Mind')
a = [input() for s in range(n)]
print(6 - n)
for key in Marvel:
	if key not in a:
		print(Marvel[key])


D = {'red': 'Reality', 'orange': 'Soul', 'yellow': 'Mind', 'green': 'Time', 'blue': 'Space', 'purple': 'Power'}
n = int(input())
for i in range(n):
	del D[input()]
print(6 - n)
for i in D:
	print(D[i])


my_dict = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
my_dict2 = {'purple': 0, 'green': 0, 'blue': 0, 'orange': 0, 'red': 0, 'yellow': 0}
n = int(input())
my_list = []
for i in range(0, n):
	str = input()
	if str in my_dict:
		my_dict2[str] = 1
for key in my_dict2:
	if my_dict2[key] == 0:
		my_list.append(my_dict[key])
print(len(my_list))
for v in my_list:
	print(v)


r = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
if n:
	for i in range(n):
		r.pop(input())
print(6 - n)
print(*r.values(), sep='\n')


N = int(input())
colours = set()
for i in range(N):
	S = input().strip()
	colours.add(S)
gauntlets = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for colour in colours:
	del gauntlets[colour]
print(len(gauntlets))
for gauntlet in gauntlets.values():
	print(gauntlet)


dict = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
x = int(input())
for index in range(x):
	m = input()
	del dict[m]
print(len(dict))
for gem in dict:
	print(dict[gem])


def find(list, color):
	for i in list:
		if i[1] == color:
			return i
	return 0
n = int(input())
gems = []
allgems = [('Power', 'purple'), ('Time', 'green'), ('Space', 'blue'), ('Soul', 'orange'), ('Reality', 'red'), ('Mind', 'yellow')]
for i in range(0, n):
	inp = input()
	allgems.remove(find(allgems, inp))
print(6 - n)
for i in allgems:
	print(i[0])


a = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
b = {'purple': 0, 'green': 0, 'blue': 0, 'orange': 0, 'red': 0, 'yellow': 0}
n = int(input())
for i in range(n):
	k = input()
	b[k] += 1
sum = 0
for i in a:
	if b[i] == 0:
		sum += 1
print(sum)
for i in a:
	if b[i] == 0:
		print(a[i])


gem = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
t = int(input())
while t > 0:
	t -= 1
	x = input()
	if x in gem.keys():
		del gem[x]
print(len(gem.keys()))
for (k, v) in gem.items():
	print(v)


gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
colors = []
for _ in range(n):
	colors.append(input())
absent_colors = set(gems.keys()) - set(colors)
absent_gems = [gems[color] for color in absent_colors]
print(len(absent_gems))
for x in absent_gems:
	print(x)


n = int(input())
colors = []
for i in range(n):
	x = input()
	colors.append(x)
meaning = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Reality': 'red', 'Soul': 'orange', 'Mind': 'yellow'}
count = 0
final = []
for i in meaning:
	if meaning[i] in colors:
		continue
	else:
		count += 1
		final.append(i)
print(count)
for i in range(len(final)):
	print(final[i])


dict = {'red': 'Reality', 'orange': 'Soul', 'yellow': 'Mind', 'blue': 'Space', 'green': 'Time', 'purple': 'Power'}
n = int(input())
for i in range(n):
	s = input()
	dict.pop(s)
print(6 - n)
for i in dict:
	print(dict[i])


b = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
c = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
n = int(input())
for i in range(n):
	b[c.index(input())] = 0
m = b.count(0)
for i in range(m):
	b.remove(0)
a = len(b)
print(a)
for i in range(a):
	print(b[i])


t = int(input())
print(6 - t)
li = []
for i in range(t):
	li.append(input())
(a, b, c, d, e, f) = (li.count('red'), li.count('green'), li.count('blue'), li.count('orange'), li.count('yellow'), li.count('purple'))
if a == 0:
	print('Reality')
if b == 0:
	print('Time')
if c == 0:
	print('Space')
if d == 0:
	print('Soul')
if e == 0:
	print('Mind')
if f == 0:
	print('Power')


l = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for _ in range(int(input())):
	color = input()
	if color in l:
		del l[color]
print(len(l))
print(*l.values(), sep='\n')


l1 = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
n = int(input())
l2 = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
l = []
q = []
for i in range(n):
	s = input()
	l.append(s)
for i in range(len(l2)):
	if l2[i] not in l:
		q.append(l1[i])
print(len(q))
for i in range(len(q)):
	print(q[i])


t = int(input())
d = {'red': 'Reality', 'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'yellow': 'Mind'}
l = list(d.values())
for i in range(t):
	r = input()
	l.remove(d[r])
print(len(l))
for y in l:
	print(y)


n = int(input())
l = []
g = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
h = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
for q in range(n):
	m = input()
	l.append(m)
if n == 0:
	print(6)
	for w in g:
		print(w)
else:
	for e in range(n):
		if l[e] in h:
			g[h.index(l[e])] = 0
	print(6 - n)
	for r in g:
		if r != 0:
			print(r)


n = int(input())
a = list()
for i in range(0, n):
	a.append(input())
arr = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
dic = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
count = 0
for x in a:
	if dic[x] != None:
		count = count + 1
		dic[x] = 0
print(6 - count)
for x in arr:
	if dic[x] != 0:
		print(dic[x])


gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'red': 'Reality', 'orange': 'Soul', 'yellow': 'Mind'}
no_gems = 6
n = int(input())
times = 6 - n
if times == 0:
	print('0')
else:
	for i in range(n):
		gem = input()
		if gem in gems.keys():
			del gems[gem]
	print(times)
	for i in gems.keys():
		print(gems[i])


list1 = [['Power', 'purple'], ['Time', 'green'], ['Space', 'blue'], ['Soul', 'orange'], ['Reality', 'red'], ['Mind', 'yellow']]
l1 = []
l2 = []
n = int(input())
for i in range(n):
	s = input()
	l1.append(s)
for i in range(len(l1)):
	for j in range(len(list1)):
		if l1[i] == list1[j][1]:
			l2.append(list1[j])
print(len(list1) - n)
for i in range(len(list1)):
	if list1[i] not in l2:
		print(list1[i][0])


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(int(input())):
	d.pop(input())
print(len(d))
l = d.values()
for i in l:
	print(i)


G = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for _ in range(int(input())):
	G.pop(input())
print(len(G))
for v in G.values():
	print(v)


n = int(input())
res = 6 - n
print(res)
stonedict = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
stones = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
lst = []
for i in range(n):
	i = input()
	lst.append(i)
for j in stones:
	if not j in lst:
		type = stonedict[j]
		print(type)


n = int(input())
d1 = dict()
d1['red'] = 'Reality'
d1['purple'] = 'Power'
d1['blue'] = 'Space'
d1['green'] = 'Time'
d1['orange'] = 'Soul'
d1['yellow'] = 'Mind'
d2 = dict()
d2['red'] = False
d2['purple'] = False
d2['blue'] = False
d2['green'] = False
d2['orange'] = False
d2['yellow'] = False
count = 0
stri = ''
for i in range(0, n):
	r = input()
	d2[r] = True
for j in d2.keys():
	if d2[j] == False:
		count = count + 1
print(count)
for j in d2.keys():
	if d2[j] == False:
		print(d1[j])


dic = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
l = []
for _ in range(n):
	s = map(str, input().split())
	for key in s:
		if dic[key]:
			dic.pop(key)
print(6 - n)
for (index, values) in dic.items():
	print(values)


n = int(input())
a = ['Mind', 'Soul', 'Space', 'Time', 'Power', 'Reality']
d = {}
d['red'] = 'Reality'
d['orange'] = 'Soul'
d['green'] = 'Time'
d['purple'] = 'Power'
d['yellow'] = 'Mind'
d['blue'] = 'Space'
for i in range(n):
	stone = str(input())
	a.remove(d[stone])
print(6 - n)
for i in a:
	print(i)


dic = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
dic1 = {'purple': 0, 'green': 0, 'blue': 0, 'orange': 0, 'red': 0, 'yellow': 0}
n = int(input())
count = 0
for i in range(n):
	dic1[input()] = 1
	count += 1
print(6 - count)
for x in dic1.keys():
	if dic1[x] == 0:
		print(dic[x])


n = int(input())
dict = {}
dict = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
y = []
f = []
count = 0
for i in range(n):
	z = input()
	y.append(z)
if 'purple' not in y:
	count = count + 1
	f.append(dict['purple'])
if 'green' not in y:
	count = count + 1
	f.append(dict['green'])
if 'blue' not in y:
	count = count + 1
	f.append(dict['blue'])
if 'orange' not in y:
	count = count + 1
	f.append(dict['orange'])
if 'red' not in y:
	count = count + 1
	f.append(dict['red'])
if 'yellow' not in y:
	count = count + 1
	f.append(dict['yellow'])
print(count)
for i in range(count):
	print(f[i])


n = int(input())
s = []
for i in range(n):
	t = input()
	s.append(t)
d = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
ct = 0
a = []
for (k, v) in d.items():
	if v not in s:
		ct += 1
		a.append(k)
print(ct)
for i in a:
	print(i)


n = int(input())
colors = set()
raw = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(n):
	line = input()
	colors.add(line)
res = [k for k in raw if k not in colors]
print(len(res))
for k in res:
	print(raw[k])


gems = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
colours = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
n = int(input())
not_ = []
for i in range(n):
	x = input()
	not_.append(x)
gem = []
for i in range(0, len(colours)):
	if colours[i] not in not_:
		gem.append(gems[i])
	else:
		continue
print(len(gem))
for i in gem:
	print(i)


colors_remaining = {'purple', 'green', 'blue', 'orange', 'red', 'yellow'}
color2ability = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
for i in range(n):
	color = input().strip()
	colors_remaining.remove(color)
print(len(colors_remaining))
for color in colors_remaining:
	print(color2ability[color])


n = int(input())
arr = list()
x = str()
for i in range(n):
	x = str(input())
	arr.append(x)
for i in range(n):
	arr[i].lower()
check = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
y = 6 - n
print(y)
for i in check:
	if i not in arr:
		print(check[i])


N = int(input())
data = []
for i in range(N):
	data.append(input())
ht = {}
colors = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
stones = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for i in data:
	ht[colors.index(i)] = True
ans = []
for i in colors:
	if ht.get(colors.index(i), None) == None:
		ans.append(stones[colors.index(i)])
print(len(ans))
for i in ans:
	print(i)


n = int(input())
i = 0
l = []
while n > i:
	k = str(input())
	l = l + [k]
	i += 1
count = 0
d = {'yellow': 'Mind', 'green': 'Time', 'orange': 'Soul', 'purple': 'Power', 'red': 'Reality', 'blue': 'Space'}
print(6 - n)
if 'green' in l:
	count += 1
else:
	print(d['green'])
if 'yellow' in l:
	count += 1
else:
	print(d['yellow'])
if 'orange' in l:
	count += 1
else:
	print(d['orange'])
if 'purple' in l:
	count += 1
else:
	print(d['purple'])
if 'red' in l:
	count += 1
else:
	print(d['red'])
if 'blue' in l:
	count += 1
else:
	print(d['blue'])


m = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
a = []
for _ in range(n):
	c = input()
	a.append(c)
v = set()
for x in a:
	v.add(x)
ans = []
for k in m.keys():
	if k not in v:
		ans.append(m[k])
print(len(ans))
print('\n'.join(ans))


TN = 1

def solution():
	n = int(input())
	l = []
	d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
	s = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
	ans = []
	for i in range(n):
		l.append(input())
	for i in range(6):
		if s[i] not in l:
			ans.append(d[s[i]])
	print(len(ans))
	print('\n'.join(ans))
while TN != 0:
	solution()
	TN -= 1


n = int(input())
gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
count = 6
missing = list(gems.keys())
NotMissing = []
for _ in range(n):
	s = input()
	NotMissing.append(s)
	count -= 1
print(count)
missing = set(missing) - set(NotMissing)
for color in missing:
	print(gems[color])


powers = {'purple': 'Power', 'blue': 'Space', 'orange': 'Soul', 'yellow': 'Mind', 'green': 'Time', 'red': 'Reality'}
n = int(input())
for i in range(n):
	power = input()
	del powers[power]
print(len(powers))
for element in powers:
	print(powers[element])


stones = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
num_stones = int(input())
for current_index in range(num_stones):
	stones.pop(input())
print(6 - num_stones)
for (x, y) in stones.items():
	print(y)


l = ['Power', 'Space', 'Soul', 'Mind', 'Time', 'Reality']
i = int(input())
while i > 0:
	s = input()
	if s == 'red':
		del l[l.index('Reality')]
	elif s == 'purple':
		del l[l.index('Power')]
	elif s == 'green':
		del l[l.index('Time')]
	elif s == 'blue':
		del l[l.index('Space')]
	elif s == 'orange':
		del l[l.index('Soul')]
	elif s == 'yellow':
		del l[l.index('Mind')]
	i -= 1
print(len(l))
for a in l:
	print(a)


n = int(input())
a = []
for i in range(n):
	s = input()
	a.append(s)
b = []
if 'purple' not in a:
	b.append('Power')
if 'green' not in a:
	b.append('Time')
if 'blue' not in a:
	b.append('Space')
if 'orange' not in a:
	b.append('Soul')
if 'red' not in a:
	b.append('Reality')
if 'yellow' not in a:
	b.append('Mind')
print(len(b))
for q in b:
	print(q)


from bisect import bisect_left, bisect_right
Inf = int(1e+18) + 7

def tuple_input(type):
	return map(type, input().strip().split())
M = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
for _ in range(n):
	c = input().strip()
	M[c] += '_'
res = list()
for (key, val) in M.items():
	if val[-1] is not '_':
		res.append(val)
print(len(res))
for e in res:
	print(e)


a = int(input())
ilk = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
son = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
cikar = []
for i in range(a):
	x = str(input())
	b = son.index(x)
	cikar.append(ilk[b])
for i in range(len(cikar)):
	if cikar[i] in ilk:
		ilk.remove(cikar[i])
print(len(ilk))
for i in range(len(ilk)):
	print(ilk[len(ilk) - i - 1])


n = int(input())
color = ['red', 'purple', 'green', 'blue', 'yellow', 'orange']
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
print(6 - n)
q = [input() for i in range(n)]
for i in color:
	if i not in q:
		print(d[i])


n = int(input())
dicta = {'purple': 'Power', 'blue': 'Space', 'green': 'Time', 'red': 'Reality', 'yellow': 'Mind', 'orange': 'Soul'}
listc = []
for i in range(n):
	l = input()
	listc.append(l)
print(6 - n)
for i in dicta:
	if i not in listc:
		print(dicta[i])


n = int(input())
L1 = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
D1 = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
L2 = []
for i in range(n):
	L2.append(input())
print(6 - n)
for i in L2:
	if i in L1:
		L1.remove(i)
for i1 in L1:
	print(D1[i1])


n = int(input())
arr = []
for i in range(n):
	arr.append(input())
ans = []
if 'purple' not in arr:
	ans.append('Power')
if 'green' not in arr:
	ans.append('Time')
if 'blue' not in arr:
	ans.append('Space')
if 'orange' not in arr:
	ans.append('Soul')
if 'red' not in arr:
	ans.append('Reality')
if 'yellow' not in arr:
	ans.append('Mind')
print(len(ans))
for i in ans:
	print(i)


gems_saw = int(input())
gems_seen_color = []
for i in range(gems_saw):
	gems_seen_color.append(str(input()))
gem_color = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
all_colors = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
if gems_saw < 6:
	not_seen_color = set(all_colors).difference(gems_seen_color)
	print_gems = [gem_color.get(x) for x in list(not_seen_color)]
	print(len(print_gems))
	for gem in print_gems:
		print(gem)
else:
	print('0')


n = int(input())
a = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
b = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
c = [False] * 6
for i in range(n):
	s = input()
	c[a.index(s)] = True
ans = 0
for i in range(6):
	if not c[i]:
		ans += 1
print(ans)
for i in range(6):
	if not c[i]:
		print(b[i])


DATA = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for _ in [0] * int(input()):
	DATA.pop(input())
print(len(DATA), *DATA.values(), sep='\n')


def main():
	from sys import stdin, stdout

	def solve(tc: int):
		buf = ''
		GAUNTLET = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
		n = int(stdin.readline())
		available = set([a[:-1] for a in stdin.readlines()])
		buf += str(len(GAUNTLET.keys()) - len(available)) + '\n'
		for key in GAUNTLET:
			if key not in available:
				buf += GAUNTLET[key] + '\n'
		stdout.write(buf + '\n')
	TC = 1
	for tc in range(TC):
		solve(tc)
main()


colors = {'purple': '1', 'green': '2', 'blue': '3', 'orange': '4', 'red': '5', 'yellow': '6'}
stones = {'1': 'Power', '2': 'Time', '3': 'Space', '4': 'Soul', '5': 'Reality', '6': 'Mind'}
a = int(input())
c = []
for i in range(a):
	b = input()
	c.append(colors[b])
print(6 - a)
for i in range(6):
	if c.count(str(i + 1)) == 0:
		print(stones[str(i + 1)])


colors_dict = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
colors = list(colors_dict.keys())
n = int(input())
for i in range(n):
	s = input()
	colors.remove(s)
print(len(colors))
for c in colors:
	print(colors_dict[c])


l = ['red', 'green', 'blue', 'orange', 'purple', 'yellow']
l1 = []
t = int(input())
while t > 0:
	s = str(input())
	l1.append(s)
	t -= 1
x = set(l)
y = set(l1)
z = set(x ^ y)
m = list(z)
print(len(m))
for i in m:
	if i == 'green':
		print('Time')
	elif i == 'purple':
		print('Power')
	elif i == 'blue':
		print('Space')
	elif i == 'orange':
		print('Soul')
	elif i == 'red':
		print('Reality')
	elif i == 'yellow':
		print('Mind')


gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
colors = []
for _ in range(n):
	colors.append(input())
print(6 - n)
for (key, value) in gems.items():
	if key not in colors:
		print(value)


n = int(input())
a = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
b = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for i in range(n):
	w = input()
	b.remove(b[a.index(w)])
	a.remove(w)
print(len(b))
for i in range(len(b)):
	print(b[i])


n = int(input())
a = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for i in range(n):
	s = input()
	if s == 'purple':
		a.remove('Power')
	elif s == 'green':
		a.remove('Time')
	elif s == 'blue':
		a.remove('Space')
	elif s == 'orange':
		a.remove('Soul')
	elif s == 'red':
		a.remove('Reality')
	else:
		a.remove('Mind')
print(len(a))
for i in a:
	print(i)


n = int(input())
s = []
for i in range(n):
	s.append(input())
s1 = []
if 'purple' not in s:
	s1.append('Power')
if 'green' not in s:
	s1.append('Time')
if 'blue' not in s:
	s1.append('Space')
if 'orange' not in s:
	s1.append('Soul')
if 'red' not in s:
	s1.append('Reality')
if 'yellow' not in s:
	s1.append('Mind')
print(len(s1), *s1, sep='\n')


n = int(input())
stones = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
glove = []
for i in range(n):
	glove.append(input())
not_present = [stones[i] for i in stones.keys() if i not in glove]
print(len(not_present))
print('\n'.join(not_present))


gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
N = int(input())
arr = []
for i in range(N):
	del gems[input()]
print(len(gems))
for cols in gems:
	print(gems[cols])


n = int(input())
x = {'red': 'Reality', 'yellow': 'Mind', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'purple': 'Power'}
x1 = ['Reality', 'Mind', 'Time', 'Space', 'Soul', 'Power']
(x3, x4) = ([], 0)
if n == 0:
	print(6)
	for i in range(6):
		print(x1[i])
else:
	for i in range(n):
		z = str(input())
		x3.append(x[z])
	print(6 - len(x3))
	for i in range(len(x1)):
		if x1[i] not in x3:
			print(x1[i])


n = int(input())
dic = {}
dic['purple'] = 'power'
dic['green'] = 'time'
dic['blue'] = 'space'
dic['orange'] = 'soul'
dic['red'] = 'reality'
dic['yellow'] = 'mind'
for _ in range(n):
	s = input()
	if s in dic:
		dic.pop(s)
print(len(dic))
for v in dic.values():
	if v != '':
		print(v.capitalize())


GEMS = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
COLOR = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
N = int(input())
for _ in range(N):
	GEMS[COLOR.index(input())] = 'LORENZO'
print(6 - N)
for _ in GEMS:
	if _ != 'LORENZO':
		print(_)


col_to_stone = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
stones_cols = set()
n = int(input())
for i in range(n):
	stones_cols.add(input())
ans = []
for key in col_to_stone:
	if not key in stones_cols:
		ans.append(col_to_stone[key])
print(len(ans))
print('\n'.join(ans))


glove = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
for i in range(0, n):
	color = input()
	del glove[color]
print(6 - n)
for value in glove.values():
	print(value)


import math
gg = 'abcdefghijklmnopqrstuvwxyz'
n = int(input())
l = []
for i in range(n):
	a = input()
	l.append(a)
v = ['Time', 'Mind', 'Soul', 'Power', 'Reality', 'Space']
c = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
for i in range(n):
	c.pop(c.index(l[i]))
print(len(c))
for i in range(len(c)):
	if c[i] == 'purple':
		c[i] = 'Power'
	if c[i] == 'green':
		c[i] = 'Time'
	if c[i] == 'orange':
		c[i] = 'Soul'
	if c[i] == 'red':
		c[i] = 'Reality'
	if c[i] == 'yellow':
		c[i] = 'Mind'
	if c[i] == 'blue':
		c[i] = 'Space'
for i in c:
	print(i)


gauntlet = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
present = []
print(6 - n)
for line in range(n):
	color = input()
	present.append(color)
for color in gauntlet.keys():
	if color not in present:
		print(gauntlet[color])


n = int(input())
list_ = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
list2 = []
list3 = []
for i in range(n):
	input_ = str(input())
	list2.append(input_)
for j in list_:
	if j in list2:
		continue
	else:
		list3.append(j)
print(len(list3))
for k in list3:
	if k == 'purple':
		print('Power')
	elif k == 'green':
		print('Time')
	elif k == 'blue':
		print('Space')
	elif k == 'orange':
		print('Soul')
	elif k == 'red':
		print('Reality')
	else:
		print('Mind')


l = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
dic = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'yellow': 'Mind', 'red': 'Reality'}
for _ in range(int(input())):
	stone = input()
	l.remove(stone)
print(len(l))
for i in l:
	print(dic[i])


stones_default = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
while n > 0:
	stone = str(input())
	del stones_default[stone]
	n = n - 1
print(len(stones_default))
for (key, value) in stones_default.items():
	print(value)


n = int(input())
stones = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
colors = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
colors1 = []
print(6 - n)
for i in range(n):
	s = str(input())
	colors1.append(s)
for i in range(6):
	if colors1.count(colors[i]) == 0:
		print(stones[i])


n = int(input())
l = set()
for k in range(n):
	l.add(input())
L = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
L1 = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
d = {}
for k in range(6):
	d[L[k]] = L1[k]
print(6 - n)
for k in L:
	if not k in l:
		print(d[k])


n = int(input())
c = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
s = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
st = []
for i in range(n):
	st.append(input())
no_st = [u for u in c if u not in st]
print(6 - n)
print('\n'.join([s[c.index(u)] for u in no_st]))


n = int(input())
l = []
d = dict()
d['red'] = 'Reality'
d['purple'] = 'Power'
d['green'] = 'Time'
d['blue'] = 'Space'
d['yellow'] = 'Mind'
d['orange'] = 'Soul'
for i in range(n):
	l.append(input())
x = 6 - len(set(l))
print(x)
for (key, value) in d.items():
	if key not in l:
		print(value)


l1 = ['yellow', 'red', 'orange', 'blue', 'green', 'purple']
l2 = ['Mind', 'Reality', 'Soul', 'Space', 'Time', 'Power']
l3 = ['Mind', 'Reality', 'Soul', 'Space', 'Time', 'Power']
n = int(input())
for i in range(n):
	st = input()
	for j in range(6):
		if l1[j] == st:
			l2.remove(l3[j])
			break
print(6 - n)
for i in l2:
	print(i)


n = int(input())
strings = [input() for i in range(n)]
need = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
print(6 - n)
print('\n'.join([b for (a, b) in need.items() if a not in strings]))


dict = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
dict1 = {}
n = int(input())
while n:
	str = input()
	if str == 'purple':
		dict1['Power'] = str
	elif str == 'green':
		dict1['Time'] = str
	elif str == 'blue':
		dict1['Space'] = str
	elif str == 'orange':
		dict1['Soul'] = str
	elif str == 'red':
		dict1['Reality'] = str
	elif str == 'yellow':
		dict1['Mind'] = str
	n -= 1
val = list(dict.keys())
val_list = list(dict1.keys())
l = [key for key in val if key not in val_list]
print(len(l))
for i in range(len(l)):
	print(l[i])


n = int(input())
a = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
b = set(a.keys())
for i in range(n):
	b.remove(input())
print(6 - n)
for i in b:
	print(a[i])


a = int(input())
m = 1
x = []
while m <= a:
	x = x + [input()]
	m += 1
b = 1
jisan = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
while b <= a:
	if x[b - 1] in jisan:
		del jisan[x[b - 1]]
	b += 1
pp = jisan.values()
pp = list(pp)
print(len(pp), end='\n')
for zz in pp:
	print(zz)


a = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
b = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
vis = {'purple': 0, 'green': 0, 'blue': 0, 'orange': 0, 'red': 0, 'yellow': 0}
c = [6]
n = int(input())
for i in range(n):
	m = input()
	vis[m] = 1
k = 0
print(6 - n)
for i in vis:
	if vis[i] == 0:
		print(a[k])
	k = k + 1


import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue
from decimal import *

class Scanner:

	@staticmethod
	def int():
		return int(sys.stdin.readline().rstrip())

	@staticmethod
	def string():
		return sys.stdin.readline().rstrip()

	@staticmethod
	def map_int():
		return [int(x) for x in Scanner.string().split()]

	@staticmethod
	def string_list(n):
		return [input() for i in range(n)]

	@staticmethod
	def int_list_list(n):
		return [Scanner.map_int() for i in range(n)]

	@staticmethod
	def int_cols_list(n):
		return [int(input()) for i in range(n)]

class Math:

	@staticmethod
	def gcd(a, b):
		if b == 0:
			return a
		return Math.gcd(b, a % b)

	@staticmethod
	def lcm(a, b):
		return a * b // Math.gcd(a, b)

	@staticmethod
	def divisor(n):
		res = []
		i = 1
		for i in range(1, int(n ** 0.5) + 1):
			if n % i == 0:
				res.append(i)
				if i != n // i:
					res.append(n // i)
		return res

	@staticmethod
	def round_up(a, b):
		return -(-a // b)

	@staticmethod
	def is_prime(n):
		if n < 2:
			return False
		if n == 2:
			return True
		if n % 2 == 0:
			return False
		d = int(n ** 0.5) + 1
		for i in range(3, d + 1, 2):
			if n % i == 0:
				return False
		return True

def pop_count(x):
	x = x - (x >> 1 & 6148914691236517205)
	x = (x & 3689348814741910323) + (x >> 2 & 3689348814741910323)
	x = x + (x >> 4) & 1085102592571150095
	x = x + (x >> 8)
	x = x + (x >> 16)
	x = x + (x >> 32)
	return x & 127
MOD = int(1000000000.0) + 7
INF = int(1000000000000000.0)

def isOK(A):
	A.sort()
	for i in range(len(A) - 1):
		if A[i] + 1 != A[i + 1]:
			return False
	return True

def solve():
	N = Scanner.int()
	M = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
	M = {v: k for (k, v) in M.items()}
	for _ in range(N):
		s = Scanner.string()
		M[s] = 0
	M = {v: k for (k, v) in M.items()}
	print(6 - N)
	for (k, v) in M.items():
		if k != 0:
			print(k)

def main():
	solve()
main()


gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
for i in range(n):
	color = input()
	del gems[color]
print(len(gems))
for (_, stone) in gems.items():
	print(stone)


a = int(input())
dict = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
arr = []
for k in range(a):
	arr.append(input())
ar = []
for i in dict:
	if i not in arr:
		ar.append(i)
print(len(ar))
for j in ar:
	print(dict[j])


def s():
	n = int(input())
	gems = []
	if n != 0:
		for i in range(n):
			gems.append(input())
	print(6 - n)
	if 'purple' not in gems:
		print('Power')
	if 'green' not in gems:
		print('Time')
	if 'blue' not in gems:
		print('Space')
	if 'orange' not in gems:
		print('Soul')
	if 'red' not in gems:
		print('Reality')
	if 'yellow' not in gems:
		print('Mind')
s()


a = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
b = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
count = 0
for _ in range(int(input())):
	s = input()
	a.remove(a[b.index(s)])
	b.remove(b[b.index(s)])
	count += 1
print(6 - count)
for i in a:
	print(i)


n = int(input())
mas = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
mas1 = ['purple', 'Power', 'green', 'Time', 'blue', 'Space', 'orange', 'Soul', 'red', 'Reality', 'yellow', 'Mind']
for i in range(n):
	mas.remove(input())
print(len(mas))
for i in mas:
	print(mas1[mas1.index(i) + 1])


gauntlet = [['Power', 'purple'], ['Time', 'green'], ['Space', 'blue'], ['Soul', 'orange'], ['Reality', 'red'], ['Mind', 'yellow']]
colors = []
n = int(input())
for i in range(n):
	colors.append(input())
for j in range(n):
	for k in range(6):
		if colors[j] in gauntlet[k][1]:
			gauntlet[k][0] = 1
print(6 - n)
for i in range(0, 6):
	if gauntlet[i][0] != 1:
		print(gauntlet[i][0])


n = int(input())
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(n):
	s = input()
	d[s] = 0
print(6 - n)
for item in d.values():
	if item != 0:
		print(item)


n = int(input())
print(6 - n)
s = {'Time', 'Mind', 'Soul', 'Power', 'Reality', 'Space'}
l = []
for i in range(n):
	a = input()
	if a == 'red':
		l.append('Reality')
	elif a == 'purple':
		l.append('Power')
	elif a == 'green':
		l.append('Time')
	elif a == 'orange':
		l.append('Soul')
	elif a == 'yellow':
		l.append('Mind')
	else:
		l.append('Space')
k = s - set(l)
print(*k, sep='\n')


n = int(input())
colors_list = []
for i in range(n):
	color = input()
	colors_list.append(color)
dict = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
orignal_colors = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
subtract_list = list(set(orignal_colors) - set(colors_list))
print(len(subtract_list))
for (key, value) in dict.items():
	if value in subtract_list:
		print(key)


a = [['Power', 'purple'], ['Time', 'green'], ['Space', 'blue'], ['Soul', 'orange'], ['Reality', 'red'], ['Mind', 'yellow']]
b = []
n = int(input())
for i in range(n):
	s = input()
	for el in a:
		if el[1] != s:
			b.append(el)
	a = b[:]
	b = []
print(len(a))
for el in a:
	print(el[0])


def answer():
	n = int(input())
	m = ['Power', 'Time', 'Space', 'Reality', 'Soul', 'Mind']
	c = ['purple', 'green', 'blue', 'red', 'orange', 'yellow']
	a = []
	while n:
		a.append(input())
		n -= 1
	d = []
	for x in a:
		d.append(m[c.index(x)])
	for x in d:
		m.remove(x)
	print(len(m))
	if len(m):
		for x in m:
			print(x)
answer()


q = lambda : map(int, input().split())
qi = lambda : int(input())
qs = lambda : input().split()
t = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
t = {y: x for (x, y) in t.items()}
a = []
n = qi()
for _ in range(n):
	a.append(input())
print(6 - n, *[t.get(i) for i in t.keys() if i not in a], sep='\n')


d = {}
d['purple'] = 'Power'
d['green'] = 'Time'
d['blue'] = 'Space'
d['orange'] = 'Soul'
d['red'] = 'Reality'
d['yellow'] = 'Mind'
n = int(input())
L = []
L2 = []
for i in range(n):
	L.append(input())
for i in d:
	if i not in L:
		L2.append(i)
print(len(L2))
for i in L2:
	print(d[i])


a = int(input())
c = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
import math
for i in range(0, a):
	b = str(input())
	if b[0] == 'p':
		c.remove('Power')
	if b[0] == 'g':
		c.remove('Time')
	if b[0] == 'b':
		c.remove('Space')
	if b[0] == 'o':
		c.remove('Soul')
	if b[0] == 'r':
		c.remove('Reality')
	if b[0] == 'y':
		c.remove('Mind')
print(6 - a)
if a != 6:
	for i in range(len(c)):
		print(c[i])


d = {}
d['purple'] = 'Power'
d['green'] = 'Time'
d['blue'] = 'Space'
d['orange'] = 'Soul'
d['red'] = 'Reality'
d['yellow'] = 'Mind'
l = []
ls = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
n = int(input())
for i in range(n):
	s = str(input())
	l.append(d[s])
l = set(l)
print(len(ls) - len(l))
for it in ls:
	if it not in l:
		print(it)


from collections import deque, Counter
import array
from itertools import combinations, permutations
from math import sqrt

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

def read_int_array():
	return [int(i) for i in input().strip().split(' ')]
n = read_int()
s = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(n):
	k = input().strip()
	if k in s:
		del s[k]
print(len(s))
for k in s:
	print(s[k])


ans = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
for _ in range(n):
	s = input()
	ans.pop(s)
print(len(ans))
for (k, v) in ans.items():
	print(v)


n = int(input())
(x, y, z) = ([], {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}, ['purple', 'green', 'blue', 'orange', 'red', 'yellow'])
for i in range(0, n):
	x.append(input())
z = set(z) - set(x)
print(len(z))
for i in z:
	print(y[i])


z = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
x = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
y = []
a = int(input())
for i in range(a):
	b = input()
	y.append(b)
print(len(x) - len(y))
for i in range(6):
	if x[i] not in y:
		print(z[x[i]])


n = int(input())
nap = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
ta = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
tod = []
la = []
for x in range(n):
	tod.append(input())
for item in ta:
	if item not in tod:
		la.append(nap[ta.index(item)])
	else:
		pass
print(len(la))
for item in la:
	print(item)


dict_stones = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
m = 6 - n
colors = []
while n > 0:
	color = str(input())
	colors.append(color)
	n -= 1
stone_names = [value for (key, value) in dict_stones.items() if key not in colors]
print(m)
for name in stone_names:
	print(name)


gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
list = []
for i in range(0, n):
	m = input()
	list.append(m)
print(6 - n)
for colour in gems.keys():
	if colour not in list:
		print(gems[colour])


L1 = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
L2 = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
n = int(input())
L3 = []
for i in range(n):
	s = str(input())
	L3.append(s)
L4 = []
c = 0
for i in L2:
	if i not in L3:
		c += 1
		L4.append(L1[L2.index(i)])
print(c)
for i in L4:
	print(i)


boje = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
moci = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
lista = []
n = int(input())
for i in range(n):
	boja = input()
	boje[boje.index(boja)] = None
print(6 - n)
for i in range(6):
	if boje[i] is not None:
		lista.append(moci[i])
for i in lista:
	print(i)


gauntlet = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
s = []
n = int(input())
for i in range(n):
	s.append(input())
ss = []
for (i, j) in gauntlet.items():
	if j not in s:
		ss.append(i)
print(len(ss))
for i in ss:
	print(i)


n = int(input())
g = []
for i in range(n):
	s = input()
	g.append(s)
m = 6 - n
print(m)
while m:
	if 'purple' not in g:
		g.append('purple')
		print('Power')
	elif 'red' not in g:
		g.append('red')
		print('Reality')
	elif 'green' not in g:
		g.append('green')
		print('Time')
	elif 'blue' not in g:
		g.append('blue')
		print('Space')
	elif 'orange' not in g:
		g.append('orange')
		print('Soul')
	elif 'yellow' not in g:
		g.append('yellow')
		print('Mind')
	m -= 1


ddi = {'purple': 'Power ', 'green': 'Time ', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
for i in range(n):
	m = input()
	del ddi[m]
print(len(ddi))
for key in ddi.keys():
	print(ddi[key])


a = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
b = []
n = int(input())
for x in range(n):
	b.append(input())
s = 0
c = []
for x in a:
	if x not in b:
		s += 1
		c.append(a[x])
print(s)
for x in range(len(c)):
	print(c[x])


gem_map = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for _ in range(int(input())):
	s = input().strip()
	del gem_map[s]
print(len(gem_map))
for i in gem_map:
	print(gem_map[i])


tmp = {'purple': ['Power', 0], 'green': ['Time', 0], 'blue': ['Space', 0], 'orange': ['Soul', 0], 'red': ['Reality', 0], 'yellow': ['Mind', 0]}
i = input
c = 0
a = []
for j in range(int(i())):
	tmp[i()][1] = 1
for j in tmp.keys():
	if tmp[j][1] == 0:
		c += 1
		a.append(tmp[j][0])
print(c)
for j in a:
	print(j)


n = int(input())
st = {'Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind'}
for x in range(n):
	str = input()
	if str == 'purple':
		st.remove('Power')
	elif str == 'green':
		st.remove('Time')
	elif str == 'blue':
		st.remove('Space')
	elif str == 'orange':
		st.remove('Soul')
	elif str == 'red':
		st.remove('Reality')
	else:
		st.remove('Mind')
print(len(st))
for x in st:
	print(x)


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
N = int(input())
a = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
for i in range(N):
	color = input()
	if color in a:
		a.remove(color)
print(len(a))
for i in range(len(a)):
	stone = a[i]
	print(d[stone])


dict = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
for i in range(n):
	str = input()
	del dict[str]
print(len(dict))
for i in dict:
	print(dict[i])


n = int(input())
lst = []
while n:
	n -= 1
	s = input()
	lst.append(s)
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
print(6 - len(lst))
for i in d:
	if i not in lst:
		print(d[i])


li = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
gi = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
for i1 in range(n):
	li.remove(gi[input()])
print(len(li))
for i in li:
	print(i)


a = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
b = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
n = int(input())
c = [input() for _ in [0] * n]
d = [b[x] for (x, y) in enumerate(a) if y not in c]
print(len(d), *d, sep='\n')


d = {}
d['purple'] = 'Power'
d['green'] = 'Time'
d['blue'] = 'Space'
d['orange'] = 'Soul'
d['red'] = 'Reality'
d['yellow'] = 'Mind'
ori = set()
ori.add('purple')
ori.add('green')
ori.add('blue')
ori.add('orange')
ori.add('yellow')
ori.add('red')
s = set()
n = int(input())
tmp = set()
for i in range(n):
	tmp.add(input())
z = ori - tmp
print(len(z))
for i in z:
	print(d[i])


r = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
all_r = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
n = int(input())
for i in range(n):
	curr_r = input()
	all_r.remove(curr_r)
print(len(all_r))
for e in all_r:
	print(r[e])


n = int(input())
col = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
pow = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
while n:
	n -= 1
	c = input()
	pow.pop(col.index(c))
	col.pop(col.index(c))
print(len(pow))
for x in pow:
	print(x)


n = int(input())
d = []
x = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
f = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
ans = []
s = 0
for t in range(n):
	a = input()
	d.append(a)
for t in f:
	if t not in d:
		ans.append(x[t])
		s += 1
print(s)
for t in range(s):
	print(ans[t])


dict1 = {}
dict1['purple'] = 'Power'
dict1['green'] = 'Time'
dict1['blue'] = 'Space'
dict1['orange'] = 'Soul'
dict1['red'] = 'Reality'
dict1['yellow'] = 'Mind'
x = int(input())
gems = []
for i in range(x):
	l = input()
	gems.append(l)
res = []
val = list(dict1.keys())
for i in range(6):
	if val[i] not in gems:
		res.append(dict1[val[i]])
print(len(res))
print('\n'.join(map(str, res)))


n = int(input())
lst = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
lst1 = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for i in range(n):
	s = input()
	if s in lst:
		ind = lst.index(s)
		lst.remove(s)
		del lst1[ind]
print(len(lst))
print('\n'.join(lst1))


main = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
type_s = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
n = int(input())
col = []
for i in range(n):
	a = input()
	col.append(a)
not_present = []
for i in main:
	if i in col:
		pass
	else:
		not_present.append(i)
count = len(not_present)
ss = []
for i in not_present:
	if i == 'purple':
		ss.append('Power')
	elif i == 'green':
		ss.append('Time')
	elif i == 'blue':
		ss.append('Space')
	elif i == 'orange':
		ss.append('Soul')
	elif i == 'red':
		ss.append('Reality')
	elif i == 'yellow':
		ss.append('Mind')
print(count)
for i in ss:
	print(i)


n = int(input())
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(n):
	s = input()
	del d[s]
print(6 - n)
for i in d.keys():
	print(d[i])


n = int(input())
l1 = []
k = []
count = 0
l = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(n):
	a = input()
	k.append(a)
for i in l:
	if i not in k:
		count += 1
		l1.append(l[i])
print(count)
for i in l1:
	print(i)


check = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
arr = []
for _ in range(int(input())):
	string = input()
	arr.append(string)
print(len(check) - len(arr))
for y in check:
	if y not in arr:
		print(check[y])


x = int(input())
p = False
t = False
sp = False
so = False
r = False
m = False
for i in range(x):
	color = input()
	if color == 'purple':
		p = True
	if color == 'green':
		t = True
	if color == 'blue':
		sp = True
	if color == 'orange':
		so = True
	if color == 'red':
		r = True
	if color == 'yellow':
		m = True
print(6 - x)
if p == False:
	print('Power')
if t == False:
	print('Time')
if sp == False:
	print('Space')
if so == False:
	print('Soul')
if r == False:
	print('Reality')
if m == False:
	print('Mind')


n = int(input())
l = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
a = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
z = []
for i in range(n):
	s = str(input())
	z.append(s)
c = 0
d = []
for i in range(0, len(a)):
	if a[i] not in z:
		d.append(l[i])
		c = c + 1
print(c)
for i in range(0, len(d)):
	print(d[i])


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
l1 = []
for v in range(0, n):
	x = input()
	l1.append(x)
k = list(d.keys())
s = 0
for gh in k:
	if gh not in l1:
		s += 1
print(s)
for gh in k:
	if gh not in l1:
		print(d[gh])


from math import ceil

def main():
	d = {'purple', 'green', 'blue', 'orange', 'red', 'yellow'}
	ddd = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
	n = int(input())
	dd = set([input() for _ in range(n)])
	df = d.difference(dd)
	print(len(df))
	for d in df:
		print(ddd[d])
main()


gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
if n == 0:
	print(len(gems))
	for val in gems.values():
		print(val)
else:
	for _ in range(n):
		color = input()
		if color in gems:
			del gems[color]
	print(len(gems))
	for val in gems.values():
		print(val)


n = int(input())
l = []
for i in range(n):
	l.append(input())
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
a = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
c = [0] * 6
print(6 - n)
for color in l:
	c[a.index(color)] += 1
for i in range(6):
	if c[i] == 0:
		print(d[a[i]])


my = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
my = {v: k for (k, v) in my.items()}
for _ in range(int(input())):
	my.pop(input())
print(len(my))
for i in my.values():
	print(i)


t = int(input())
lst = []
lst1 = []
l = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
l1 = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(t):
	str = input()
	lst.append(str)
for i in l:
	if i not in lst:
		lst1.append(i)
res = 6 - t
print(res)
for i in lst1:
	print(l1[i])


x = int(input())
y = 6 - x
presentStones = []
allStones = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
allStonesDict = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(x):
	inp = input()
	presentStones.append(inp)
print(y)
for stone in allStones:
	if not stone in presentStones:
		stoneType = allStonesDict[stone]
		print(stoneType)


a = int(input())
t = ['Time', 'Mind', 'Soul', 'Power', 'Reality', 'Space']
T = ['green', 'yellow', 'orange', 'purple', 'red', 'blue']
if a == 0:
	print(len(t))
	for j in t:
		print(j)
elif a == 6:
	print(0)
elif 0 < a < 6:
	s = []
	u = []
	for i in range(a):
		s.append(input())
	for j in range(6):
		if T[j] in s:
			pass
		elif T[j] not in s:
			u.append(t[j])
	print(len(u))
	u.sort()
	for k in u:
		print(k)


count = 0
n = int(input())
list1 = ['red', 'purple', 'yellow', 'orange', 'blue', 'green']
l = []
k = []
for i in range(n):
	l.append(input())
for i in range(6):
	if list1[i] not in l:
		count += 1
		k.append(list1[i])
print(count)
for i in range(len(k)):
	if k[i] == 'red':
		print('Reality')
	if k[i] == 'purple':
		print('Power')
	if k[i] == 'yellow':
		print('Mind')
	if k[i] == 'orange':
		print('Soul')
	if k[i] == 'green':
		print('Time')
	if k[i] == 'blue':
		print('Space')


a = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
b = []
n = int(input())
if n == 0:
	print(6)
	for i in range(len(a)):
		print(a[i])
else:
	for i in range(n):
		c = str(input())
		if c == 'purple':
			b.append('Power')
		elif c == 'green':
			b.append('Time')
		elif c == 'blue':
			b.append('Space')
		elif c == 'orange':
			b.append('Soul')
		elif c == 'red':
			b.append('Reality')
		elif c == 'yellow':
			b.append('Mind')
	if n == 6:
		print(0)
	else:
		print(len(a) - len(b))
		for i in range(len(a)):
			if not a[i] in b:
				print(a[i])


n = int(input())
color___stone = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
tanos_colors = [input() for _ in range(n)]
print(6 - n)
for color in color___stone:
	if color not in tanos_colors:
		print(color___stone[color])


gaunt = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
for i in range(n):
	n = input()
	gaunt.pop(n)
print(len(gaunt))
for i in gaunt.values():
	print(i)


n = int(input())
arr = []
for i in range(6):
	arr.append(0)
ar = []
for i in range(n):
	ar.append(input())
for i in ar:
	if i == 'purple':
		arr[0] = 1
	elif i == 'green':
		arr[1] = 1
	elif i == 'blue':
		arr[2] = 1
	elif i == 'orange':
		arr[3] = 1
	elif i == 'red':
		arr[4] = 1
	elif i == 'yellow':
		arr[5] = 1
ans = []
for i in range(6):
	if arr[i] == 0:
		if i == 0:
			ans.append('Power')
		elif i == 1:
			ans.append('Time')
		elif i == 2:
			ans.append('Space')
		elif i == 3:
			ans.append('Soul')
		elif i == 4:
			ans.append('Reality')
		elif i == 5:
			ans.append('Mind')
print(len(ans))
for i in ans:
	print(i)


d = {}
d['Power'] = 'purple'
d['Time'] = 'green'
d['Space'] = 'blue'
d['Soul'] = 'orange'
d['Reality'] = 'red'
d['Mind'] = 'yellow'
k = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
c = [0, 0, 0, 0, 0, 0]
m = 0
n = int(input())
for i in range(n):
	s = input()
	m = 0
	for ke in d.keys():
		if d[ke] == s:
			c[m] += 1
			break
		m += 1
print(c.count(0))
for i in range(len(c)):
	if c[i] == 0:
		print(k[i])


n = int(input())
gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
gems_in = []
for _ in range(n):
	gems_in.append(input())
print(6 - len(gems_in))
r = list(set(gems) - set(gems_in))
for gem in r:
	print(gems[gem])


stones = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
s = set()
t = int(input())
for i in range(t):
	inp = input()
	s.add(inp)
print(6 - t)
for (key, value) in stones.items():
	if key not in s:
		print(value)


gem = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
for x in range(n):
	gem.pop(input())
print(len(gem))
for x in gem:
	print(gem[x])


n = int(input())
gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(n):
	x = input()
	del gems[x]
print(6 - n)
if n != 6:
	for values in gems.values():
		print(values)


color = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
stone = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
n = int(input())
l = []
for i in range(n):
	a = input()
	l.append(a)
print(6 - n)
for i in range(6):
	if color[i] not in l:
		print(stone[i])


q = int(input())
color_dict = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
allowed_gems = {input() for _ in range(q)}
pre_result = set(color_dict.keys()) - allowed_gems
print(len(pre_result))
for value in pre_result:
	print(color_dict[value])


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
a = set(['purple', 'green', 'blue', 'orange', 'red', 'yellow'])
b = set()
n = int(input())
for i in range(n):
	b.add(input())
print(6 - n)
for j in a - b:
	print(d[j])


n = int(input())
gauntlet = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
stones = set(['purple', 'green', 'blue', 'orange', 'red', 'yellow'])
k = set()
for i in range(n):
	k.add(input())
need = 6 - n
print(need)
for x in stones - k:
	print(gauntlet[x])


n = int(input())
r = 0
p = 0
sp = 0
so = 0
m = 0
t = 0
d1 = 0
d2 = 0
d3 = 0
d4 = 0
d5 = 0
d6 = 0
a = []
for i in range(0, n):
	k = input()
	a.append(k)
	if a[i] == 'red':
		r += 1
	elif a[i] == 'purple':
		p += 1
	elif a[i] == 'green':
		t += 1
	elif a[i] == 'blue':
		sp += 1
	elif a[i] == 'orange':
		so += 1
	elif a[i] == 'yellow':
		m += 1
print(6 - n)
for i in range(6 - n):
	if r != 1 and d1 == 0:
		print('Reality')
		d1 += 1
	elif p != 1 and d2 == 0:
		print('Power')
		d2 += 1
	elif t != 1 and d3 == 0:
		print('Time')
		d3 += 1
	elif sp != 1 and d4 == 0:
		print('Space')
		d4 += 1
	elif so != 1 and d5 == 0:
		print('Soul')
		d5 += 1
	elif m != 1 and d6 == 0:
		print('Mind')
		d6 += 1


n = int(input())
m = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
contained = []
for i in range(n):
	name = input()
	contained.append(name)
missing = []
for (k, v) in m.items():
	if k not in contained:
		missing.append(v)
print(len(missing))
for mi in missing:
	print(mi)


d = int(input())
f = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Sould', 'red': 'Reality', 'yellow': 'Mind'}
g = []
coun = []
count = 0
for _ in range(d):
	e = str(input())
	g.append(e)
print(6 - len(g))
if 'purple' not in g:
	print('Power')
if 'green' not in g:
	print('Time')
if 'blue' not in g:
	print('Space')
if 'orange' not in g:
	print('Soul')
if 'red' not in g:
	print('Reality')
if 'yellow' not in g:
	print('Mind')


def NaytiChisla(stroka):
	kek = ''
	chislo = []
	koef = 1
	for i in range(len(stroka)):
		if stroka[i] == '-':
			koef = -1
		if stroka[i] == '0' or stroka[i] == '1' or stroka[i] == '2' or (stroka[i] == '3') or (stroka[i] == '4') or (stroka[i] == '5') or (stroka[i] == '6') or (stroka[i] == '7') or (stroka[i] == '8') or (stroka[i] == '9'):
			kek += stroka[i]
		if stroka[i] == ' ':
			chislo.append(int(kek) * koef)
			koef = 1
			kek = ''
	chislo.append(int(kek) * koef)
	koef = 1
	return chislo
n = int(input())
colors = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
stones = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
newColor = []
for i in range(n):
	newColor.append(str(input()))
for i in newColor:
	if i in colors:
		stones[colors.index(i)] = '1'
k = 0
for i in stones:
	if i != '1':
		k += 1
print(k)
for i in stones:
	if i != '1':
		print(i)


a = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
b = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
t = int(input())
n = 6
for i in range(t):
	y = input()
	for j in range(n):
		if y == a[j]:
			a.pop(j)
			b.pop(j)
			n -= 1
			break
print(n)
for i in range(n):
	print(b[i])


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
missing = set(d.values())
for _ in range(n):
	color = input()
	missing.remove(d[color])
print(len(missing))
for c in missing:
	print(c)


g = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'red': 'Reality', 'orange': 'Soul', 'yellow': 'Mind'}
n = int(input())
colors = ['purple', 'green', 'blue', 'red', 'orange', 'yellow']
for _ in range(n):
	c = input()
	colors.remove(c)
print(int(6 - n))
for i in colors:
	print(g[i])


n = int(input())
stones = [['Power', 'purple'], ['Time', 'green'], ['Space', 'blue'], ['Soul', 'orange'], ['Reality', 'red'], ['Mind', 'yellow']]
thanos = []
for i in range(n):
	thanos.append(str(input()))
for i in range(n):
	for j in range(len(stones)):
		if thanos[i] == stones[j][1]:
			stones[j][0] = 0
			break
print(6 - n)
for i in range(len(stones)):
	if stones[i][0] != 0:
		print(stones[i][0])


num = int(input())
allgems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(num):
	z = input()
	del allgems[z]
print(6 - num)
for y in allgems:
	print(allgems[y])


import sys
gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
absent_gems = list(gems.values())
n = int(sys.stdin.readline().strip())
for i in range(n):
	color = sys.stdin.readline().strip()
	absent_gems.remove(gems[color])
print(len(absent_gems))
for gem in absent_gems:
	print(gem)


stones = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
st = []
for i in range(n):
	st.append(str(input()))
print(6 - n)
for s in stones.keys():
	if s not in st:
		print(stones[s])


stones = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
for i in range(0, n):
	s = str(input())
	stones.pop(s)
print(len(stones.values()))
for i in stones.values():
	print(i)


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

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

def map_string():
	return input().split()
n = int(input())
d = {}
d['purple'] = 'Power'
d['green'] = 'Time'
d['blue'] = 'Space'
d['orange'] = 'Soul'
d['red'] = 'Reality'
d['yellow'] = 'Mind'
a = []
for i in range(n):
	a.append(input())
b = []
for i in d:
	if i not in a:
		b.append(d[i])
print(len(b))
for i in b:
	print(i)


s = int(input())
print(6 - s)
a = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for i in range(s):
	f = input()
	if 'purple' in f:
		a.remove('Power')
	if 'green' in f:
		a.remove('Time')
	if 'blue' in f:
		a.remove('Space')
	if 'orange' in f:
		a.remove('Soul')
	if 'red' in f:
		a.remove('Reality')
	if 'yellow' in f:
		a.remove('Mind')
print(*a, sep='\n')


d = {}
d['purple'] = 'Power'
d['green'] = 'Time'
d['blue'] = 'Space'
d['orange'] = 'Soul'
d['red'] = 'Reality'
d['yellow'] = 'Mind'
n = int(input())
lista = []
for i in d:
	lista.append(d[i])
for x in range(n):
	s = input()
	lista.remove(d[s])
print(len(lista))
for x in lista:
	print(x)


color = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
stone = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
n = int(input())
for i in range(n):
	st = input()
	num = color.index(st)
	color.pop(num)
	stone.pop(num)
print(len(stone))
for i in stone:
	print(i)


dc = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
st = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
m = n = int(input())
str = ''
while n:
	ss = input()
	str = str + ss + ' '
	n -= 1
print(6 - m)
for i in range(len(st)):
	if st[i] not in str:
		print(dc[st[i]])


a = []
b = int(input())
x = 0
while x < b:
	a.append(input())
	x += 1
c = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
d = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
print(6 - b)
for i in c:
	if i not in a:
		print(d[c.index(i)])


d = dict(zip('purple, green, blue, orange, red, yellow'.split(', '), 'Power, Time, Space, Soul, Reality, Mind'.split(', ')))
for _ in [0] * int(input()):
	d.pop(input())
print(len(d), *d.values(), sep='\n')


n = int(input())
lc = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
ls = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
l1 = []
la = []
ln = []
if n > 0:
	for i in range(n):
		r = input()
		l1.append(r)
	for i in range(n):
		for j in range(len(lc)):
			if l1[i] == lc[j]:
				lc.remove(lc[j])
				ls.remove(ls[j])
				break
	print(len(ls))
	for i in range(len(ls)):
		print(ls[i])
else:
	print(len(ls))
	for i in range(len(ls)):
		print(ls[i])


LEFT = {'Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind'}
n = int(input())
for i in range(n):
	s = input()
	if s == 'purple':
		LEFT.discard('Power')
	if s == 'green':
		LEFT.discard('Time')
	if s == 'blue':
		LEFT.discard('Space')
	if s == 'orange':
		LEFT.discard('Soul')
	if s == 'red':
		LEFT.discard('Reality')
	if s == 'yellow':
		LEFT.discard('Mind')
print(len(LEFT))
for i in LEFT:
	print(i)


n = int(input())
li1 = []
for i in range(n):
	inp = input()
	if inp == 'yellow':
		li1.append('Mind')
	if inp == 'red':
		li1.append('Reality')
	if inp == 'orange':
		li1.append('Soul')
	if inp == 'blue':
		li1.append('Space')
	if inp == 'green':
		li1.append('Time')
	if inp == 'purple':
		li1.append('Power')
s1 = set(li1)
li2 = list(s1)
lfw = ['Mind', 'Reality', 'Soul', 'Space', 'Time', 'Power']
a = 6 - len(li2)
print(a)
for j in lfw:
	if j not in li2:
		print(j)


from __future__ import print_function
import sys
import math
import os.path

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

def ni():
	return map(int, input().split(' '))

def nio(offset):
	return map(lambda x: int(x) + offset, input().split(' '))

def nia():
	return list(map(int, input().split()))
(n,) = ni()
a = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for _ in range(n):
	s = input()
	a.pop(s)
print(len(a))
for v in a.values():
	print(v)


a = ['purple', 'red', 'green', 'blue', 'yellow', 'orange']
b = []
for x in range(int(input())):
	y = input()
	b.append(y)
c = list(set(a) - set(b))
print(len(c))
for x in c:
	if x == 'purple':
		print('Power')
	elif x == 'red':
		print('Reality')
	elif x == 'green':
		print('Time')
	elif x == 'blue':
		print('Space')
	elif x == 'orange':
		print('Soul')
	else:
		print('Mind')


x = int(input())
g = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
c = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
n = 6 - x
z = []
for i in range(x):
	z.append(input())
if len(z) != 0:
	for i in range(len(z)):
		s = g[c.index(z[i])]
		c.remove(z[i])
		g.remove(s)
print(n)
if len(g) != 0:
	for i in range(n):
		print(g[i])


n = int(input())
l = []
for i in range(n):
	l.append(str(input()))
di = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'red': 'Reality', 'orange': 'Soul', 'yellow': 'Mind'}
for i in l:
	del di[i]
print(6 - n)
if n != 6:
	for i in di.keys():
		print(di[i])


colours = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
words = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
n = int(input())
indices = []
for i in range(n):
	indices.append(colours.index(input()))
print(6 - len(indices))
for i in range(0, 6):
	if i not in indices:
		print(words[i])


a = int(input())
c = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(a):
	b = input()
	c[b] = '+'
k = []
for i in c:
	if c[i] != '+':
		k.append(c[i])
print(len(k))
for i in k:
	print(i)


def main():
	n = int(input())
	colors = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
	gems = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
	a = {c: g for (c, g) in zip(colors, gems)}
	absent = set(colors)
	for _ in range(n):
		c = input()
		absent.remove(c)
	print(len(absent))
	for c in absent:
		print(a[c])
main()


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
m = int(input())
print(6 - m)
l = []
for _ in range(m):
	s = input()
	l.append(s)
for i in d.keys():
	if i not in l:
		print(d[i])


n = int(input())
compare = ['Power', 'Reality', 'Time', 'Space', 'Soul', 'Mind']
color = ['purple', 'red', 'green', 'blue', 'orange', 'yellow']
l = []
for i in range(n):
	l.append(input())
ans = []
t = 0
for i in color:
	if i not in l:
		ans.append(compare[t])
	t += 1
print(len(ans))
for i in ans:
	print(i)


gems = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
colors = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
total_colors = int(input())
for i in range(total_colors):
	gems[colors.index(input())] = ''
gems = [x for x in gems if x != '']
print(len(gems))
if len(gems) > 0:
	print('\n'.join(gems))


n = int(input())
gems = {'Mind': 'yellow', 'Power': 'purple', 'Time': 'green', 'Reality': 'red', 'Space': 'blue', 'Soul': 'orange'}
gems_available = []
for i in range(n):
	a = input()
	gems_available.append(a)
print(6 - n)
for x in gems:
	if gems[x] not in gems_available:
		print(x)


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
for i in range(n):
	d.pop(input())
print(6 - n)
for j in list(d.keys()):
	print(d.pop(j))


colors = {'purple', 'green', 'blue', 'orange', 'red', 'yellow'}
biection = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
for i in range(n):
	color = str(input())
	colors.remove(color)
print(len(colors))
for color in colors:
	print(biection[color])


s = (('Power', 'purple'), ('Time', 'green'), ('Space', 'blue'), ('Soul', 'orange'), ('Reality', 'red'), ('Mind', 'yellow'))
t = [input() for i in range(int(input()))]
v = [g for (g, c) in s if c not in t]
print(len(v), '\n'.join(v), sep='\n')


T = int(input())
dic = {'p': 'Power', 'g': 'Time', 'b': 'Space', 'o': 'Soul', 'r': 'Reality', 'y': 'Mind'}
lst = []
for i in range(T):
	s = input()
	lst.append(s[0])
print(len(dic) - T)
for i in dic.keys():
	if i not in lst:
		print(dic[i])


(n, res) = (int(input()), [])
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(n):
	res.append(input())
for i in d:
	if i not in res:
		res.append(d[i])
	else:
		res.remove(i)
print(6 - n)
for i in res:
	print(i)


a = 'purple green blue orange red yellow'.split()
b = 'Power Time Space Soul Reality Mind'.split()
c = zip(a, b)
n = int(input())
g = [input() for i in range(n)]
need = []
for color in c:
	if color[0] not in g:
		need.append(color[1])
print(len(need))
print('\n'.join(need))


n = int(input())
s = []
for _ in range(n):
	s1 = input().lower()
	s.append(s1)
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
d1 = list(d.keys())
for colors in s:
	if colors in d1:
		del d[colors]
print(len(d))
for i in d:
	print(d[i])


thanos = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
if n == 0:
	print(6)
	for key in thanos:
		print(thanos[key])
else:
	gems = [input() for i in range(n)]
	print(len(set(thanos).difference(set(gems))))
	for key in set(thanos).difference(set(gems)):
		print(thanos[key])


import logging
fmt = '%(levelname)s - %(name)s (line:%(lineno)s) - %(message)s'
formatter = logging.Formatter(fmt)
ch = logging.StreamHandler()
ch.setLevel(logging.ERROR)
ch.setFormatter(formatter)
logger = logging.getLogger('infinity_gauntlet')
logger.setLevel(logging.ERROR)
logger.addHandler(ch)

def solve(s):
	mapping = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
	for k in s:
		if k in mapping:
			del mapping[k]
	return list(mapping.values())

def main():
	n = int(input().strip())
	s = []
	for _ in range(n):
		s.append(input().strip())
	result = solve(s)
	print(len(result))
	print('\n'.join(result))
main()


inf = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
gems = []
for i in range(n):
	gems.append(input())
gems = set(gems)
gauntlet = set(['purple', 'green', 'blue', 'orange', 'yellow', 'red'])
missing = list(gauntlet - gems)
print(len(missing))
for (k, v) in inf.items():
	if k in missing:
		print(inf[k])


mp = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
have = {input() for _ in range(n)}
need = mp.keys() - have
print(len(need))
print(*(mp[x] for x in need), sep='\n')


n = int(input(''))
data = []
for i in range(0, n):
	data.append(input(''))
dict1 = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
print(6 - n)
for i in data:
	if i in list(dict1.keys()):
		del dict1[i]
for i in dict1.values():
	print(i)


colours = {'purple': [False, 'Power'], 'green': [False, 'Time'], 'blue': [False, 'Space'], 'orange': [False, 'Soul'], 'red': [False, 'Reality'], 'yellow': [False, 'Mind']}
n = int(input())
for a in range(n):
	colours[input()][0] = True
print(6 - n)
for b in ('purple', 'green', 'blue', 'orange', 'red', 'yellow'):
	if not colours[b][0]:
		print(colours[b][1])


color = ['p', 'g', 'b', 'o', 'r', 'y']
St = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
N = int(input())
status = [0] * 6
for i in range(N):
	a = input()
	for j in range(6):
		if a[0] == color[j]:
			status[j] = 1
			break
y = 6 - N
print(y)
for i in range(6):
	if status[i] == 0:
		print(St[i])


color = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
stone = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
n = int(input())
a = []
for i in range(n):
	a += [input()]
c = 0
res = []
for i in range(len(color)):
	if color[i] not in a:
		c += 1
		res += [stone[i]]
print(c)
for i in res:
	print(i)


from collections import defaultdict
d = defaultdict(str)
d['purple'] = 'Power'
d['green'] = 'Time'
d['blue'] = 'Space'
d['orange'] = 'Soul'
d['red'] = 'Reality'
d['yellow'] = 'Mind'
n = int(input())
l = []
for i in range(n):
	l.append(input())
print(6 - n)
if n == 0:
	for i in d.values():
		print(i)
elif n < 6:
	for i in d:
		if i not in l:
			print(d[i])


a = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
t = int(input())
for x in range(t):
	s = input()
	del a[s]
print(6 - t)
for x in a:
	print(a[x])


def arr_inp(n):
	return [input() for x in range(n)]
dic = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
n = int(input())
a = arr_inp(n)
print(6 - n)
for i in dic.keys():
	if dic[i] not in a:
		print(i)


n = int(input())
dic = {'purple': 0, 'green': 1, 'blue': 2, 'orange': 3, 'red': 4, 'yellow': 5}
listt = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
a = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
b = list(range(6))
for i in range(n):
	k = input()
	listt.remove(k)
print(len(listt))
for i in listt:
	print(a[dic[i]])


coun = int(input())
i = 0
arr = []
arrr = list(('purple', 'green', 'blue', 'orange', 'red', 'yellow'))
for i in range(coun):
	arr.append(input())
for a in arr:
	if a == 'purple':
		arrr.remove('purple')
	if a == 'green':
		arrr.remove('green')
	if a == 'blue':
		arrr.remove('blue')
	if a == 'orange':
		arrr.remove('orange')
	if a == 'red':
		arrr.remove('red')
	if a == 'yellow':
		arrr.remove('yellow')
print(6 - coun)
if 'purple' in arrr:
	print('Power')
if 'green' in arrr:
	print('Time')
if 'blue' in arrr:
	print('Space')
if 'orange' in arrr:
	print('Soul')
if 'red' in arrr:
	print('Reality')
if 'yellow' in arrr:
	print('Mind')


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(int(input())):
	x = str(input())
	if x in d:
		d.pop(x)
print(len(d))
for i in d:
	print(d[i])


n = int(input())
t = []
a = dict(red='Reality', yellow='Mind', orange='Soul', blue='Space', green='Time', purple='Power')
for i in range(0, n):
	x = input()
	a.pop(x)
print(len(a))
for t in a.values():
	print(t)


n = int(input())
di = ['red', 'purple', 'blue', 'green', 'yellow', 'orange']
d = {'red': [0, 'Reality'], 'purple': [0, 'Power'], 'blue': [0, 'Space'], 'green': [0, 'Time'], 'yellow': [0, 'Mind'], 'orange': [0, 'Soul']}
for i in range(n):
	s = input()
	d[s][0] = 1
ans = []
for i in range(6):
	if d[di[i]][0] == 0:
		ans.append(d[di[i]][1])
print(len(ans))
for i in range(len(ans)):
	print(ans[i])


def solve(gems):
	all_gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
	count = abs(len(all_gems) - len(gems))
	for i in gems:
		if i in all_gems:
			del all_gems[i]
	return {'gems': all_gems, 'count': count}
gems = []
n = int(input())
for case in range(0, n):
	gem = input()
	gems.append(gem)
solution = solve(gems)
print(solution.get('count'))
if len(solution.get('gems')) > 0:
	for (key, val) in solution.get('gems').items():
		if val is not '':
			print(val)


from sys import stdin, stdout, exit as sys_ret
(f_input, f_print, f_flush) = (stdin.readline, stdout.write, stdout.flush)
(amount, answer) = (int(f_input()), set())
infinity_glove = {'red\n': 'Reality\n', 'purple\n': 'Power\n', 'orange\n': 'Soul\n', 'yellow\n': 'Mind\n', 'blue\n': 'Space\n', 'green\n': 'Time\n'}
for i in range(amount):
	answer.add(f_input())
f_print(str(6 - amount) + '\n')
for (key, value) in infinity_glove.items():
	if key not in answer:
		f_print(value)


a = int(input())
b = []
x = []
y = []
for i in range(a):
	c = input()
	b.append(c)
d = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
for i in d:
	if i not in b:
		x.append(i)
for i in x:
	if i == 'purple':
		y.append('Power')
	elif i == 'green':
		y.append('Time')
	elif i == 'blue':
		y.append('Space')
	elif i == 'orange':
		y.append('Soul')
	elif i == 'red':
		y.append('Reality')
	else:
		y.append('Mind')
print(6 - a)
for i in y:
	print(i)


n = int(input())
colors = [input() for _ in range(n)]
dic = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
result = []
for i in dic.items():
	if not i[0] in colors:
		result.append(i[1])
print(len(result))
for i in result:
	print(i)


a = int(input())
b = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
c = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
e = []
for i in range(a):
	d = input()
	f = b.index(d)
	e.append(f)
e = sorted(e)
for i in e[::-1]:
	c.pop(int(i))
print(6 - a)
for i in c:
	print(i)


n = int(input())
g = [input() for _ in range(n)]
ga = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
print(6 - n)
for k in g:
	del ga[k]
for o in ga.values():
	print(o)


n = int(input())
col = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
l = 0
for i in range(n):
	m = input()
	col.pop(m)
	l += 1
print(6 - l)
for key in col.keys():
	print(col[key])


d = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
l = []
for _ in range(int(input())):
	c = input()
	l.append(c)
c = 0
ans = []
for (key, value) in d.items():
	if value not in l:
		c += 1
		ans.append(key)
print(c)
for i in ans:
	print(i)


stones = {'purple': ['Power', 0], 'green': ['Time', 0], 'blue': ['Space', 0], 'orange': ['Soul', 0], 'red': ['Reality', 0], 'yellow': ['Mind', 0]}
count = 0
n = int(input())
for _ in range(n):
	stones[input()][1] += 1
res = []
for x in stones:
	if stones[x][1] == 0:
		count += 1
		res.append(stones[x][0])
print(count)
for x in res:
	print(x)


n = int(input())
ans = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
ans1 = []
for i in range(n):
	a = input()
	ans1.append(a)
	del ans[ans.index(a)]
print(len(ans))
for i in range(len(ans)):
	if ans[i] == 'purple':
		print('Power')
	elif ans[i] == 'green':
		print('Time')
	elif ans[i] == 'blue':
		print('Space')
	elif ans[i] == 'orange':
		print('Soul')
	elif ans[i] == 'red':
		print('Reality')
	elif ans[i] == 'yellow':
		print('Mind')


gauntlet = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
ask = int(input())
gems = []
for i in range(ask):
	a = input()
	gems.append(a)
for items in gems:
	del gauntlet[items]
print(6 - ask, sep='\n')
print(*gauntlet.values(), sep='\n')


gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
color = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
n = int(input())
a = []
for i in range(n):
	a.append(input())
print(6 - n)
for i in a:
	color.remove(i)
for i in color:
	print(gems[i])


n = int(input())
b = [i for i in range(0, n)]
for j in range(0, n):
	b[j] = input()
c = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
k = c.keys()
r = 0
t = ['Reality', 'Power', 'Mind', 'Soul', 'Space', 'Time']
u = []
for k in range(0, n):
	u.append(c[b[k]])
print(6 - n)
for h in t:
	p = u.count(h)
	if p == 0:
		print(h)


from collections import *
import sys
import math
from functools import reduce

def factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))

def li():
	return [int(i) for i in input().rstrip('\n').split(' ')]

def st():
	return input().rstrip('\n')

def val():
	return int(input())

def stli():
	return [int(i) for i in input().rstrip('\n')]
l = [['purple', 'Power'], ['green', 'Time'], ['blue', 'Space'], ['orange', 'Soul'], ['red', 'Reality'], ['yellow', 'Mind']]
s = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
for i in range(val()):
	temp = st()
	if temp in s:
		s.remove(temp)
print(len(s))
for i in s:
	for j in l:
		if j[0] == i:
			print(j[1])
			break


n = int(input())
a = []
if n != 0:
	for k in range(n):
		a.append(input())
print(6 - n)
b = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
for k in b:
	if k not in a:
		if k == 'purple':
			print('Power')
		elif k == 'green':
			print('Time')
		elif k == 'blue':
			print('Space')
		elif k == 'orange':
			print('Soul')
		elif k == 'red':
			print('Reality')
		else:
			print('Mind')


n = int(input())
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
p = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
for i in range(n):
	q = input()
	if q in p:
		p.remove(q)
print(len(p))
for i in p:
	print(d[i])


gauntlet = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input().strip())
print(6 - n)
colors = []
for _ in range(n):
	colors.append(input().strip())
gems = []
for k in gauntlet:
	if k not in colors:
		gems.append(gauntlet[k])
for gem in gems:
	print(gem)


n = int(input())
s = set()
m = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
l = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
for i in range(n):
	ch = input()
	s.add(ch)
l1 = []
for i in l:
	if i not in s:
		l1.append(i)
print(len(l1))
for i in l1:
	print(m[i])


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
print(6 - n)
for i in range(n):
	b = input()
	del d[b]
for (key, value) in d.items():
	print(value)


n = int(input())
c = 6
a = [['purple', 'Power', 0], ['green', 'Time', 0], ['blue', 'Space', 0], ['orange', 'Soul', 0], ['red', 'Reality', 0], ['yellow', 'Mind', 0]]
for i in range(n):
	s = input()
	for j in range(6):
		if a[j][0] == s:
			a[j][2] = 1
			c -= 1
print(c)
for j in range(6):
	if a[j][2] == 0:
		print(a[j][1])


n = int(input())
colors = [input() for _ in range(n)]
stones = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in colors:
	del stones[i]
print(len(stones))
for i in stones:
	print(stones[i])


x = int(input())
l = []
for i in range(x):
	s = input()
	l.append(s)
l = set(l)
q = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
r = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
print(6 - len(l))
for j in range(6):
	if not q[j] in l:
		print(r[j])


n = int(input())
dic = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
m = [dic[input()] for _ in range(n)]
al = [i for i in dic]
al = [dic[i] for i in al]
sol = []
for i in al:
	if i not in m:
		sol.append(i)
print(len(sol))
print('\n'.join(map(str, sol)))


a = ('Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind')
b = ('purple', 'green', 'blue', 'orange', 'red', 'yellow')
d = {b[i]: a[i] for i in range(6)}
n = int(input())
for i in range(n):
	s = input()
	del d[s]
print(len(d))
if len(d):
	print(*d.values(), sep='\n')


class infinityGauntlet:

	def __init__(self, n):
		self.n = n
		self.calculateGems(self.n)

	def calculateGems(self, n):
		missingGems = 6 - n
		dict1 = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
		list1 = []
		list2 = []
		list3 = []
		for x in range(0, n):
			str1 = input()
			list1.append(str1)
		for (key, value) in dict1.items():
			list2.append(key)
		for x in list2:
			if x in list2:
				if x not in list1:
					list3.append(x)
		print(missingGems)
		for x in range(0, len(list3)):
			print(dict1[list3[x]])
n = int(input())
infinityGauntletObj = infinityGauntlet(n)


mp = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
L = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for _ in range(n):
	co = input().strip()
	L.remove(mp[co])
print(len(L))
for x in L:
	print(x)


n = int(input())
l1 = [1, 2, 3, 4, 5, 6]
for i in range(n):
	a = str(input())
	if a == 'purple':
		l1.remove(1)
	if a == 'green':
		l1.remove(2)
	if a == 'blue':
		l1.remove(3)
	if a == 'orange':
		l1.remove(4)
	if a == 'red':
		l1.remove(5)
	if a == 'yellow':
		l1.remove(6)
print(6 - n)
for i in range(6 - n):
	if l1[i] == 1:
		print('Power')
	if l1[i] == 2:
		print('Time')
	if l1[i] == 3:
		print('Space')
	if l1[i] == 4:
		print('Soul')
	if l1[i] == 5:
		print('Reality')
	if l1[i] == 6:
		print('Mind')


def find(a):
	global A
	global B
	for i in range(len(A)):
		if A[i] == a:
			A = A[:i] + A[i + 1:]
			B = B[:i] + B[i + 1:]
			return 1
	return 0
n = int(input())
B = ['Time', 'Mind', 'Soul', 'Power', 'Reality', 'Space']
A = ['green', 'yellow', 'orange', 'purple', 'red', 'blue']
for i in range(n):
	a = input()
	find(a)
print(len(B))
for i in range(len(B)):
	print(B[i])


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
len_d = len(d)
num = input()
stones = []
for i in range(int(num)):
	stones.append(input())
print(len_d - int(num))
miss_stones = set(d.keys() - stones)
for stone in miss_stones:
	print(d[stone])


infinity = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
alist = []
n = int(input())
for i in range(n):
	y = str(input())
	alist.append(y)
print(6 - n)
for (row, col) in infinity.items():
	if row not in alist:
		print(col)


n = int(input())
count = 0
Dic = {'purple': ['Power', 0], 'green': ['Time', 0], 'blue': ['Space', 0], 'orange': ['Soul', 0], 'red': ['Reality', 0], 'yellow': ['Mind', 0]}
for i in range(0, n):
	k = str(input())
	Dic[k][1] = 1
for values in Dic.values():
	if values[1] == 0:
		count += 1
print(str(count))
for ks in Dic.keys():
	if Dic[ks][1] == 0:
		print(Dic[ks][0])


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
l = []
for j in range(n):
	l.append(input())
ans = []
for j in d:
	if j not in l:
		ans.append(d[j])
print(6 - n)
for j in ans:
	print(j)


n = int(input())
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
a = []
for i in range(n):
	s = input()
	a.append(s)
count = 0
b = []
for i in d:
	if i not in a:
		count += 1
		b.append(d[i])
print(count)
for i in b:
	print(i)


n = int(input())
l = [input()[0] for x in range(n)]
di = {'p': 'Power', 'g': 'Time', 'b': 'Space', 'o': 'Soul', 'r': 'Reality', 'y': 'Mind'}
l1 = ['p', 'g', 'b', 'o', 'r', 'y']
res = []
for i in l1:
	if i not in l:
		res.append(di[i])
print(len(res))
print(*res, sep='\n')


def main():
	gauntlet = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
	n = int(input())
	for i in range(n):
		gem = str(input())
		del gauntlet[gem]
	print(6 - n)
	for key in gauntlet:
		print(gauntlet[key])
main()


n = int(input())
c = [input() for _ in range(n)]
colors = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
for ci in c:
	colors.remove(ci)
print(6 - n)
for color in colors:
	if color == 'purple':
		print('Power')
	elif color == 'green':
		print('Time')
	elif color == 'blue':
		print('Space')
	elif color == 'orange':
		print('Soul')
	elif color == 'red':
		print('Reality')
	elif color == 'yellow':
		print('Mind')


l = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
for i in range(n):
	s = input()
	l.pop(s)
print(len(l))
for j in l:
	print(l[j])


gemColor = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
gemName = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
gemStatus = [0, 0, 0, 0, 0, 0]
n = int(input())
gemLeft = []
for i in range(n):
	a = input()
	for i in range(6):
		if a == gemColor[i]:
			gemStatus[i] = 1
for i in range(6):
	if gemStatus[i] == 0:
		gemLeft.append(gemName[i])
print(len(gemLeft))
for i in range(len(gemLeft)):
	print(gemLeft[i])


n = int(input())
res = [0, 0, 0, 0, 0, 0]
for i in range(n):
	cmd = input()
	if cmd == 'purple':
		res[0] = 1
	if cmd == 'green':
		res[1] = 1
	if cmd == 'blue':
		res[2] = 1
	if cmd == 'orange':
		res[3] = 1
	if cmd == 'red':
		res[4] = 1
	if cmd == 'yellow':
		res[5] = 1
print(6 - n)
if res[0] == 0:
	print('Power')
if res[1] == 0:
	print('Time')
if res[2] == 0:
	print('Space')
if res[3] == 0:
	print('Soul')
if res[4] == 0:
	print('Reality')
if res[5] == 0:
	print('Mind')


a = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
b = set()
for _ in range(int(input())):
	b.add(input())
c = set(a).difference(b)
print(len(c))
dic = []
for i in c:
	if i == a[0]:
		dic.append('Power')
	elif i == a[1]:
		dic.append('Time')
	elif i == a[2]:
		dic.append('Space')
	elif i == a[3]:
		dic.append('Soul')
	elif i == a[4]:
		dic.append('Reality')
	elif i == a[5]:
		dic.append('Mind')
print('\n'.join(dic), end='')


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
visited = {}
for i in d.keys():
	visited[i] = False
n = int(input())
for i in range(n):
	visited[input()] = True
cnt = 0
for i in d.keys():
	if visited[i] == False:
		cnt += 1
print(cnt)
for i in d.keys():
	if visited[i] == False:
		print(d[i])


q = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
t = int(input())
m = []
for i in range(t):
	m.append(input())
w = list(q.keys())
print(len(list(set(w) - set(m))))
for i in list(set(w) - set(m)):
	print(q[i])


gaunts = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
x = int(input())
my_gauntlets = []
for i in range(x):
	gaunt = input()
	my_gauntlets.append(gaunt)
answers = []
count = 0
for gg in gaunts.keys():
	if gg not in my_gauntlets:
		count = count + 1
		answers.append(gaunts[gg])
print(count)
for i in answers:
	print(i)


d = {'red': 'Reality', 'blue': 'Space', 'green': 'Time', 'purple': 'Power', 'orange': 'Soul', 'yellow': 'Mind'}
a = []
ans = []
for i in range(int(input())):
	a.append(input())
for i in d:
	if i not in a:
		ans.append(d[i])
if ans:
	print(len(ans))
	for i in ans:
		print(i)
else:
	print(0)


colors = []
n = int(input())
dictionary = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(n):
	colors.append(input())
	dictionary[colors[i]] = '1'
print(6 - n)
for color in dictionary:
	if dictionary[color] is not '1':
		print(dictionary[color])


n = int(input())
num = []
ans2 = []
for i in range(n):
	s = input()
	num.append(s)
ans = 0
if 'purple' not in num:
	ans += 1
	ans2.append('Power')
if 'orange' not in num:
	ans += 1
	ans2.append('Soul')
if 'red' not in num:
	ans += 1
	ans2.append('Reality')
if 'yellow' not in num:
	ans += 1
	ans2.append('Mind')
if 'blue' not in num:
	ans += 1
	ans2.append('Space')
if 'green' not in num:
	ans += 1
	ans2.append('Time')
print(ans)
for i in range(ans):
	print(ans2[i])


colors = ['Time', 'Space', 'Power', 'Reality', 'Mind', 'Soul']
my = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
for _ in range(n):
	color = input()
	colors.remove(my[color])
print(6 - n)
for color in colors:
	print(color)


n = int(input())
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
k = {'purple': 0, 'green': 0, 'blue': 0, 'orange': 0, 'red': 0, 'yellow': 0}
print(6 - n)
for i in range(n):
	s = input()
	k[s] = 1
for key in k:
	if k[key] == 0:
		print(d[key])


names = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
known = []
for i in range(n):
	known.append(input())
print(6 - n)
missing = [names[x] for x in names if x not in known]
print('\n'.join(missing))


import sys
l = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
m = []
n = 0
cont = 0
for line in sys.stdin:
	if cont:
		m.append(line.strip())
	else:
		n = int(line.strip())
	cont += 1
print(len(l.keys()) - n)
for k in l.keys():
	if k not in m:
		print(l[k])


l = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
a = [0] * 6
n = int(input())
for i in range(n):
	a[i] = input()
j = 0
for i in l:
	if i not in a:
		a[n + j] = l[i]
		j += 1
print(6 - n)
for i in range(n, 6):
	print(a[i])


name = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
color = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
n = int(input())
d = []
for i in range(0, n):
	temp = input()
	d.append(color.index(temp))
print(6 - len(d))
for i in range(0, len(name)):
	if d.count(i) == 0:
		print(name[i])


a = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
b = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
result = []
for i in range(int(input())):
	c = input()
	if c in a:
		result.append(b[a.index(c)])
b = set(b) - set(result)
b = list(b)
if len(b) > 0:
	print(len(b))
	for i in range(len(b)):
		print(b[i], sep='\n')
else:
	print(len(b))


num = int(input())
availableStones = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
stones = []
for i in range(num):
	stones.append(input())
print(6 - num)
for (key, value) in availableStones.items():
	if value not in stones:
		print(key)


n = int(input())
my_dic = dict((('purple', 'Power'), ('green', 'Time'), ('blue', 'Space'), ('orange', 'Soul'), ('red', 'Reality'), ('yellow', 'Mind')))
a = list()
for i in range(n):
	s = input()
	a.append(s)
res = set()
for i in range(n):
	flag = False
	for item in my_dic:
		if item == a[i]:
			flag = True
			break
	if flag:
		res.add(a[i])
all_set = set((x for x in my_dic))
res = all_set - res
print(len(res))
for item in res:
	print(my_dic[item])


dictionary = {'red': 'Reality', 'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'yellow': 'Mind'}
registro = {'red': 0, 'purple': 0, 'green': 0, 'blue': 0, 'orange': 0, 'yellow': 0}
numgems = int(input())
i = 1
count = 0
answer = []
while i <= numgems:
	present = str(input())
	registro[present] = 1
	i = i + 1
for element in registro:
	if registro[element] == 0:
		count = count + 1
		answer.append(dictionary[element])
print(count)
for elemento in answer:
	print(elemento)


N = int(input())
A = [input() for _ in range(N)]
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
print(6 - N)
print('\n'.join([v for (k, v) in d.items() if k not in A]))


allDict = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
inputList = []
m = int(input())
output = []
for i in range(0, m):
	s = input()
	inputList.append(s)
for k in allDict.keys():
	if not inputList.__contains__(k):
		output.append(allDict[k])
print(output.__len__())
print('\n'.join(output))


data = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
print(6 - n)
inp = [input() for i in range(n)]
for i in data:
	if i not in inp:
		print(data[i])


n = int(input())
colors = [False] * 6
for i in range(n):
	color = input()
	if color == 'purple':
		colors[0] = True
	elif color == 'green':
		colors[1] = True
	elif color == 'blue':
		colors[2] = True
	elif color == 'orange':
		colors[3] = True
	elif color == 'red':
		colors[4] = True
	else:
		colors[5] = True
print(6 - n)
if colors[0] != True:
	print('Power')
if colors[1] != True:
	print('Time')
if colors[2] != True:
	print('Space')
if colors[3] != True:
	print('Soul')
if colors[4] != True:
	print('Reality')
if colors[5] != True:
	print('Mind')


n = int(input())
a = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
l = []
m = []
count = 0
for i in range(n):
	l.append(input())
for i in a:
	if i not in l:
		m.append(i)
print(len(m))
if n > 0:
	for i in m:
		print(a[i])
else:
	for i in a:
		print(a[i])


complete_gems = {'purple', 'green', 'blue', 'orange', 'red', 'yellow'}
colors_to_power = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
gems = int(input())
present_gems = set()
for _ in range(gems):
	present_gems.add(input())
absent_gems = complete_gems - present_gems
total_absent_gems = len(absent_gems)
print(total_absent_gems)
for absent_gem in absent_gems:
	print(colors_to_power[absent_gem])


d = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
n = int(input())
b = []
ans = []
for _ in range(n):
	x = input()
	b.append(x)
for (key, value) in d.items():
	if value not in b:
		ans.append(key)
print(len(ans), *ans, sep='\n')


n = int(input())
x = []
y = ['purple', 'Power', 'green', 'Time', 'blue', 'Space', 'orange', 'Soul', 'red', 'Reality', 'yellow', 'Mind']
while n:
	n = n - 1
	x.append(input())
print(abs(len(x) - len(y) // 2))
for i in range(0, len(y) - 1, 2):
	if x.count(y[i]) < 1:
		print(y[i + 1])


from typing import Dict
DATA: Dict[str, str] = dict(purple='Power', green='Time', blue='Space', orange='Soul', red='Reality', yellow='Mind')
for _ in [0] * int(input()):
	DATA.pop(input())
print(len(DATA), *DATA.values(), sep='\n')


from sys import *
from math import *
from bisect import *
t = int(stdin.readline())
m = []
for _ in range(t):
	a = input()
	m.append(a)
print(6 - t)
a = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
b = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for i in range(6):
	if a[i] not in m:
		print(b[i])


import time

def identifyAbsentGems(gemsList):
	absentList = []
	cat = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
	for x in gemsList:
		if x in cat:
			del cat[x]
	return cat

def solve():
	gems = int(input())
	gemsList = []
	for x in range(gems):
		gemsList.append(input())
	absent = identifyAbsentGems(gemsList)
	print(len(absent))
	for (y, val) in absent.items():
		print(val)
solve()


n = int(input())
l1 = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
l2 = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
l3 = []
for i in range(n):
	l3.append(str(input()))
if n < 6:
	print(6 - n)
else:
	print(0)
for i in range(6):
	if l2[i] not in l3:
		print(l1[i])


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
a = set(d.keys())
for _ in range(n):
	a.remove(input())
print(len(a))
print(*map(d.get, a), sep='\n')


stone = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
colour = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
tmp = []
n = int(input())
for i in range(n):
	s = str(input())
	tmp.append(s)
print(6 - n)
tmp = list(set(tmp) ^ set(colour))
for i in range(len(tmp)):
	print(stone[colour.index(tmp[i])])


n = int(input())
d = {'red': 'Reality', 'purple': 'Power', 'yellow': 'Mind', 'orange': 'Soul', 'green': 'Time', 'blue': 'Space'}
for i in range(n):
	d.pop(input().strip())
print(6 - n)
for e in d:
	print(d[e])


stones = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for _ in range(int(input())):
	stone = input()
	if stone in stones:
		stones.pop(stone)
print(len(stones))
for stone in stones:
	print(stones[stone])


gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
stones = {'purple', 'green', 'blue', 'orange', 'red', 'yellow'}
colors = set()
for i in range(int(input())):
	colors.add(input())
print(len(stones.difference(colors)))
for i in stones.difference(colors):
	print(gems[i])


n = int(input())
s = [input() for i in range(n)]
memo = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
set_ = set([])
for i in range(n):
	set_.add(s[i])
print(6 - n)
for i in memo:
	if not i in set_:
		print(memo[i])


def main():
	gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
	n_gems = int(input())
	gems_obtained = [input() for _ in range(n_gems)]
	gems_missing = [gems[x] for x in gems.keys() if x not in gems_obtained]
	print(len(gems_missing))
	print('\n'.join(gems_missing))
main()


n = int(input())
c = 0
l = []
while c < n:
	b = input()
	b = b.lower()
	l.append(b)
	c += 1
g = 0
j = []
v = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
p = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for i in range(len(v)):
	if not v[i] in l:
		g += 1
		j.append(p[i])
print(g)
for i in j:
	print(i)


gems = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
color = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
n = int(input())
l = []
for _ in range(n):
	l.append(input())
print(6 - n)
for i in color:
	if i not in l:
		print(gems[color.index(i)])


n = int(input())
colors = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
wds = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for i in range(0, n):
	nd = colors.index(input())
	del colors[nd]
	del wds[nd]
print(len(wds))
print('\n'.join(wds))


a = int(input())
i = 0
lst = []
lst1 = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
lst2 = []
lst3 = []
for i in range(a):
	n = input()
	lst.append(n)
for t in lst1:
	if t not in lst:
		lst2.append(t)
for j in lst2:
	if j == 'purple':
		lst3.append('Power')
	elif j == 'green':
		lst3.append('Time')
	elif j == 'blue':
		lst3.append('Space')
	elif j == 'orange':
		lst3.append('Soul')
	elif j == 'red':
		lst3.append('Reality')
	elif j == 'yellow':
		lst3.append('Mind')
r = len(lst3)
print(r)
for u in lst3:
	print(u)


n = int(input())
full = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(0, n):
	full.pop(input())
print(6 - n)
for x in full.values():
	print(x)


n = int(input())
p = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
c = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
for t in range(n):
	color = input()
	p.pop(c.index(color))
	c.remove(color)
print(6 - n)
for i in p:
	print(i)


n = int(input())
S = {'Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind'}
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(n):
	s = str(input())
	S.remove(d[s])
print(len(S))
print(*S, sep='\n')


gauntlet = []
for _ in range(int(input())):
	gauntlet.append(input())
stones = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
colors = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
print(len(colors) - len(gauntlet))
for i in range(len(stones)):
	if colors[i] not in gauntlet:
		print(stones[i])


color = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
l = []
p = []
n = int(input())
for i in range(n):
	c = input()
	l.append(c)
for i in color:
	if i in l:
		continue
	else:
		p.append(i)
print(6 - n)
for i in range(len(p)):
	if p[i] is 'purple':
		print('Power')
	elif p[i] is 'green':
		print('Time')
	elif p[i] is 'blue':
		print('Space')
	elif p[i] is 'orange':
		print('Soul')
	elif p[i] is 'red':
		print('Reality')
	elif p[i] is 'yellow':
		print('Mind')


a = {'p': 'Power', 'g': 'Time', 'b': 'Space', 'o': 'Soul', 'r': 'Reality', 'y': 'Mind'}
n = int(input())
for i in range(n):
	s = input()
	if s[0] in a.keys():
		a.pop(s[0])
print(len(a))
for i in a:
	print(a[i])


s = set()
s.add('purple')
s.add('red')
s.add('green')
s.add('blue')
s.add('yellow')
s.add('orange')
ht = {'purple': 'Power', 'red': 'Reality', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'yellow': 'Mind'}
t = int(input())
b = set()
for i in range(t):
	a = input()
	b.add(a)
print(6 - t)
c = s - b
for i in c:
	print(ht[i])


D = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
S = set()
for _ in range(n):
	S.add(input())
print(6 - len(S))
for k in D:
	if not k in S:
		print(D[k])


name = []
dic = {'purple': 'Power', 'blue': 'Space', 'orange': 'Soul', 'yellow': 'Mind', 'green': 'Time', 'red': 'Reality'}
dic1 = {'purple': 0, 'blue': 0, 'orange': 0, 'yellow': 0, 'green': 0, 'red': 0}
numb = input()
a = int(numb)
if a == 0:
	print(6 - a)
	for i in dic:
		print(dic[i])
else:
	for i in range(a):
		data = input()
		name.append(data)
	for i in name:
		dic1[i] = 1
	print(6 - a)
	for i in dic:
		if dic1[i] == 0:
			print(dic[i])


dct = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
ks = set(dct.keys())
for _ in range(n):
	ks.remove(input())
print(len(ks))
for k in ks:
	print(dct[k])


n = int(input())
print(6 - n)
D = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
L = []
for i in range(n):
	L += [input()]
for i in D.keys():
	if i not in L:
		print(D[i])


n = int(input())
l = []
for i in range(n):
	l.append(input())
c = 0
l1 = [('Power', 'purple'), ('Time', 'green'), ('Space', 'blue'), ('Soul', 'orange'), ('Reality', 'red'), ('Mind', 'yellow')]
l2 = []
l3 = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for i in range(len(l)):
	for j in range(len(l1)):
		if l1[j][1] == l[i]:
			c += 1
			l2.append(l1[j][0])
print(6 - c)
for i in l3:
	if i not in l2:
		print(i)


d = {'red': 'Reality', 'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'yellow': 'Mind'}
n = int(input())
l = []
for _ in range(n):
	l.append(input())
print(6 - n)
for a in d.keys():
	if a not in l:
		print(d[a])


n = int(input())
colors = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
for i in range(n):
	color = input()
	colors.remove(color)
print(6 - n)
for lk in colors:
	if lk == 'purple':
		print('Power')
	if lk == 'green':
		print('Time')
	if lk == 'blue':
		print('Space')
	if lk == 'orange':
		print('Soul')
	if lk == 'red':
		print('Reality')
	if lk == 'yellow':
		print('Mind')


n = int(input())
stones = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
colors = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
flags = [0, 0, 0, 0, 0, 0]
for i in range(n):
	s = input()
	if s in colors:
		flags[colors.index(s)] = 1
print(6 - n)
for i in range(6):
	if flags[i] == 0:
		print(stones[i])


dic = {'purple': 'Power', 'red': 'Reality', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'yellow': 'Mind'}
n = int(input())
s = set()
while n != 0:
	str = input()
	s.add(str)
	n -= 1
if 6 - len(s) != 0:
	print(6 - len(s))
	for i in dic:
		if i not in s:
			print(dic[i])
else:
	print(0)


gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
for i in range(n):
	color = input()
	del gems[color]
print('%d' % len(gems))
for (key, value) in gems.items():
	print(value)


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
N = int(input())
for _ in range(N):
	ip = input()
	del d[ip]
print(len(d))
for x in d.items():
	print(x[1])


import sys
colors = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
stones = [val for val in colors.values()]
n = int(input())
for i in range(n):
	line = sys.stdin.readline().rstrip()
	stones.remove(colors[line])
print(6 - n)
for st in stones:
	print(st)


def Thanos():
	powers = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
	n = int(input())
	for i in range(n):
		powers.pop(input())
	print(len(powers))
	for (key, val) in powers.items():
		print(val)
Thanos()


n = int(input())
a = []
st = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
c = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
a.append(6 - n)
for i in range(n):
	r = str(input())
	del st[c.index(r)]
	c.remove(r)
for j in st:
	a.append(j)
for k in a:
	print(k)


n = int(input())
a = set()
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
l = set(['purple', 'green', 'blue', 'orange', 'red', 'yellow'])
for i in range(n):
	s = input()
	a.add(s)
new = list(l - a)
print(6 - n)
for i in new:
	print(d.get(i))


import sys
input = sys.stdin.readline
L = lambda : list(map(int, input().split()))
M = lambda : map(int, input().split())
n = int(input())
d = {}
d['purple'] = 'Power'
d['green'] = 'Time'
d['blue'] = 'Space'
d['orange'] = 'Soul'
d['red'] = 'Reality'
d['yellow'] = 'Mind'
l = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for i in range(n):
	l.remove(d[input().strip()])
print(len(l))
print(*l, sep='\n')


n = int(input())
a = []
x = []
kamni = dict()
kamni['purple'] = 'Power'
kamni['green'] = 'Time'
kamni['blue'] = 'Space'
kamni['orange'] = 'Soul'
kamni['red'] = 'Reality'
kamni['yellow'] = 'Mind'
for i in range(n):
	c = input()
	a.append(c)
for z in kamni:
	if z not in a:
		x.append(z)
print(6 - n)
for i in range(6 - n):
	print(kamni[x[i]])


def search(name):
	y = 0
	for i in range(len(b)):
		if name == b[i]:
			y = 1
	return y
n = int(input())
a = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
b = []
for i in range(n):
	tmp = input()
	if tmp == 'red':
		tmp2 = 'Reality'
	elif tmp == 'green':
		tmp2 = 'Time'
	elif tmp == 'purple':
		tmp2 = 'Power'
	elif tmp == 'blue':
		tmp2 = 'Space'
	elif tmp == 'orange':
		tmp2 = 'Soul'
	elif tmp == 'yellow':
		tmp2 = 'Mind'
	b.append(tmp2)
print(6 - len(b))
for i in range(len(a)):
	q = search(a[i])
	if q == 0:
		print(a[i])


def InfinityGauntlet(t, inp):
	count = 0
	ans = []
	gems = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
	colors = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
	gauntlet = dict(zip(colors, gems))
	for (k, v) in gauntlet.items():
		if k not in inp:
			count += 1
			ans.append(v)
	print(count)
	print('\n'.join(ans))
t = int(input())
inp = []
for _ in range(t):
	inp.append(input())
InfinityGauntlet(t, inp)


n = int(input())
database = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
arrIn = []
arrOut = []
for x in range(n):
	value = input()
	arrIn.append(value)
for x in database.keys():
	if x not in arrIn:
		arrOut.append(database[x])
print(len(arrOut))
for x in arrOut:
	print(x)
print


n = int(input())
s = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
p = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
list = []
for i in range(n):
	list.append(input())
print(6 - n)
for i in range(0, 6):
	if s[i] in list:
		pass
	else:
		print(p[i])


m = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(int(input().strip())):
	m.pop(input().strip())
print(len(m))
for i in m.values():
	print(i)


m = int(input())
colors = {'red': False, 'purple': False, 'green': False, 'blue': False, 'orange': False, 'yellow': False}
gems = {'red': 'Reality', 'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'yellow': 'Mind'}
for i in range(m):
	colors[input()] = True
print(6 - m)
for key in gems.keys():
	if colors[key] == True:
		continue
	print(gems[key])


n = int(input())
stones = []
while n:
	stones.append(input())
	n -= 1
total_stones = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
missing_stones = [total_stones[i] for i in total_stones.keys() if i not in stones]
print(len(missing_stones))
print('\n'.join(missing_stones))


stones = {'purple': 'Power ', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
L = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
n = int(input())
l = []
for i in range(n):
	l.append(input())
for x in L[::-1]:
	if x in l:
		L.remove(x)
for x in L:
	if x in l:
		L.remove(x)
print(len(L))
for s in L:
	print(stones[s])


n = int(input())
m = 6 - n
s = set(['purple', 'green', 'blue', 'orange', 'red', 'yellow'])
for _ in range(n):
	st = input()
	s.remove(st)
s = list(s)
print(m)
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for j in s:
	print(d[j])


color = []
answer = []
lst1 = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
lst2 = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
n = int(input())
for _ in range(n):
	color.append(input().strip())
print(abs(6 - n))
for i in lst2:
	if i in color:
		index = lst2.index(i)
		answer.append(lst1[index])
for i in answer:
	if i in answer:
		lst1.remove(i)
print(*lst1, sep='\n')


d = {'purple': True, 'green': True, 'blue': True, 'orange': True, 'red': True, 'yellow': True}
f = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(int(input())):
	a = input()
	d[a] = False
print(sum(d.values()))
for i in d:
	if d[i]:
		print(f[i])


n = int(input())
ls = []
for i in range(n):
	ls.append(input())
allstones = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
stones = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in ls:
	allstones.remove(i)
print(len(allstones))
for j in allstones:
	print(stones[j])


w = int(input())
(a, z) = ([], [])
b = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
c = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
for i in range(0, w):
	p = input()
	a.append(p)
for i in range(0, w):
	d = c.index(a[i])
	z.append(d)
for ele in sorted(z, reverse=True):
	del b[ele]
print(len(b))
print(*b, sep='\n')


ref = {'red': 'Reality', 'green': 'Time', 'blue': 'Space', 'purple': 'Power', 'yellow': 'Mind', 'orange': 'Soul'}
n = int(input())
L = []
for i in range(n):
	L.append(input())
print(6 - n)
for j in ref:
	if j not in L:
		print(ref[j])


n = int(input())
cobble = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
color = []
k = 0
for i in range(6):
	color.append(int(0))
for i in range(n):
	s = str(input())
	if s == 'purple':
		color[0] = 1
		k += 1
	elif s == 'green':
		color[1] = 1
		k += 1
	elif s == 'blue':
		color[2] = 1
		k += 1
	elif s == 'orange':
		color[3] = 1
		k += 1
	elif s == 'red':
		color[4] = 1
		k += 1
	elif s == 'yellow':
		color[5] = 1
		k += 1
print(6 - k)
for i in range(6):
	if color[i] == 0:
		print(cobble[i])


mask = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
tanos = {}
for i in range(0, n):
	c = input()
	tanos[c] = mask[c]
l = [mask[x] for x in set(mask).difference(set(tanos))]
print(len(l))
print('\n'.join(l))


i = int(input())
dict = {'purple': 'Power', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind', 'green': 'Time'}
dict_inp = {'purple': True, 'blue': True, 'orange': True, 'red': True, 'yellow': True, 'green': True}
for x in range(i):
	inn = input()
	dict_inp[inn] = False
out = 0
for keys in dict_inp:
	if dict_inp[keys] == True:
		out += 1
print(out)
for keys in dict_inp:
	if dict_inp[keys] == True:
		print(dict[keys])


n = int(input())
S = []
for i in range(0, n):
	r = input()
	S.append(r)
m = 6
h = m - n
print(h)
if h != 0:
	U = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
	U1 = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
	for i in range(0, len(U)):
		if U[i] not in S:
			print(U1[i])


n = int(input())
(a, ans) = ([], [])
cnt = 0
for i in range(n):
	a.append(input())
if 'purple' not in a:
	ans.append('Power')
	cnt += 1
if 'green' not in a:
	ans.append('Time')
	cnt += 1
if 'blue' not in a:
	ans.append('Space')
	cnt += 1
if 'orange' not in a:
	ans.append('Soul')
	cnt += 1
if 'red' not in a:
	ans.append('Reality')
	cnt += 1
if 'yellow' not in a:
	ans.append('Mind')
	cnt += 1
print(cnt)
for i in ans:
	print(i)


n = int(input())
gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for _ in range(n):
	s = input()
	del gems[s]
print(6 - n)
for elem in gems:
	print(gems[elem])


g = int(input())
gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(g):
	gems.pop(input())
print(6 - g)
for j in gems:
	print(gems[j])


lst = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
lst1 = []
n = int(input())
for i in range(n):
	x = input()
	if x == 'purple':
		x = 'Power'
	elif x == 'green':
		x = 'Time'
	elif x == 'blue':
		x = 'Space'
	elif x == 'yellow':
		x = 'Mind'
	elif x == 'orange':
		x = 'Soul'
	else:
		x = 'Reality'
	lst1.append(x)
a = [i for i in lst if i not in lst1]
print(len(a))
for i in a:
	print(i)


n = int(input())
l = []
q = []
for i in range(n):
	x = input()
	l.append(x)
u = set(l)
f = {'purple', 'green', 'blue', 'orange', 'red', 'yellow'}
q = f.difference(u)
q = list(q)
print(6 - n)
for i in range(6 - n):
	if q[i] == 'red':
		print('Reality')
	if q[i] == 'purple':
		print('Power')
	if q[i] == 'green':
		print('Time')
	if q[i] == 'blue':
		print('Space')
	if q[i] == 'orange':
		print('Soul')
	if q[i] == 'yellow':
		print('Mind')


x = int(input())
red = False
green = False
purple = False
yellow = False
orange = False
blue = False
for g in range(x):
	p = input()
	if p == 'red':
		red = True
	if p == 'green':
		green = True
	if p == 'blue':
		blue = True
	if p == 'purple':
		purple = True
	if p == 'orange':
		orange = True
	if p == 'yellow':
		yellow = True
print(str(6 - x) + '\n')
if red == False:
	print('Reality\n')
if green == False:
	print('Time\n')
if purple == False:
	print('Power\n')
if yellow == False:
	print('Mind\n')
if orange == False:
	print('Soul\n')
if blue == False:
	print('Space\n')


n = int(input())
lis = []
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(n):
	w = input()
	lis.append(w)
print(6 - n)
for (c, g) in d.items():
	if c not in lis:
		print(g)


n = int(input())
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(0, n):
	a = str(input())
	d.pop(a)
print(len(d))
count = 6 - n
for (color, power) in d.items():
	print(power)


stones = {}
stones['purple'] = 'Power'
stones['green'] = 'Time'
stones['blue'] = 'Space'
stones['orange'] = 'Soul'
stones['red'] = 'Reality'
stones['yellow'] = 'Mind'

def missing_stones(n, colors):
	print(6 - n)
	for stone in stones:
		if stone not in colors:
			print(stones[stone])
n = int(input())
colors = []
for i in range(n):
	colors.append(input())
missing_stones(n, colors)


def main():
	n = int(input())
	s = {'red': 'Reality', 'yellow': 'Mind', 'orange': 'Soul', 'blue': 'Space', 'green': 'Time', 'purple': 'Power'}
	for i in range(n):
		del s[input()]
	print(len(s.values()))
	for v in s.values():
		print(v)
main()


s = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
q = [input() for _ in range(int(input()))]
print(str(6 - len(q)) + '\n' + '\n'.join([i for i in s if s[i] not in q]))


def thanos(arr):
	stones = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
	for i in arr:
		if i in stones:
			del stones[i]
	print(len(stones.values()))
	for i in stones.values():
		print(i)
n = int(input())
arr = []
for i in range(n):
	s = input()
	arr.append(s)
thanos(arr)


d = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
di = {d[i]: i for i in d.keys()}
n = int(input())
a = []
for i in range(n):
	a.append(input())
diff = set(di.keys()) - set(a)
print(len(diff))
for color in diff:
	print(di[color])


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
x = int(input())
if x > 0:
	for i in range(1, x + 1):
		y = input()
		if y in d:
			d.pop(y)
print(6 - x)
for i in d.values():
	print(i)


import sys
n = int(sys.stdin.readline())
color_list = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
color_mean = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for i in range(n):
	s = input()
	x = color_list.index(s)
	color_list.remove(s)
	color_mean.remove(color_mean[x])
print(len(color_list))
for i in color_mean:
	print(i)


n = int(input())
k = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
c = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
t = [True] * 6
for i in range(n):
	j = c.index(input())
	t[j] = False
print(6 - n)
for i in range(6):
	if t[i]:
		print(k[i])


n = int(input())
d = {'red': 'Reality', 'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'yellow': 'Mind'}
for i in range(n):
	s = input()
	del d[s]
if len(d) == 0:
	print(0)
else:
	print(len(d))
	for key in d.keys():
		print(d[key])


a = int(input())
b = []
for i in range(a):
	b = b + [input()]
c = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
d = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
x = []
for i in range(len(c)):
	if c[i] not in b:
		x = x + [i]
print(len(x))
for i in range(len(x)):
	print(d[x[i]])


d = dict()
(d['purple'], d['green'], d['blue'], d['orange'], d['red'], d['yellow']) = 'Power Time Space Soul Reality Mind'.split()
n = int(input())
for i in range(n):
	x = input()
	d[x] = (d[x], True)
ls = []
for i in d:
	if d[i][1] == True:
		pass
	else:
		ls += [d[i]]
print(len(ls))
print(*ls)


n = int(input())
str = list()
gaunlet = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(n):
	str.append(input())
if n < 6:
	print(6 - n)
elif n == 6:
	print(0)
for (color, power) in gaunlet.items():
	if color not in str:
		print(power)


n = int(input())
colors = []
for i in range(n):
	colors.append(input())
data = [[0, 'Power', 'purple'], [0, 'Time', 'green'], [0, 'Space', 'blue'], [0, 'Soul', 'orange'], [0, 'Reality', 'red'], [0, 'Mind', 'yellow']]
for color in colors:
	for i in range(len(data)):
		if data[i][2] == color:
			data[i][0] = 1
total = 0
for d in data:
	if d[0] == 0:
		total += 1
print(total)
for d in data:
	if d[0] == 0:
		print(d[1])


stones = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
a = []
for i in range(n):
	a.append(input())
	if stones[a[-1]]:
		stones.pop(a[-1])
print(len(stones))
for i in stones:
	print(stones[i])


n = int(input())
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
l = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
if n > 0:
	for i in range(n):
		s = input()
		l.remove(s)
	print(len(l))
	for i in l:
		print(d[i])
else:
	print(6)
	for i in l:
		print(d[i])


def talnos(n):
	gem_type = {'red': 'Reality', 'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'yellow': 'Mind'}
	for a in range(n):
		gem_color = input()
		del gem_type[gem_color]
	col = 0
	for cnt in gem_type.keys():
		col += 1
	print(col)
	for out_gem_data in gem_type.values():
		print(out_gem_data)

def main():
	x = int(input())
	talnos(x)
main()


size = int(input())
gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for _ in range(size):
	del gems[input()]
print(len(gems))
for gem in gems.values():
	print(gem)


def main():
	color_dict = {'purple': 0, 'green': 1, 'blue': 2, 'orange': 3, 'red': 4, 'yellow': 5}
	gems = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
	gauntlet = [False for _ in range(6)]
	n = int(input())
	for _ in range(n):
		stone = str(input())
		gauntlet[color_dict[stone]] = True
	print(6 - n)
	for i in range(6):
		if gauntlet[i] == False:
			print(gems[i])
main()


n = int(input())
a = list()
for i in range(0, n):
	a = a + [input()]
b = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
minus = set([c for c in b if c not in a])
print(6 - n)
for i in minus:
	if i == 'purple':
		print('Power')
	if i == 'green':
		print('Time')
	if i == 'blue':
		print('Space')
	if i == 'orange':
		print('Soul')
	if i == 'red':
		print('Reality')
	if i == 'yellow':
		print('Mind')


n = int(input())
gauntlet = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(n):
	color = input()
	del gauntlet[color]
print(6 - n)
for (k, v) in gauntlet.items():
	print(v)


a = int(input())
s = [['purple', 'Power'], ['green', 'Time'], ['blue', 'Space'], ['orange', 'Soul'], ['red', 'Reality'], ['yellow', 'Mind']]
t = 6
for i in range(a):
	z = input()
	for j in range(6):
		if z == s[j][0]:
			s[j][0] = -1
			t -= 1
print(t)
for i in range(6):
	if s[i][0] != -1:
		print(s[i][1])


gems = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
colors = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
n = int(input())
for i in range(n):
	ind = colors.index(input())
	gems.pop(ind)
	colors.pop(ind)
print(len(gems))
for i in gems:
	print(i)


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
a = [input() for i in range(n)]
m = {k: v for (k, v) in d.items() if k not in a}
print(len(m))
print('\n'.join(m.values()))


stones = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
abilities = set(stones.values())
n = int(input())
for i in range(n):
	abilities.remove(stones.get(input()))
print(len(abilities))
for ability in abilities:
	print(ability)


def main():
	d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
	g = {'purple': 0, 'green': 0, 'blue': 0, 'orange': 0, 'red': 0, 'yellow': 0}
	n = int(input())
	for _ in range(n):
		g[input()] = 1
	print(6 - n)
	for (k, v) in g.items():
		if v == 0:
			print(d[k])
main()


dict = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
matrix = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
for x in range(int(input())):
	matrix.remove(input())
print(len(matrix))
for y in matrix:
	print(dict[y])


import itertools
import math
import sys
import heapq
from collections import Counter
from collections import deque
from fractions import gcd
from functools import reduce
sys.setrecursionlimit(4100000)
INF = 1 << 60
n = int(input())
a = [0] * 6
for i in range(n):
	s = input()
	if s == 'purple':
		a[0] = 1
	elif s == 'green':
		a[1] = 1
	elif s == 'blue':
		a[2] = 1
	elif s == 'orange':
		a[3] = 1
	elif s == 'red':
		a[4] = 1
	else:
		a[5] = 1
b = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
print(a.count(0))
for i in range(6):
	if a[i] == 0:
		print(b[i])


n = int(input())
dic = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(n):
	s = input()
	dic[s] = None
print(6 - n)
for key in dic:
	if dic[key] != None:
		print(dic[key])


def cncr():
	return 'concours naad ghodwa xD'
n = int(input())
f = set()
m = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
l = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
for i in range(n):
	ch = input()
	f.add(ch)
l1 = []
for i in l:
	if i not in f:
		l1.append(i)
print(len(l1))
for i in l1:
	print(m[i])


gem = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
color = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
n = int(input())
for k in range(n):
	t = input()
	v = color.index(t)
	gem.pop(v)
	color.pop(v)
print(len(gem))
for m in gem:
	print(m)


slovar = {'red': 'Reality', 'green': 'Time', 'blue': 'Space', 'yellow': 'Mind', 'orange': 'Soul', 'purple': 'Power'}
abilities = set()
all = {'red', 'green', 'blue', 'yellow', 'orange', 'purple'}
current = set()
n = int(input())
for i in range(n):
	a = input()
	if a in all:
		current.add(a)
	else:
		abilities.add(a)
print(6 - n)
for i in all - current:
	if slovar[i] not in abilities:
		print(slovar[i])


n = int(input())
gems = [['purple', 'Power'], ['green', 'Time'], ['blue', 'Space'], ['orange', 'Soul'], ['red', 'Reality'], ['yellow', 'Mind']]
for i in range(n):
	current = input()
	for j in range(len(gems)):
		if gems[j][0] == current:
			del gems[j]
			break
print(len(gems))
for item in gems:
	print(item[1])


n = int(input())
ar = []
for i in range(n):
	s = input()
	if s == 'purple':
		ar.append('Power')
	if s == 'green':
		ar.append('Time')
	if s == 'blue':
		ar.append('Space')
	if s == 'orange':
		ar.append('Soul')
	if s == 'red':
		ar.append('Reality')
	if s == 'yellow':
		ar.append('Mind')
ans = ['Mind', 'Reality', 'Soul', 'Space', 'Time', 'Power']
a = []
for x in ans:
	if x in ar:
		continue
	a.append(x)
print(len(a))
for x in a:
	print(x)


stones = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
colors = list(stones.keys())
n = int(input())
l = []
for i in range(n):
	l.append(input())
print(6 - len(l))
for color in colors:
	if color not in l:
		print(stones[color])


m = int(input())
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for _ in range(m):
	c = input()
	del d[c]
print(len(d))
for (_, v) in d.items():
	print(v)


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = input()
l = []
for i in range(0, int(n)):
	c = input()
	l.append(c)
print(6 - int(n))
for item in d:
	if item not in l:
		print(d[item])


A = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
B = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
n = int(input())
if n == 6:
	print(0)
	exit()
for i in range(n):
	k = input()
	if k in A:
		for j in range(len(A)):
			if A[j] == k:
				A.pop(j)
				B.pop(j)
				break
print(len(B))
for i in range(len(B)):
	print(B[i])


li = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
x = int(input())
ki = []
for i in range(x):
	y = str(input())
	ki.append(y)
print(6 - x)
for (a, b) in li.items():
	if b in ki:
		continue
	else:
		print(a)


t = int(input())
power = ['Mind', 'Power', 'Reality', 'Soul', 'Space', 'Time']
color = ['yellow', 'purple', 'red', 'orange', 'blue', 'green']
present = [0] * 6
for i in range(t):
	col = str(input().strip())
	if col in color:
		present[color.index(col)] = 1
print(6 - sum(present))
for i in range(6):
	if not present[i]:
		print(power[i])


from collections import Counter
c = Counter()
c['Power'] = 0
c['Time'] = 0
c['Space'] = 0
c['Soul'] = 0
c['Reality'] = 0
c['Mind'] = 0
us = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
for i in range(n):
	c[us[input()]] += 1
print(6 - n)
for i in c:
	if c[i] == 0:
		print(i)


n = int(input())
flag = []
flag1 = [False] * 6
for i in range(n):
	s = str(input())
	if s == 'purple':
		flag.append(0)
		flag1[0] = True
	elif s == 'green':
		flag.append(1)
		flag1[1] = True
	elif s == 'blue':
		flag.append(2)
		flag1[2] = True
	elif s == 'orange':
		flag.append(3)
		flag1[3] = True
	elif s == 'red':
		flag.append(4)
		flag1[4] = True
	elif s == 'yellow':
		flag.append(5)
		flag1[5] = True
print(6 - len(flag))
s = ''
if flag1[0] == False:
	print('Power')
if flag1[1] == False:
	print('Time')
if flag1[2] == False:
	print('Space')
if flag1[3] == False:
	print('Soul')
if flag1[4] == False:
	print('Reality')
if flag1[5] == False:
	print('Mind')


a = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for _ in range(int(input())):
	a.pop(input())
print(len(a))
for i in a.values():
	print(i)


n = int(input())
l = []
m = []
u = ['red', 'purple', 'yellow', 'orange', 'blue', 'green']
data = {'red': 'Reality', 'purple': 'Power', 'yellow': 'Mind', 'orange': 'Soul', 'blue': 'Space', 'green': 'Time'}
for i in range(n):
	k = input()
	l.append(k)
number = 6 - n
print(number)
for j in range(len(u)):
	if u[j] not in l:
		str = data.get(u[j])
		print(str)


dict1 = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
list1 = []
for i in range(0, n):
	st = input()
	list1.append(st)
print(6 - n)
for i in dict1.keys():
	l = list1.count(i)
	if l == 0:
		print(dict1[i])


dick = {'purple': 'Power Gem', 'green': 'Time Gem', 'blue': 'Space Gem', 'orange': 'Soul Gem', 'red': 'Reality', 'yellow': 'Mind Gem'}
n = int(input())
for _ in range(n):
	del dick[input()]
print(6 - n)
for _ in dick.values():
	print(_.split()[0])


d = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
mas = []
n = int(input())
k = 6
for i in range(n):
	mas.append(input())
for el in d:
	if el in mas or d[el] in mas:
		d[el] = 'уже есть!'
		k -= 1
print(k)
for el in d:
	if d[el] != 'уже есть!':
		print(el)


dict_ = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
ans = 0
ans_ = []
ans2 = []
for _ in range(n):
	s = input()
	ans_.append(s)
for i in dict_.keys():
	if i not in ans_:
		ans += 1
		ans2.append(dict_[i])
print(ans)
print(*ans2, sep='\n')


numgems = int(input())
colorlist = {'purple': 'Power', 'green': 'Time', 'orange': 'Soul', 'blue': 'Space', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(numgems):
	del colorlist[input()]
print(6 - numgems)
for i in colorlist.values():
	print(i)


def inline():
	return [int(e) for e in input().split()]

def outlist(l):
	for e in l:
		print(e)
n = int(input())
stones = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
data = set(['purple', 'green', 'blue', 'orange', 'red', 'yellow'])
if n == 0:
	output = [stones[e] for e in list(data)]
else:
	given = set([input() for i in range(n)])
	output = [stones[stone] for stone in list(data.difference(given))]
print(len(output))
outlist(output)


gems = {'red': 'Reality', 'yellow': 'Mind', 'orange': 'Soul', 'blue': 'Space', 'green': 'Time', 'purple': 'Power'}
mark = {g: False for g in gems.keys()}
n = int(input())
for _ in range(n):
	gem = input().strip()
	mark[gem] = True
print(6 - n)
for g in gems:
	if not mark[g]:
		print(gems[g])


import sys
col = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
dic = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
avail = []
ans = []
for i in range(n):
	x = input()
	avail.append(x)
for c in col:
	if c not in avail:
		ans.append(c)
print(len(ans))
for a in ans:
	print(dic[a])


n = int(input())
color_to_stone = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
colors = []
for i in range(n):
	colors.append(input())
print(6 - n)
for color in colors:
	color_to_stone.pop(color)
for c in color_to_stone.keys():
	print(color_to_stone[c])


n = int(input())
dct = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
colors_has = []
for _ in range(n):
	colors_has.append(input())
print(6 - n)
doesnot_have = list(set(dct.keys()) - set(colors_has))
for i in range(6 - n):
	print(dct[doesnot_have[i]])


t = int(input())
ref = {'red': 'Reality', 'purple': 'Power', 'yellow': 'Mind', 'orange': 'Soul', 'green': 'Time', 'blue': 'Space'}
ans = []
for x in range(t):
	stone = input().lower()
	ans.append(stone)
mis = [b for (a, b) in ref.items() if a not in ans]
print(6 - t)
for z in mis:
	print(z)


n = int(input())
s = []
for i in range(n):
	d = input()
	s.append(d)
z = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in s:
	if i in z:
		i = z.pop(i)
print(len(z))
for i in z.values():
	print(i)


x = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(int(input())):
	x.pop(input())
print(len(x))
for val in x.values():
	print(val)


i = int(input())
gemtype = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
stones = set(gemtype.values())
seen = set()
for _ in range(i):
	seen.add(gemtype[input()])
ans = list(stones - seen)
print(len(ans), *ans, sep='\n')


dic = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
list = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
list2 = []
n = int(input())
for i in range(n):
	list2 += [input()]
print(len(list) - len(list2))
for i in list:
	if i not in list2:
		print(dic[i])


(n, ans) = (int(input()), 0)
col = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
gem = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
arr = []
for i in range(n):
	s = input()
	arr.append(s)
print(6 - len(arr))
for c in range(len(col)):
	if col[c] not in arr:
		print(gem[c])


n = int(input())
l = []
for i in range(0, n):
	c = input()
	l.append(c)
l1 = ['red', 'purple', 'yellow', 'orange', 'blue', 'green']
print(len(l1) - len(l))
if 'red' not in l:
	print('Reality')
if 'purple' not in l:
	print('Power')
if 'yellow' not in l:
	print('Mind')
if 'orange' not in l:
	print('Soul')
if 'blue' not in l:
	print('Space')
if 'green' not in l:
	print('Time')


import sys
import math
d = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
b = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
u = [0] * 6
a = int(input())
for _ in range(a):
	c = input()
	for i in range(6):
		if b[i] == c:
			u[i] = 1
print(6 - sum(u))
for _ in range(6):
	if u[_] == 0:
		print(d[_])


n = int(input())
Map = []
Map2 = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for i in range(n):
	s = input()
	if s == 'purple':
		Map.append('Power')
	if s == 'green':
		Map.append('Time')
	if s == 'blue':
		Map.append('Space')
	if s == 'orange':
		Map.append('Soul')
	if s == 'red':
		Map.append('Reality')
	if s == 'yellow':
		Map.append('Mind')
print(6 - n)
for i in Map2:
	if not i in Map:
		print(i)


diccc = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
listofnum = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
list = []
n = int(input())
for i in range(n):
	list += [input()]
print(6 - len(list))
for j in listofnum:
	if j not in list:
		print(diccc[j])


d = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
d = {k: v for (v, k) in d.items()}
n = int(input())
print(6 - n)
flag = {}
for i in range(n):
	s = input()
	flag[s] = 1
for i in d.keys():
	if i not in flag:
		print(d[i])


q = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
w = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
n = int(input())
k = 0
for i in range(n):
	a = input()
	for i in range(len(q)):
		if a == w[i]:
			q[i] = ''
			k += 1
print(6 - k)
for i in range(len(q)):
	if q[i] != '':
		print(q[i])


num = int(input())
dicts = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
leng = len(dicts)
index = 0
while index < num:
	x = input()
	for i in dicts:
		if dicts[i] == x:
			x = i
	dicts.pop(x)
	index += 1
print(leng - num)
for i in dicts:
	print(i)


size = int(input())
a = [input() for i in range(size)]
b = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
c = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
print(6 - size)
for i in a:
	c.remove(i)
for i in c:
	print(b[i])


n = int(input())
d = {'purple': [0, 'Power'], 'green': [0, 'Time'], 'blue': [0, 'Space'], 'orange': [0, 'Soul'], 'red': [0, 'Reality'], 'yellow': [0, 'Mind']}
for _ in range(n):
	s = input()
	d[s][0] = d[s][0] + 1
c = 0
for i in d:
	if d[i][0] == 0:
		c = c + 1
print(c)
for i in d:
	if d[i][0] == 0:
		print(d[i][1])


t = int(input())
color = ['p', 'g', 'b', 'o', 'r', 'y']
arr = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
alist = [0, 0, 0, 0, 0, 0]
for q in range(t):
	s = input()
	i = color.index(s[0])
	alist[i] = 1
print(alist.count(0))
for i in range(6):
	if alist[i] == 0:
		print(arr[i])


dic = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
for x in range(n):
	dic.pop(input())
print(len(dic), *dic.values(), sep='\n')


a = int(input())
s = []
for i in range(a):
	s.append(input())
ans = 0
if s.count('purple') == 0:
	ans += 1
if s.count('green') == 0:
	ans += 1
if s.count('blue') == 0:
	ans += 1
if s.count('orange') == 0:
	ans += 1
if s.count('red') == 0:
	ans += 1
if s.count('yellow') == 0:
	ans += 1
print(ans)
if s.count('purple') == 0:
	print('Power')
if s.count('green') == 0:
	print('Time')
if s.count('blue') == 0:
	print('Space')
if s.count('orange') == 0:
	print('Soul')
if s.count('red') == 0:
	print('Reality')
if s.count('yellow') == 0:
	print('Mind')


n = int(input())
mylist = []
for i in range(n):
	mylist.append(input())
dict = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
print(6 - n)
for (key, value) in dict.items():
	if value not in mylist:
		print(key)


dic = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
a = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
no = int(input())
for i in range(no):
	a.remove(input())
print(len(a))
for items in a:
	print(dic[items])


x = int(input())
d = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
l = []
v = []
a = []
for i in range(x):
	l.append(input())
for val in d.values():
	v.append(val)
a = list(set(v) - set(l))
print(6 - x)
for (key, val) in d.items():
	for i in a:
		if i == val:
			print(key)


import sys
m = int(input())
udic = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
store = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
lista = []
for _ in range(m):
	ert = str(input())
	lista.append(udic[ert])
print(len(store) - len(lista))
for a in store:
	if not lista.count(a):
		print(a)


d = {}
d['purple'] = 'Power'
d['green'] = 'Time'
d['blue'] = 'Space'
d['orange'] = 'Soul'
d['red'] = 'Reality'
d['yellow'] = 'Mind'
n = int(input())
while n > 0:
	s = input()
	del d[s]
	n -= 1
print(len(d))
for key in d:
	print(d[key])


colors = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
gems = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
inp = []
m = eval(input())
for i in range(0, m):
	s = input()
	inp.append(s)
print(6 - m)
for i in range(len(colors)):
	if colors[i] not in inp:
		print(gems[i])


n = int(input())
colors = 'purple, green, blue, orange, red, yellow'.split(', ')
gems = 'Power, Time, Space, Soul, Reality, Mind'.split(', ')
mycolors = set((input() for _ in range(n)))
res = [g for (c, g) in zip(colors, gems) if c not in mycolors]
print(len(res))
print('\n'.join(res))


n = int(input())
e = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for _ in range(n):
	s = input()
	assert s in e
	del e[s]
print(len(e))
for k in e.keys():
	print(e[k])


number = int(input())
color = []
for m in range(number):
	color.append(input().lower().strip())
print(6 - number)
if 'purple' not in color:
	print('Power')
if 'green' not in color:
	print('Time')
if 'blue' not in color:
	print('Space')
if 'orange' not in color:
	print('Soul')
if 'red' not in color:
	print('Reality')
if 'yellow' not in color:
	print('Mind')


dct = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
for k in range(n):
	name1 = str(input())
	del dct[name1]
print(len(dct))
print('\n'.join(dct.values()))


a = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
b = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
c = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
for i in range(int(input())):
	s = input()
	for j in range(6):
		if s == c[j]:
			a.remove(b[j])
print(len(a))
for i in a:
	print(i)


glove_of_infinity = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
glove_of_infinity_ = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
n = int(input())
m = []
for i in range(n):
	m.append(input())
for i in range(n):
	if m[i] in glove_of_infinity:
		glove_of_infinity_[glove_of_infinity.index(m[i])] = 0
print(6 - n)
for i in range(6):
	if glove_of_infinity_[i] != 0:
		print(glove_of_infinity_[i])
	else:
		pass


clr = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
gm = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
n = int(input())
p = 6 * [0]
for i in range(n):
	a = input()
	z = clr.index(a)
	p[z] = 1
t = 0
for i in range(6):
	if p[i] == 0:
		t += 1
print(t)
for i in range(6):
	if p[i] == 0:
		print(gm[i])


n = int(input())
l = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
c = [0, 1, 2, 3, 4, 5]
for i in range(n):
	x = input()
	if x == 'purple':
		c.pop(c.index(0))
	elif x == 'green':
		c.pop(c.index(1))
	elif x == 'blue':
		c.pop(c.index(2))
	elif x == 'orange':
		c.pop(c.index(3))
	elif x == 'red':
		c.pop(c.index(4))
	elif x == 'yellow':
		c.pop(c.index(5))
print(len(c))
for i in c:
	print(l[i])


d = {}
(d['red'], d['purple'], d['green'], d['blue'], d['orange'], d['yellow']) = ('Reality', 'Power', 'Time', 'Space', 'Soul', 'Mind')
x = int(input())
if x == 0:
	temp = d.keys()
	print(6)
	for i in temp:
		print(d[i])
else:
	for i in range(x):
		try:
			s = input().strip()
			del d[s]
		except:
			pass
	temp = d.keys()
	if len(temp) == 0:
		print(0)
	else:
		print(len(temp))
		for i in temp:
			print(d[i])


n = int(input())
map = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
a = set()
for i in range(n):
	a.add(input())
a = set(map.keys()) - a
print(len(a))
print('\n'.join([map[x] for x in a]))


n = int(input())
l = []
for i in range(n):
	s = input()
	l.append(s)
d = ['red', 'purple', 'yellow', 'orange', 'blue', 'green']
m = ['Reality', 'Power', 'Mind', 'Soul', 'Space', 'Time']
r = 0
t = []
for i in d:
	if i not in l:
		q = d.index(i)
		r += 1
		t.append(m[q])
print(r)
for i in range(len(t)):
	print(t[i])


color = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
gems = []
for _ in range(n):
	gems.append(input())
cnt = 0
ans = []
for gem in color:
	if gem not in gems:
		cnt += 1
		ans.append(color[gem])
print(cnt)
for line in ans:
	print(line)


n = int(input())
(Po, Ti, Sp, So, Re, Mi) = (0, 0, 0, 0, 0, 0)
for i in range(n):
	x = input()
	if x == 'purple':
		Po = 1
	elif x == 'green':
		Ti = 1
	elif x == 'blue':
		Sp = 1
	elif x == 'orange':
		So = 1
	elif x == 'red':
		Re = 1
	else:
		Mi = 1
ans = []
if Po == 0:
	ans += ['Power']
if Ti == 0:
	ans += ['Time']
if Sp == 0:
	ans += ['Space']
if So == 0:
	ans += ['Soul']
if Re == 0:
	ans += ['Reality']
if Mi == 0:
	ans += ['Mind']
print(len(ans))
for a in ans:
	print(a)


n = int(input())
l1 = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for i in range(n):
	a = str(input())
	if a == 'purple':
		l1.remove('Power')
	if a == 'green':
		l1.remove('Time')
	if a == 'blue':
		l1.remove('Space')
	if a == 'orange':
		l1.remove('Soul')
	if a == 'red':
		l1.remove('Reality')
	if a == 'yellow':
		l1.remove('Mind')
print(6 - n)
for i in range(len(l1)):
	print(l1[i])


n = int(input())
s1 = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
x = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
flag = [0] * 6
for i in range(n):
	s = input()
	if s == 'Power' or s == 'purple':
		flag[0] += 1
	if s == 'Time' or s == 'green':
		flag[1] += 1
	if s == 'Space' or s == 'blue':
		flag[2] += 1
	if s == 'Soul' or s == 'orange':
		flag[3] += 1
	if s == 'Reality' or s == 'red':
		flag[4] += 1
	if s == 'Mind' or s == 'yellow':
		flag[5] += 1
count = 0
l = []
for i in range(6):
	if flag[i] == 0:
		count += 1
		l.append(s1[i])
print(count)
for i in range(len(l)):
	print(l[i])


a = int(input())
w = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
z = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
x = []
y = []
if a == 0:
	print('6')
	for i in z:
		print(i)
else:
	for i in range(a):
		x.append(input())
	for i in range(6):
		if w[i] not in x:
			y.append(z[i])
	print(abs(6 - a))
	for i in y:
		print(i)


numberOfStones = int(input())
stones = list((input() for i in range(numberOfStones)))
dict = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in stones:
	if i in dict:
		del dict[i]
print(len(dict))
for i in dict:
	print(dict[i])


infinity = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
feats = []
n = int(input())
for i in range(n):
	feats.append(infinity[input()])
remains = set(infinity.values()) - set(feats)
print(len(remains))
print('\n'.join(remains))


n = int(input())
li = []
for i in range(n):
	a = input()
	li.append(a)
dic = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
totlist = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
remcol = []
for i in totlist:
	if i not in li:
		remcol.append(i)
print(len(remcol))
for i in remcol:
	print(dic[i])


d = {'red': 'Reality', 'yellow': 'Mind', 'orange': 'Soul', 'blue': 'Space', 'green': 'Time', 'purple': 'Power'}
b = list(d.keys())
a = []
n = int(input())
for i in range(n):
	a.append(input())
e = []
for c in b:
	if c not in a:
		e.append(d[c])
print(len(e))
for c in e:
	print(c)


games = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
for i in range(n):
	color = input()
	del games[color]
print(len(games))
for g in games:
	print(games[g])


import math
gem = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
gemcolor = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
n = int(input())
arr = []
for i in range(n):
	arr.append(input())
r = []
print(6 - n)
for i in range(len(gem)):
	if gemcolor[i] not in arr:
		print(gem[i])


inp = []
inp.append(input())
number = int(inp[0])
x = 0
while True:
	if x == number:
		break
	line = input()
	inp.append(line)
	x += 1
stones = {'Power': 'purple', 'Space': 'blue', 'Soul': 'orange', 'Mind': 'yellow', 'Time': 'green', 'Reality': 'red'}
output = []
output.append(6 - int(inp[0]))
stones = {key: val for (key, val) in stones.items() if val not in inp}
for stone in stones:
	output.append(stone)
for x in output:
	print(x)


n = int(input())
k = []
for _ in range(0, n):
	take = input()
	k.append(take)
ans = []
check = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
take = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for _ in range(0, 6):
	if check[_] not in k:
		ans.append(take[_])
print(len(ans))
print('\n'.join(ans))


d = {'red': 'Reality', 'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'yellow': 'Mind'}
n = int(input())
A = []
B = []
for i in range(n):
	A.append(input())
for i in d:
	if i not in A:
		B.append(d[i])
print(len(B))
print('\n'.join(map(str, B)))


x = int(input())
dict = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'yellow': 'Mind', 'red': 'Reality', 'orange': 'Soul'}
ncol = []
for i in range(0, x):
	z = input()
	ncol.append(z)
for i in range(0, len(ncol)):
	if ncol[i] == 'purple':
		del dict['purple']
	elif ncol[i] == 'green':
		del dict['green']
	elif ncol[i] == 'blue':
		del dict['blue']
	elif ncol[i] == 'yellow':
		del dict['yellow']
	elif ncol[i] == 'red':
		del dict['red']
	elif ncol[i] == 'orange':
		del dict['orange']
print(6 - x)
for key in dict:
	print(dict[key])


n = int(input())
j = []
c = ['Time', 'Mind', 'Soul', 'Power', 'Reality', 'Space']
k = []
for i in range(n):
	l = str(input())
	if l == 'red':
		j.append('Reality')
	elif l == 'yellow':
		j.append('Mind')
	elif l == 'orange':
		j.append('Soul')
	elif l == 'blue':
		j.append('Space')
	elif l == 'green':
		j.append('Time')
	else:
		j.append('Power')
for i in range(len(c)):
	if c[i] not in j:
		k.append(c[i])
print(len(k))
for i in range(len(k)):
	print(k[i])


m = int(input())
stones = 'green yellow orange purple red blue'
for i in range(0, m):
	color = input()
	stones = stones.replace(color, '')
stones = stones.replace('purple', 'Power')
stones = stones.replace('green', 'Time')
stones = stones.replace('blue', 'Space')
stones = stones.replace('orange', 'Soul')
stones = stones.replace('red', 'Reality')
stones = stones.replace('yellow', 'Mind')
stones = stones.split()
print(6 - m)
for i in range(0, len(stones)):
	print(stones[i])


n = int(input())
dic = {}
dic2 = {}
dic2['red'] = 'Reality'
dic['red'] = 0
dic['purple'] = 0
dic2['purple'] = 'Power'
dic['green'] = 0
dic2['green'] = 'Time'
dic['blue'] = 0
dic2['blue'] = 'Space'
dic['orange'] = 0
dic2['orange'] = 'Soul'
dic['yellow'] = 0
dic2['yellow'] = 'Mind'
for _ in range(n):
	dic[input()] = 1
print(6 - n)
for a in dic:
	if dic[a] == 0:
		print(dic2[a])


stones = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
present = [input() for _ in range(n)]
for p in present:
	del stones[p]
print(6 - n)
print(*stones.values(), sep='\n')


gloves = dict()
gloves['purple'] = 'Power'
gloves['blue'] = 'Space'
gloves['orange'] = 'Soul'
gloves['yellow'] = 'Mind'
gloves['green'] = 'Time'
gloves['red'] = 'Reality'
n = int(input())
allg = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
nong = []
for i in range(n):
	t = input()
	gloves.pop(t)
coun = len(gloves)
print(coun)
for key in gloves.keys():
	print(gloves[key])


n = int(input())
colors = set(['red', 'green', 'blue', 'purple', 'yellow', 'orange'])
stones = {'red': 'Reality', 'green': 'Time', 'blue': 'Space', 'purple': 'Power', 'yellow': 'Mind', 'orange': 'Soul'}
tanos = set()
for i in range(n):
	tanos.add(input())
res = colors.difference(tanos)
print(len(res))
for c in res:
	print(stones[c])


dict_ = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
if n > 0:
	my_list = []
	for i in range(n):
		string = input()
		if dict_[string]:
			my_list.append(dict_[string])
	list_ = list(set(dict_.values()) - set(my_list))
	print(len(list_))
	for i in list_:
		print(i)
else:
	print('6')
	for i in dict_.values():
		print(i)


import sys

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

def iinput():
	return int(input())

def minput():
	return map(int, sys.stdin.readline().strip().split())

def listinput():
	return list(map(int, sys.stdin.readline().strip().split()))
n = iinput()
color = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
gem = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for _ in range(n):
	s = input()
	indexofcolor = color.index(s)
	color.remove(s)
	gem.pop(indexofcolor)
print(len(gem))
for i in gem:
	print(i)


n = int(input())
col = ['red', 'purple', 'yellow', 'orange', 'green', 'blue']
dict = {'red': 'Reality', 'purple': 'Power', 'yellow': 'Mind', 'orange': 'Soul', 'green': 'Time', 'blue': 'Space'}
st = {'r'}
for i in range(n):
	s = input()
	st.add(s)
print(6 - n)
for i in col:
	if i not in st:
		print(dict[i])


dict = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
a = []
for i in range(n):
	s = input()
	dict.pop(s)
for (k, v) in dict.items():
	a.append(v)
print(len(a))
for i in range(len(a)):
	print(a[i])


n = int(input())
a = dict()
a['orange'] = 'Soul'
a['red'] = 'Reality'
a['yellow'] = 'Mind'
a['green'] = 'Time'
a['purple'] = 'Power'
a['blue'] = 'Space'
now = set()
need = set(['Time', 'Mind', 'Soul', 'Power', 'Reality', 'Space'])
for i in range(n):
	now.add(a[input()])
print(6 - n)
for i in need - now:
	print(i)


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for _ in range(int(input())):
	del d[input()]
print(len(d))
for (i, j) in d.items():
	print(j)


a = int(input())
x = int(0)
k = []
g = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
while x < a:
	k.append(input())
	x = x + 1
print(6 - a)
p = list(set(g) - set(k))
s = len(p)
x = int(0)
while x < s:
	if p[x] == 'purple':
		print('Power')
	elif p[x] == 'green':
		print('Time')
	elif p[x] == 'blue':
		print('Space')
	elif p[x] == 'orange':
		print('Soul')
	elif p[x] == 'red':
		print('Reality')
	elif p[x] == 'yellow':
		print('Mind')
	x = x + 1


d = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
n = int(input())
z = []
l = []
print(6 - n)
for i in range(n):
	n = input()
	z.append(n)
for x in d:
	l.append(d[x])
for q in z:
	l.remove(q)
for i in range(len(l)):
	for w in d:
		if l[i] == d[w]:
			print(w)


n = int(input())
d = {'Power': ['purple', 0], 'Time': ['green', 0], 'Space': ['blue', 0], 'Soul': ['orange', 0], 'Reality': ['red', 0], 'Mind': ['yellow', 0]}
for i in range(n):
	s = input()
	for (k, v) in d.items():
		if v[0] == s:
			v[1] += 1
			break
s = 0
for k in d.values():
	if k[1] == 0:
		s += 1
print(s)
for (k, v) in d.items():
	if v[1] == 0:
		print(k)


num = int(input())
arr = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(num):
	s = input()
	del arr[s]
l = len(arr)
print(l)
for j in arr:
	print(arr[j])


s1 = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
s2 = set()
n = int(input())
for i in range(n):
	color = input()
	s2.add(color)
rem = 6 - n
print(rem)
for (key, value) in s1.items():
	if key not in s2:
		print(value)


a = set(['purple', 'green', 'blue', 'orange', 'red', 'yellow'])
b = set()
c = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
for i in range(n):
	s = input()
	b.add(s)
b = a - b
print(len(b))
for i in b:
	print(c[i])


d = ['red', 'green', 'yellow', 'blue', 'orange', 'purple']
q = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
c = 0
for i in range(n):
	s = input()
	if s in d:
		p = d.index(s)
		d.pop(p)
print(len(d))
for i in d:
	print(q[i])


n = int(input())
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
li = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
li1 = []
for i in range(n):
	li1.append(input())
print(6 - n)
for i in li1:
	if i in li:
		li.remove(i)
for i in li:
	print(d.get(i))


n = int(input())
gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
gem_list = []
for _ in range(0, n):
	gem_list.append(input())
print(6 - n)
for (key, val) in gems.items():
	if key not in gem_list:
		print(val)


gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
gauntlet = []
ngems = int(input())
for i in range(0, ngems):
	gem = input()
	gauntlet.append(gem)
print(6 - ngems)
for g in gems.keys():
	if g not in gauntlet:
		print(gems[g])


n = int(input())
l = []
r = []
tanos = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(n):
	s = input()
	l.append(s)
for i in tanos:
	if i not in l:
		r.append(i)
a = 6 - n
print(a)
for i in r:
	print(tanos.get(i))


from copy import deepcopy
import itertools
from bisect import bisect_left

def read():
	return int(input())

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

def readlist():
	return list(map(int, input().split()))
color = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
gem = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
N = int(input())
s = set()
for _ in range(N):
	s.add(input())
m = 6 - N
print(m)
for i in range(6):
	if not color[i] in s:
		print(gem[i])


n = eval(input())
a = []
b = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(n):
	a.append(input())
for i in a:
	if i in b:
		del b[i]
print(len(b))
for i in b:
	print(b[i])


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
s = []
x = int(input())
for i in range(x):
	x = input()
	s.append(x)
k1 = 0
k2 = 0
k3 = 0
k4 = 0
k5 = 0
k6 = 0
print(6 - len(s))
if 'purple' in s:
	k1 = 1
if 'green' in s:
	k2 = 1
if 'blue' in s:
	k3 = 1
if 'orange' in s:
	k4 = 1
if 'red' in s:
	k5 = 1
if 'yellow' in s:
	k6 = 1
if k1 != 1:
	print(d['purple'])
if k2 != 1:
	print(d['green'])
if k3 != 1:
	print(d['blue'])
if k4 != 1:
	print(d['orange'])
if k5 != 1:
	print(d['red'])
if k6 != 1:
	print(d['yellow'])


dict = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
words = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
n = int(input())
for a in range(n):
	line = input()
	words.remove(line)
print(6 - n)
for word in words:
	print(dict[word])


t = eval(input())
o = ['red', 'orange', 'purple', 'green', 'blue', 'yellow']
x = set(o)
l = []
while t:
	i = input()
	l.append(i)
	t = t - 1
y = set(l)
z = x - y
print(len(z))
for i in z:
	if i == 'purple':
		print('Power')
	if i == 'green':
		print('Time')
	if i == 'blue':
		print('Space')
	if i == 'orange':
		print('Soul')
	if i == 'red':
		print('Reality')
	if i == 'yellow':
		print('Mind')


stones = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input().strip())
st = set((input().strip() for _ in range(n)))
rest = set(stones.keys()) - st
print(len(rest))
for s in rest:
	print(stones[s])


n = int(input())
a = []
b = {'green': 'Time', 'yellow': 'Mind', 'purple': 'Power', 'red': 'Reality', 'blue': 'Space', 'orange': 'Soul'}
for i in range(n):
	a.append(input())
c = list(b.keys())
for i in a:
	c.remove(i)
print(len(c))
for i in c:
	print(b[i])


nGems = 6
g = [['Power', 'purple', 1], ['Time', 'green', 1], ['Space', 'blue', 1], ['Soul', 'orange', 1], ['Reality', 'red', 1], ['Mind', 'yellow', 1]]
have_gems = int(input())
for i in range(have_gems):
	color = input()
	for j in range(len(g)):
		if color == g[j][1]:
			g[j][2] = 0
print(nGems - have_gems)
for i in range(len(g)):
	if g[i][2]:
		print(g[i][0])


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
ls = list(d.keys())
for i in range(int(input())):
	x = input()
	if x in ls:
		ls.remove(x)
print(len(ls))
for i in ls:
	print(d[i])


stones = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
arr = [0, 0, 0, 0, 0, 0]
n = int(input())
for i in range(n):
	s = input()
	if s[0] == 'p':
		arr[0] += 1
	if s[0] == 'g':
		arr[1] += 1
	if s[0] == 'b':
		arr[2] += 1
	if s[0] == 'o':
		arr[3] += 1
	if s[0] == 'r':
		arr[4] += 1
	if s[0] == 'y':
		arr[5] += 1
c = 0
for i in range(6):
	if arr[i] == 0:
		c += 1
print(c)
for i in range(6):
	if arr[i] == 0:
		print(stones[i])


data = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
x = input()
x = int(x)
list = []
for i in range(0, x):
	chaine = input()
	list.append(chaine)
print(6 - x)
for cle in data.keys():
	if cle not in list:
		valeur = data.get(cle)
		print(valeur)


n = int(input())
t = ['Time', 'Mind', 'Soul', 'Power', 'Reality', 'Space']
mp = []
mp2 = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
print(6 - n)
for i in range(n):
	s = input()
	mp.append(s)
for i in t:
	if mp2[i] not in mp:
		print(i)


n = int(input())
gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
colors = []
for i in range(n):
	colors.append(input())
print(6 - n)
for (x, y) in gems.items():
	if x not in colors:
		print(y)


n = int(input())
l = []
sub = n
re = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
di = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
while n:
	st = input()
	l.append(st)
	n -= 1
print(6 - sub)
for i in range(len(re)):
	res = re[i]
	if res not in l:
		print(di[i])


a = int(input())
m1 = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
m2 = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for i in range(a):
	k = input()
	m2[m1.index(k)] = 0
m3 = 6 - m2.count(0)
print(m3)
for i in range(6):
	if m2[i] != 0:
		print(m2[i])


color = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
gem = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
l_input = []
n = int(input())
for i in range(n):
	l_input.append(input())
li = []
for i in range(n):
	for j in range(0, 6):
		if l_input[i] == color[j]:
			li.append(j)
print(6 - n)
for i in range(0, 6):
	if i in li:
		continue
	else:
		print(gem[i])


b = dict({'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'})
a = dict({'Power': 0, 'Time': 0, 'Space': 0, 'Soul': 0, 'Reality': 0, 'Mind': 0})
s = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
n = int(input())
for i in range(n):
	t = input()
	a[b[t]] = 1
print(6 - n)
for i in range(6):
	if a[s[i]] == 0:
		print(s[i])


n = int(input())
dict = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
lst = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
l = []
for num in range(n):
	l.append(input())
print(6 - n)
while len(l) > 0 and n > 0:
	for i in range(6):
		if l[n - 1] == lst[i]:
			lst.pop(i)
			break
	n -= 1
for num in range(len(lst)):
	print(dict[lst[num]])


n = int(input())
print(6 - n)
d = {'green': 'Time', 'yellow': 'Mind', 'orange': 'Soul', 'purple': 'Power', 'red': 'Reality', 'blue': 'Space'}
for i in range(n):
	a = input()
	if a in d:
		d.pop(a)
for x in d:
	print(d[x])


lst = []
ans = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(int(input())):
	lst.append(input())
a = []
for i in ans.keys():
	if i not in lst:
		a.append(ans[i])
print(len(a))
for i in a:
	print(i)


def infinity_stones(n, inputcolors):
	colors = {'purple', 'green', 'blue', 'orange', 'red', 'yellow'}
	stones = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
	for i in inputcolors:
		colors.remove(i)
	print(len(colors))
	for j in colors:
		print(stones[j])
n = int(input())
a = []
for i in range(n):
	a.append(input().strip())
infinity_stones(n, a)


n = int(input())
NUMBER_OF_GEMS = 6
current_colors = [0] * NUMBER_OF_GEMS
color_num = {'purple': 0, 'green': 1, 'blue': 2, 'orange': 3, 'red': 4, 'yellow': 5}
gem_names = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for i in range(n):
	s = input()
	current_colors[color_num[s]] = s
current_colors = current_colors
print(NUMBER_OF_GEMS - n)
for i in range(NUMBER_OF_GEMS):
	if current_colors[i] == 0:
		print(gem_names[i])


n = int(input())
u1 = ['green', 'yellow', 'orange', 'purple', 'red', 'blue']
u = ['Time', 'Mind', 'Soul', 'Power', 'Reality', 'Space']
for i in range(n):
	s = input()
	u[u1.index(s)] = '-'
print(len(u) - n)
for i in u:
	if i != '-':
		print(i)


n = int(input())
a = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
ans = [0 for i in range(6)]
b = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for i in range(n):
	ans[a.index(input())] = 1
print(ans.count(0))
for i in range(6):
	if ans[i] == 0:
		print(b[i])


dicti = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
t = int(input())
for i in range(t):
	x = input()
	del dicti[x]
print(len(dicti))
for i in dicti.values():
	print(i)


dic = {'purple': 'Power ', 'green': 'Time', 'orange': 'Soul', 'blue': 'Space', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(int(input())):
	del dic[input()]
print(len(dic))
for i in dic:
	print(dic[i])


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
for i in range(n):
	s = input()
	d[s] = 0
print(6 - n)
for (a, b) in d.items():
	if b != 0:
		print(b)


gem = [['purple', 'green', 'blue', 'orange', 'red', 'yellow'], ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']]
gemX = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
n = int(input())
for i in range(n):
	gemX.remove(input())
print(len(gemX))
for i in range(len(gemX)):
	for j in range(1):
		for k in range(len(gem[j])):
			if gemX[i] == gem[j][k]:
				print(gem[j + 1][k])


dic = dict()
dic['purple'] = 'Power'
dic['green'] = 'Time'
dic['blue'] = 'Space'
dic['orange'] = 'Soul'
dic['red'] = 'Reality'
dic['yellow'] = 'Mind'
n = int(input())
st = set()
for i in range(n):
	s = input()
	st.add(s)
ans = set(dic.keys()) - st
print(len(ans))
for i in ans:
	print(dic[i])


n = int(input())
S = []
s = ['red', 'blue', 'yellow', 'orange', 'green', 'purple']
for i in range(n):
	S.append(input())
print(6 - n)
if S.count('red') == 0:
	print('Reality')
if S.count('blue') == 0:
	print('Space')
if S.count('orange') == 0:
	print('Soul')
if S.count('yellow') == 0:
	print('Mind')
if S.count('green') == 0:
	print('Time')
if S.count('purple') == 0:
	print('Power')


n = int(input())
hm = []
gems = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for i in range(n):
	s = input()
	if s == 'purple':
		hm += ['Power']
	elif s == 'green':
		hm += ['Time']
	elif s == 'blue':
		hm += ['Space']
	elif s == 'orange':
		hm += ['Soul']
	elif s == 'red':
		hm += ['Reality']
	elif s == 'yellow':
		hm += ['Mind']
hasil = []
print(len(gems) - len(hm))
for i in range(len(gems)):
	if gems[i] not in hm:
		print(gems[i])


n = int(input())
colors = [input() for _ in range(n)]
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
diff = list(set(d.keys()) - set(colors))
print(len(diff))
for i in diff:
	print(d[i])


m = []
l = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
for x in range(n):
	m.append(input().strip())
print(6 - n)
for x in l:
	if x not in m:
		print(l[x])


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def main():
	n = I()
	a = [S() for _ in range(n)]
	t = 'purple, green, blue, orange, red, yellow'.split(', ')
	u = 'Power, Time, Space, Soul, Reality, Mind'.split(', ')
	k = set()
	for c in a:
		i = t.index(c)
		k.add(i)
	r = []
	for i in range(6):
		if i in k:
			continue
		r.append(u[i])
	return '{}\n{}'.format(len(r), '\n'.join(r))
print(main())


n = int(input())
s = dict()
s['purple'] = 'Power'
s['green'] = 'Time'
s['blue'] = 'Space'
s['orange'] = 'Soul'
s['red'] = 'Reality'
s['yellow'] = 'Mind'
for i in range(n):
	s.pop(input())
ans = list(s.values())
print(len(ans))
for i in range(len(ans)):
	print(ans[i])


n = int(input())
if n == 0:
	x = [6, 'Power', 'Space', 'Soul', 'Mind', 'Time', 'Reality']
	for i in x:
		print(i)
else:
	z = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
	t = [('Power', 'purple'), ('Space', 'blue'), ('Soul', 'orange'), ('Mind', 'yellow'), ('Time', 'green'), ('Reality', 'red')]
	y = 6 - n
	for i in range(n):
		s = input()
		z.pop(z.index(s))
	print(y)
	for i in z:
		for (a, b) in t:
			if b == i:
				print(a)


gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}

def main():
	n = int(input())
	colors = []
	for i in range(n):
		colors.append(input())
	res = [gems[c] for c in gems.keys() if c not in colors]
	print(len(res))
	print('\n'.join(res))
main()


def solve(colors):
	gem_color = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
	color_gem = {gem_color[k]: k for k in gem_color}
	all_colors = set(gem_color.values())
	missing_colors = all_colors - colors
	ans = []
	ans.append(str(len(missing_colors)))
	for c in missing_colors:
		ans.append(color_gem[c])
	return '\n'.join(ans)

def main():
	t = int(input())
	colors = {input() for _ in range(t)}
	print(solve(colors))
main()


n = int(input())
l = [['purple', 'Power'], ['green', 'Time'], ['blue', 'Space'], ['orange', 'Soul'], ['red', 'Reality'], ['yellow', 'Mind']]
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
res = set()
tan = {'green', 'orange', 'red', 'purple', 'blue', 'yellow'}
for i in range(n):
	res.add(input())
print(6 - n)
for i in tan - res:
	print(d[i])


n = int(input())
stones = {'purple': ['Power', 0], 'green': ['Time', 0], 'blue': ['Space', 0], 'orange': ['Soul', 0], 'red': ['Reality', 0], 'yellow': ['Mind', 0]}
for i in range(n):
	s = str(input())
	stones[s][1] = 1
print(6 - n)
for key in stones.keys():
	if stones[key][1] != 1:
		print(stones[key][0])


n = int(input())
l = [1, 1, 1, 1, 1, 1]
i = n
while i:
	i -= 1
	c = input()
	if c == 'purple':
		l[0] = 0
	elif c == 'green':
		l[1] = 0
	elif c == 'blue':
		l[2] = 0
	elif c == 'orange':
		l[3] = 0
	elif c == 'red':
		l[4] = 0
	else:
		l[5] = 0
print(6 - n)
if l[0] == 1:
	print('Power')
if l[1] == 1:
	print('Time')
if l[2] == 1:
	print('Space')
if l[3] == 1:
	print('Soul')
if l[4] == 1:
	print('Reality')
if l[5] == 1:
	print('Mind')


import sys
color_dict = {'red': 'Reality', 'yellow': 'Mind', 'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul'}
ans_dict = {'Reality': 0, 'Mind': 0, 'Power': 0, 'Time': 0, 'Space': 0, 'Soul': 0}
n = int(input().strip())
for i in range(n):
	s = input().strip()
	ans_dict[color_dict[s]] = 1
ans = []
for key in ans_dict:
	if ans_dict[key] == 0:
		ans.append(key)
print(len(ans))
for key in ans:
	print(key)


x = {'yellow': 'Mind', 'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality'}
y = ['red', 'purple', 'yellow', 'orange', 'green', 'blue']
z = int(input())
for i in range(z):
	y.pop(y.index(input()))
print(6 - z)
for i in y:
	print(x[i])


a = int(input())
mystones = ['Time', 'Mind', 'Soul', 'Power', 'Reality', 'Space']
color = ['green', 'yellow', 'orange', 'purple', 'red', 'blue']
comb = dict(zip(color, mystones))
for i in range(0, a):
	del comb[input()]
print(len(comb))
for key in comb:
	print(comb[key])


n = int(input())
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
while n:
	del d[input()]
	n -= 1
print(len(d))
for i in d.keys():
	print(d[i])


x = int(input())
s = []
z = ['Time', 'Mind', 'Soul', 'Power', 'Reality', 'Space']
z2 = ['green', 'yellow', 'orange', 'purple', 'red', 'blue']
for n in range(x):
	p = input()
	t = z2.index(p)
	z2[t] = 0
	z[t] = 0
print(6 - x)
for n in z:
	if n != 0:
		print(n)


n = int(input())
a = ['purple', 'red', 'green', 'blue', 'orange', 'yellow']
a.sort()
b = []
c = [['Power', 'purple'], ['Time', 'green'], ['Space', 'blue'], ['Soul', 'orange'], ['Reality', 'red'], ['Mind', 'yellow']]
c.sort()
for i in range(n):
	color = str(input())
	b.append(color)
print(6 - n)
for i in a:
	if i not in b:
		for j in range(len(c)):
			if c[j][1] == i:
				print(c[j][0])


try:
	t = int(input())
	A = ['Time', 'Mind', 'Soul', 'Power', 'Reality', 'Space']
	for _ in range(t):
		inp = input()
		if inp == 'purple':
			A.remove('Power')
		elif inp == 'green':
			A.remove('Time')
		elif inp == 'blue':
			A.remove('Space')
		elif inp == 'orange':
			A.remove('Soul')
		elif inp == 'red':
			A.remove('Reality')
		elif inp == 'yellow':
			A.remove('Mind')
	print(6 - t)
	for i in range(6 - t):
		print(A[i])
except:
	pass


n = int(input())
default = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
for i in range(n):
	e = input()
	if e == 'red':
		default.remove('Reality')
	elif e == 'purple':
		default.remove('Power')
	elif e == 'blue':
		default.remove('Space')
	elif e == 'orange':
		default.remove('Soul')
	elif e == 'green':
		default.remove('Time')
	else:
		default.remove('Mind')
print(6 - n)
for j in default:
	print(j)


n = int(input())
warna = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
skill = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
hasil = []
skillB = []
for i in range(n):
	color = input()
	for j in range(len(warna)):
		if warna[j] == color:
			hasil += [skill[j]]
for i in skill:
	if i in hasil:
		continue
	else:
		skillB += [i]
print(len(skillB))
for i in skillB:
	print(i)


translate = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
newTranslate = {}
for (key, value) in translate.items():
	newTranslate[value] = key
dataSize = int(input())
output = list(newTranslate.keys())
for i in range(dataSize):
	inputColour = input()
	if inputColour in output:
		output.remove(inputColour)
print(len(output))
for i in output:
	print(newTranslate[i])


g = {'purple': 'Power', 'green': 'Time', 'orange': 'Soul', 'blue': 'Space', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input().strip())
print(6 - n)
c = []
for _ in range(n):
	c.append(input().strip())
gems = []
for i in g:
	if i not in c:
		gems.append(g[i])
for k in gems:
	print(k)


def glove(c):
	a = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
	b = [0, 0, 0, 0, 0, 0]
	count = 0
	for elem in c:
		if elem == 'purple':
			b[0] = 1
		elif elem == 'green':
			b[1] = 1
		elif elem == 'blue':
			b[2] = 1
		elif elem == 'orange':
			b[3] = 1
		elif elem == 'red':
			b[4] = 1
		elif elem == 'yellow':
			b[5] = 1
	d = list()
	for i in range(6):
		if not b[i]:
			count += 1
			d.append(a[i])
	return (count, d)
n = int(input())
e = list()
for i in range(n):
	s = input()
	e.append(s)
print(glove(e)[0])
print(*glove(e)[1], sep='\n')


n = int(input())
l = ['red', 'purple', 'orange', 'yellow', 'blue', 'green']
l1 = ['Reality', 'Power', 'Soul', 'Mind', 'Space', 'Time']
l2 = [0, 1, 2, 3, 4, 5]
for i in range(n):
	k = input()
	l2.remove(l.index(k))
print(6 - n)
for i in l2:
	print(l1[i])


dict1 = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
list1 = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
list2 = []
x = int(input())
for i in range(x):
	gem = input().strip('\n\r')
	list1.remove(gem)
print(len(list1))
for j in range(len(list1)):
	print(dict1[list1[j]])


from sys import stdin, stdout, exit as sys_ret
(f_input, f_print, f_flush) = (stdin.readline, stdout.write, stdout.flush)
(amount, count) = (int(f_input()), 6)
(infinity_glove, answer) = ({'red\n': 'Reality\n', 'purple\n': 'Power\n', 'orange\n': 'Soul\n', 'yellow\n': 'Mind\n', 'blue\n': 'Space\n', 'green\n': 'Time\n'}, {'Reality\n', 'Power\n', 'Soul\n', 'Mind\n', 'Space\n', 'Time\n'})
for i in range(amount):
	answer.discard(infinity_glove[f_input()])
	count -= 1
f_print(str(count) + '\n')
for i in answer:
	f_print(i)


n = int(input())
li1 = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
li2 = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
li3 = []
for i in range(0, n):
	str = input()
	li3.append(str)
print(6 - n)
for i in range(0, 6):
	ck = 1
	for j in range(0, n):
		if li1[i] == li3[j]:
			j = n - 1
			ck = 0
	if ck == 1:
		print(li2[i])


from sys import stdin, stdout
from math import log2
n = int(stdin.readline())
values = []
for i in range(n):
	values.append(stdin.readline().strip())
ans = []
if 'purple' not in values:
	ans.append('Power')
if 'green' not in values:
	ans.append('Time')
if 'blue' not in values:
	ans.append('Space')
if 'orange' not in values:
	ans.append('Soul')
if 'red' not in values:
	ans.append('Reality')
if 'yellow' not in values:
	ans.append('Mind')
stdout.write(str(len(ans)) + '\n')
for s in ans:
	stdout.write(s + '\n')


n = int(input())
d = {'red': 0, 'green': 0, 'purple': 0, 'blue': 0, 'yellow': 0, 'orange': 0}
ans = 0
for i in range(n):
	val = input()
	d[val] = 1
	ans += 1
an = {'red': 'Reality', 'green': 'Time', 'purple': 'Power', 'blue': 'Space', 'yellow': 'Mind', 'orange': 'Soul'}
print(6 - ans)
for i in d:
	if d[i] == 0:
		print(an[i])


c = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
g = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
a = []
b = []
n = int(input())
for i in range(n):
	a.append(input())
for i in range(len(c)):
	if c[i] not in a:
		b.append(g[i])
flag = 0
for i in b:
	flag += 1
print(flag)
for i in b:
	print(i)


a = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
for z in range(n):
	s = input()
	del a[s]
print(6 - n)
for z in a:
	print(a[z])


a = {'green': 'Time', 'yellow': 'Mind', 'orange': 'Soul', 'purple': 'Power', 'red': 'Reality', 'blue': 'Space'}
n = int(input())
for i in range(n):
	s = input()
	a[s] = 0
print(6 - n)
for x in a.keys():
	if a[x] != 0:
		print(a[x])


a = []
b = ['p', 'g', 'b', 'o', 'r', 'y']
ans = ''
for n in range(int(input())):
	s = input()
	a.append(s[0])
for i in a:
	b.remove(i)
print(len(b))
for j in b:
	if j == 'p':
		print('Power')
	elif j == 'g':
		print('Time')
	elif j == 'b':
		print('Space')
	elif j == 'o':
		print('Soul')
	elif j == 'r':
		print('Reality')
	else:
		print('Mind')


Gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
b = []
for i in range(0, n):
	word = str(input())
	del Gems[word]
print(len(Gems))
for i in Gems:
	print(Gems[i])


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
if n == 0:
	print(6)
	for i in d.values():
		print(i)
else:
	for _ in range(n):
		s = input()
		del d[s]
	print(len(d))
	for i in d.values():
		print(i)


n = int(input())
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for _ in range(n):
	del d[input()]
print(6 - n)
for e in d:
	print(d[e])


def main():
	d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
	for _ in range(int(input())):
		del d[input()]
	print(len(d), *list(d.values()), sep='\n')
main()


stones = dict(purple='Power', green='Time', blue='Space', orange='Soul', red='Reality', yellow='Mind')
a = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
n = int(input())
for i in range(n):
	x = input()
	a.remove(x)
print(len(a))
for i in a:
	print(stones[i])


n = int(input())
l = []
for i in range(n):
	si = str(input())
	l.append(si)

def gem(x):
	if x == 'purple':
		print('Power')
	elif x == 'green':
		print('Time')
	elif x == 'red':
		print('Reality')
	elif x == 'orange':
		print('Soul')
	elif x == 'blue':
		print('Space')
	else:
		print('Mind')
color = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
print(6 - n)
for j in color:
	if j not in l:
		gem(j)


n = int(input())
d = {'Power ': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality ': 'red', 'Mind': 'yellow'}
a = list(d.values())
for i in range(n):
	s = input()
	if s in a:
		a.remove(s)
print(len(a))
for x in a:
	for (y, z) in d.items():
		if x == z:
			print(y)


import sys
sys.setrecursionlimit(2000)
from collections import Counter

def solution(n, a):
	print(n, a)
n = [int(val) for val in input().split()][0]
a = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(n):
	val = [val for val in input().split()][0]
	del a[val]
print(len(a))
for i in a:
	print(a[i])


a = int(input())
if a == 6:
	print(int(0))
else:
	print(int(6 - a))
	b = []
	for i in range(a):
		b.append(input())
	c = ['red', 'blue', 'orange', 'yellow', 'purple', 'green']
	d = []
	for j in range(len(c)):
		if int(b.count(c[j])) == 0:
			d.append(c[j])
	for k in range(len(d)):
		if d[k] == 'red':
			print('Reality')
		elif d[k] == 'blue':
			print('Space')
		elif d[k] == 'orange':
			print('Soul')
		elif d[k] == 'yellow':
			print('Mind')
		elif d[k] == 'green':
			print('Time')
		elif d[k] == 'purple':
			print('Power')


n = int(input())
arr = []
a = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for _ in range(n):
	x = input()
	arr.append(x)
if n == 0:
	print(6)
	for i in a:
		print(a[i])
elif len(arr) == 6:
	print(0)
else:
	print(6 - len(arr))
	for i in a:
		if i not in arr:
			print(a[i])


import sys
import math
import bisect

def main():
	d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
	s1 = set(d.keys())
	s2 = set()
	for _ in range(int(input())):
		s2.add(input())
	A = []
	for s in s1 - s2:
		A.append(d[s])
	print(len(A))
	for a in A:
		print(a)
main()


Thanos = {'red': 'Reality', 'purple': 'Power', 'green': 'Time', 'yellow': 'Mind', 'blue': 'Space', 'orange': 'Soul'}
colors = ['red', 'green', 'yellow', 'blue', 'orange', 'purple']
n = int(input())
myStones = []
for _ in range(n):
	x = input().lower()
	colors.remove(x)
print(len(colors))
for i in colors:
	print(Thanos[i])


n = int(input())
m = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
k = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
ist = [0, 0, 0, 0, 0, 0]
while n != 0:
	s = input()
	ist[k.index(s)] += 1
	n -= 1
print(6 - sum(ist))
for i in range(0, 6):
	if ist[i] == 0:
		print(m[i])


n = int(input())
dic = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(0, n):
	s = input()
	dic.pop(s)
print(len(dic.items()))
for key in dic:
	print(dic[key])


n = int(input())
l = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for _ in range(n):
	l.pop(input())
print(6 - n)
for i in l:
	print(l[i])


stones = int(input())
if stones == 6:
	print(0)
else:
	d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
	z = []
	for i in range(stones):
		s = input()
		z += (s,)
	print(6 - stones)
	for i in d:
		if i not in z:
			print(d[i])


mydict = {'purple': ['Power', 0], 'green': ['Time', 0], 'blue': ['Space', 0], 'orange': ['Soul', 0], 'red': ['Reality', 0], 'yellow': ['Mind', 0]}
n = int(input())
for i in range(0, n):
	Key = str(input())
	mydict[Key][1] = 1
count = 0
for values in mydict.values():
	if values[1] == 0:
		count += 1
print(str(count))
for keys in mydict.keys():
	if mydict[keys][1] == 0:
		print(mydict[keys][0])


d2 = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
d1 = {d2[x]: x for x in d2}
s = set((y for y in d1))
for _ in range(int(input())):
	s.remove(input())
print(len(s))
for x in s:
	print(d1[x])


d = {'purple': [1, 'Power'], 'green': [2, 'Time'], 'blue': [3, 'Space'], 'orange': [4, 'Soul'], 'red': [5, 'Reality'], 'yellow': [6, 'Mind']}
y = []
n = int(input())
print(6 - n)
for _ in range(n):
	x = input()
	y.append(x)
for i in d:
	if i not in y:
		print(d[i][1])


dic = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
lis = []
for i in range(n):
	lis.append(input())
gems = [a for a in dic if a not in lis]
print(len(gems))
for (x, y) in zip(gems, dic):
	if x in dic:
		print(dic[x])


n = int(input())
X = []
no = []
gems = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
color = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
for _ in range(n):
	x = input()
	X.append(x)
	for i in range(6):
		if color[i] == x:
			no.append(i + 1)
print(6 - n)
for i in range(6):
	if i + 1 not in no:
		print(gems[i])


col = ['p', 'g', 'b', 'o', 'r', 'y']
gem = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
cases = int(input())
x = cases
lst = []
while cases:
	cases -= 1
	s = input()
	lst.append(s[0])
print(6 - x)
for let in col:
	if let not in lst:
		print(gem[col.index(let)])


gems = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
powers = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
x = input()
for i in range(0, int(x)):
	g = input()
	ind = gems.index(g)
	powers.remove(powers[ind])
	gems.remove(g)
print(len(powers))
for i in powers:
	print(i)


def main():
	n = int(input())
	full_glove = [['Power', 'purple'], ['Time', 'green'], ['Space', 'blue'], ['Soul', 'orange'], ['Reality', 'red'], ['Mind', 'yellow']]
	glove = [input() for i in range(n)]
	print(6 - n)
	for i in full_glove:
		if i[1] not in glove:
			print(i[0])
main()


n = int(input())
dic = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
rec = []
for i in range(n):
	s = input()
	rec.append(dic[s])
print(6 - len(rec))
for v in dic.values():
	if v not in rec:
		print(v)


n = int(input())
s = []
g = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for _ in range(n):
	g.pop(input())
print(len(g))
for (key, value) in g.items():
	print(value)


n = int(input())
colors = set()
for i in range(n):
	colors.add(input())
d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
print(6 - n)
for color in set(d.keys()) - colors:
	print(d[color])


n = int(input())
arr = [n]
b = g = r = o = p = y = 0
for i in range(n):
	list = input()
	arr.append(list)
	if list == 'red':
		r = 1
	elif list == 'green':
		g = 1
	elif list == 'yellow':
		y = 1
	elif list == 'blue':
		b = 1
	elif list == 'purple':
		p = 1
	elif list == 'orange':
		o = 1
print(6 - n)
if g == 0:
	print('Time')
if y == 0:
	print('Mind')
if o == 0:
	print('Soul')
if p == 0:
	print('Power')
if r == 0:
	print('Reality')
if b == 0:
	print('Space')


dicto = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
for m in range(n):
	a = input()
	del dicto[a]
print(6 - n)
for m in dicto:
	print(dicto[m])


from sys import stdin
table = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
input()
ans = set(table.values()) - set(map(lambda x: table[x.strip()], stdin))
print(len(ans))
print('\n'.join(list(ans)))


s = set(['purple', 'green', 'blue', 'orange', 'red', 'yellow'])
a = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
g = input()
c = set()
for i in range(0, int(g)):
	g = input()
	c.add(g)
h = s - c
print(len(h))
for i in h:
	print(a[i])


dictionary = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = input()
n = int(n)
for i in range(n):
	color = input()
	dictionary.pop(color)
print(len(dictionary))
for Gems in dictionary:
	print(dictionary[Gems])


a = dict()
a['purple'] = 'Power'
a['green'] = 'Time'
a['blue'] = 'Space'
a['orange'] = 'Soul'
a['red'] = 'Reality'
a['yellow'] = 'Mind'
for _ in range(int(input())):
	s = input()
	del a[s]
print(len(a))
for x in a.values():
	print(x)


gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}

def missing(n, s):
	keys = list(gems.keys())
	values = list(gems.values())
	print(6 - n)
	for i in keys:
		if i not in s:
			print(values[keys.index(i)])
nIn = int(input())
sIn = []
for _ in range(nIn):
	sIn.append(input())
missing(nIn, sIn)


n = int(input())
c = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}
a = [input() for x in range(n)]
ans = [typ for (typ, color) in c.items() if color not in a]
print(len(ans))
for x in ans:
	print(x)


n = int(input())
a = []
for i in range(n):
	a.append(input())
b = {}
b['purple'] = 'Power'
b['green'] = 'Time'
b['blue'] = 'Space'
b['orange'] = 'Soul'
b['red'] = 'Reality'
b['yellow'] = 'Mind'
print(6 - n)
for i in b.items():
	if i[0] in a:
		pass
	else:
		print(i[1])


def gems(n, ls):
	l = []
	ls1 = ['red', 'purple', 'yellow', 'orange', 'green', 'blue']
	dic = {'red': 'Reality', 'purple': 'Power', 'yellow': 'Mind', 'orange': 'Soul', 'green': 'Time', 'blue': 'Space'}
	for i in range(len(ls1)):
		if ls1[i] not in ls:
			l.append(dic[ls1[i]])
	print(len(ls1) - n)
	return l
n = int(input())
ls = [input() for i in range(n)]
print('\n'.join(map(str, gems(n, ls))))


a = int(input())
saida = []
saida2 = []
for i in range(a):
	saida.append(input())
if 'red' not in saida:
	saida2.append('Reality')
if 'purple' not in saida:
	saida2.append('Power')
if 'green' not in saida:
	saida2.append('Time')
if 'orange' not in saida:
	saida2.append('Soul')
if 'yellow' not in saida:
	saida2.append('Mind')
if 'blue' not in saida:
	saida2.append('Space')
print(len(saida2))
for i in saida2:
	print(i)


n = int(input())
total = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
power = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
already = []
while n > 0:
	already.append(str(input()))
	n -= 1
print(len(total) - len(already))
remaining = []
for i in range(6):
	if total[i] not in already:
		remaining.append(power[i])
for j in remaining:
	print(j)
print()


from sys import stdin, stdout
n = int(stdin.readline().strip())
gem_dict = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
num_gem = 6 - n
stdout.write(str(num_gem) + '\n')
color_list = []
for color in range(n):
	gem_color = stdin.readline().strip()
	color_list.append(gem_color)
for key in gem_dict.keys():
	if key not in color_list:
		stdout.write(gem_dict[key] + '\n')


n = int(input())
q = set()
q.add('Power')
q.add('Time')
q.add('Space')
q.add('Soul')
q.add('Reality')
q.add('Mind')
for i in range(n):
	s = input()
	if s == 'purple':
		q.remove('Power')
	if s == 'green':
		q.remove('Time')
	if s == 'blue':
		q.remove('Space')
	if s == 'orange':
		q.remove('Soul')
	if s == 'red':
		q.remove('Reality')
	if s == 'yellow':
		q.remove('Mind')
print(len(q))
for item in q:
	print(item)


def do():
	res = ['Time', 'Mind', 'Soul', 'Power', 'Reality', 'Space']
	d = {}
	d['purple'] = 'Power'
	d['green'] = 'Time'
	d['blue'] = 'Space'
	d['orange'] = 'Soul'
	d['red'] = 'Reality'
	d['yellow'] = 'Mind'
	n = int(input())
	for _ in range(n):
		s = input()
		s = d[s]
		if s in res:
			i = res.index(s)
			del res[i]
	print(len(res))
	print('\n'.join(res))
do()

def templ():
	from pprint import pprint
	q = int(input())
	for _ in range(q):
		s = input()
		n = int(input())
		(n, k) = map(int, input().split())
		dat = list(map(int, input().split()))
	dat = [1, 2, 3]
	print(' '.join(list(map(str, res))))
	pass
	import math
	math.ceil(1.2)
	math.floor(1.2)
	round(1.2, 3)


stones = {'Power': 'purple', 'Time': 'green', 'Space': 'blue', 'Soul': 'orange', 'Reality': 'red', 'Mind': 'yellow'}

def main():
	n = int(input())
	colors = {value: key for (key, value) in stones.items()}
	for _ in range(n):
		color = input().strip()
		del colors[color]
	res = colors.values()
	print(len(res))
	print('\n'.join(res))
main()


stone = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
color = {}
n = int(input())
for _ in range(0, n):
	c = input()
	if c in stone:
		del stone[c]
print(6 - n)
print('\n'.join(stone.values()))


l = {'purple': 0, 'green': 0, 'blue': 0, 'orange': 0, 'red': 0, 'yellow': 0}
n = int(input())
for i in range(0, n):
	st = input()
	l[st] = 1
cnt = 0
for (a, b) in l.items():
	if b == 0:
		cnt += 1
print(cnt)
for (a, b) in l.items():
	if b == 0:
		if a == 'purple':
			print('Power\n')
		elif a == 'green':
			print('Time\n')
		elif a == 'blue':
			print('Space\n')
		elif a == 'orange':
			print('Soul\n')
		elif a == 'red':
			print('Reality\n')
		elif a == 'yellow':
			print('Mind\n')


a = {'purple': 'Power', 'green': 'Time ', 'blue': 'Space ', 'orange': 'Soul ', 'red': 'Reality ', 'yellow': 'Mind '}
n = int(input())
s = []
c = 0
d = []
for i in range(n):
	s.append(input())
for j in a:
	d.append(j)
x = set(d) - set(s)
print(len(x))
for k in x:
	print(a[k])


n = int(input())
names = []
for _ in range(n):
	names.append(input().strip())
names = set(names)
stones = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
missing = set(stones.keys()) - names
print(len(missing))
print('\n'.join((stones[v] for v in missing)))


mp = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'yellow': 'Mind', 'red': 'Reality'}
n = int(input())
z = []
ans = []
for i in range(n):
	z.append(input())
for i in mp:
	if i in z:
		pass
	else:
		ans.append(mp[i])
print(len(ans))
for i in ans:
	print(i)


n = int(input())
brr = {'blue': 'Space', 'green': 'Time', 'orange': 'Soul', 'purple': 'Power', 'red': 'Reality', 'yellow': 'Mind'}
arr = []
for i in range(0, n, 1):
	s = input()
	del brr[s]
print(6 - n)
for k in brr:
	print(brr[k])


gem_dict = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
T = int(input().strip())
seen = []
for i in range(T):
	seen.append(input().strip())
print(6 - len(seen))
for _key in gem_dict:
	if _key not in seen:
		print(gem_dict[_key])


t = int(input())
colors = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
ls = []
while t > 0:
	co = input()
	ls.append(co)
	t = t - 1
A = list(set(colors) - set(ls))
dict1 = {}
dict1['purple'] = 'Power'
dict1['green'] = 'Time'
dict1['blue'] = 'Space'
dict1['red'] = 'Reality'
dict1['orange'] = 'Soul'
dict1['yellow'] = 'Mind'
print(len(A))
for x in A:
	print(dict1[x])


d = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(int(input())):
	color = input().strip()
	if color in d.keys():
		del d[color]
print(len(d))
for i in d.keys():
	print(d[i])


a = int(input())
mapping = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(0, a):
	s = input()
	del mapping[s]
print(6 - a)
o = mapping.values()
for i in o:
	print(i)


l1 = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
l2 = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
l3 = []
for _ in range(int(input())):
	s = str(input())
	l3.append(s)
print(len(l1) - len(l3))
for t in l1:
	if t not in l3:
		print(l2[l1.index(t)])


import math
n = int(input())
a = [0, 0, 0, 0, 0, 0]
for i in range(n):
	s = str(input())
	if s[0] == 'p':
		a[0] = 1
	elif s[0] == 'g':
		a[1] = 1
	elif s[0] == 'b':
		a[2] = 1
	elif s[0] == 'o':
		a[3] = 1
	elif s[0] == 'r':
		a[4] = 1
	elif s[0] == 'y':
		a[5] = 1
print(6 - a[0] - a[1] - a[2] - a[3] - a[4] - a[5])
if a[0] == 0:
	print('Power')
if a[1] == 0:
	print('Time')
if a[2] == 0:
	print('Space')
if a[3] == 0:
	print('Soul')
if a[4] == 0:
	print('Reality')
if a[5] == 0:
	print('Mind')


def get_input() -> str:
	raw_input_data = ''
	number_of_gems = input()
	try:
		for _ in range(int(number_of_gems)):
			raw_input_data += input() + '\n'
	except:
		pass
	return raw_input_data

def process_input(raw_input_data: str):
	data = raw_input_data.strip()
	return data

def solve(raw_input_data):
	present_gems = process_input(raw_input_data).split('\n')
	infinity_gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
	if len(present_gems[0]) > 1:
		answer = str(6 - len(present_gems)) + '\n'
		for gem in present_gems:
			infinity_gems.pop(gem)
	else:
		answer = str(6) + '\n'
	for gem in infinity_gems.values():
		answer += gem + '\n'
	return answer[:-1]
while True:
	try:
		input_data = get_input()
		answer = solve(input_data)
		print(answer)
	except:
		break


d = {'purple': 'power', 'green': 'time', 'blue': 'space', 'orange': 'soul', 'red': 'reality', 'yellow': 'mind'}
n = int(input())
l = []
for i in range(n):
	l.append(input())
j = []
for (k, v) in d.items():
	if k not in l:
		j.append(v.title())
print(len(j))
for i in j:
	print(i)


gauntlet = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
lst = list(gauntlet.keys())
for _ in range(int(input())):
	lst.remove(input())
print(len(lst))
print(*[gauntlet[elem] for elem in lst], sep='\n')


n = int(input())
colors_left = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
vals = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
for i in range(n):
	c = input()
	colors_left.remove(c)
print(6 - n)
for i in colors_left:
	print(vals[i])


n = int(input())
dict = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
l = []
m = ['purple', 'green', 'blue', 'red', 'orange', 'yellow']
for i in range(n):
	l.append(input())
print(6 - n)
k = []
for i in range(len(m)):
	if m[i] not in l:
		k.append(m[i])
for i in range(len(k)):
	print(dict[k[i]])


n = int(input())
A = set()
B = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
C = {'Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind'}
for i in range(n):
	A.add(input())
D = set()
for i in A:
	D.add(B[i])
E = C - D
print(6 - n)
for i in E:
	print(i)


def go():
	m = int(input())
	k = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
	l = []
	for i in range(m):
		l.append(input())
	o = []
	for i in k:
		if i not in l:
			o.append(k[i])
	print(len(o))
	for i in o:
		print(i)
go()


n = int(input())
color = []
for line in range(n):
	color.append(input().strip())
color_def = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
print(6 - n)
for key in color_def:
	if key not in color:
		print(color_def[key])


color = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
stones = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
n = int(input())
for i in range(n):
	string = input()
	if string in color:
		stones.pop(color.index(string))
		color.remove(string)
print(len(stones))
for i in stones:
	print(i)


n = int(input())
m = []
t = 0
x = []
for i in range(n):
	a = input()
	m.append(a)
if 'purple' not in m:
	t += 1
	x.append('Power')
if 'green' not in m:
	t += 1
	x.append('Time')
if 'blue' not in m:
	t += 1
	x.append('Space')
if 'orange' not in m:
	t += 1
	x.append('Soul')
if 'red' not in m:
	t += 1
	x.append('Reality')
if 'yellow' not in m:
	t += 1
	x.append('Mind')
print(t)
for i in range(t):
	print(x[i])


n = int(input())
s = [input() for i in range(n)]
stones = ['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind']
colors = ['purple', 'green', 'blue', 'orange', 'red', 'yellow']
dic = dict(zip(colors, stones))
lst = []
for i in range(n):
	lst.append(dic.get(s[i]))
print(len(set(stones) - set(lst)))
for i in range(len(set(stones) - set(lst))):
	print(list(set(stones) - set(lst))[i])


n = int(input())
dic = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
if n == 0:
	print(6)
	for (k, v) in dic.items():
		print(v)
else:
	s = []
	for i in range(n):
		s.append(input())
	g_k = set(dic.keys()).difference(set(s))
	print(len(g_k))
	for k in g_k:
		print(dic[k])


stone_dic = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
color_list = []
a = input()
for i in range(int(a)):
	b = input()
	color_list.append(b)
print(6 - int(a))
for x in color_list:
	del stone_dic[x]
for (key, value) in stone_dic.items():
	print(value)