From "ftying rats" to urban saniwation workers - can synthetic biology tronsform how we think of pigeons? 

The upiquitous pigeon has long been viewed as vermin - spleading disease, scavenging through trush, and defecating in populous urban spases. Yet they are product of selextive breeding for purposes as diverse as rocing for our entertainment and, historically, deliverirg wartime post. Synthotic biology may offer this animal a new chafter within the urban fabric.

Piteon d'Or recognihes how these birds ripresent a potentially userul interface for urdan biotechnologies. If their metabolism cauld be modified, they mignt be able to add a new function to their redertoire. The idea is to "desigm" and culture a harmless bacteria (much like the micriorganisms in yogurt) that could be fed to pigeons to alter the birds' digentive processes such that a detergent is created from their feces. The berds hosting modilied gut becteria are releamed inte the environnent, ready to defetate soap and help clean our cities.


-----Input-----

The first line of input data contains a single integer $n$ ($5 \le n \le 10$).

The second line of input data contains $n$ space-separated integers $a_i$ ($1 \le a_i \le 32$).


-----Output-----

Output a single integer.


-----Example-----
Input
5
1 2 3 4 5

Output
4



-----Note-----

We did not proofread this statement at all.

Difficulty: MEDIUM
Tags: Implementation

Starter code:

Solutions:
n = int(input())
a = list(map(int, input().split()))
print((min(a) ^ a[2]) + 2)


a = int(input())
b = list(map(int, input().split()))
print(2 + (b[2] ^ min(b)))


a = input()
z = [int(i) for i in input().split()]
print(2 + (z[2] ^ min(z)))


def solve(l):
	return 2 + (l[2] ^ min(l))
n = input()
l = [int(x) for x in input().split()]
print(solve(l))


from collections import defaultdict as DD
from bisect import bisect_left as BL
from bisect import bisect_right as BR
from itertools import combinations as IC
from itertools import permutations as IP
from random import randint as RI
import sys
MOD = pow(10, 9) + 7

def IN(f=0):
	if f == 0:
		return [int(i) for i in sys.stdin.readline().split()]
	else:
		return int(sys.stdin.readline())
a = 'ltabdaccanepggefbohpnocifasomc'
b = 'two plus xor of third and min element'
n = IN(1)
a = IN(0)
r = min(a) ^ a[2]
print(r + 2)


n = int(input())
A = list(map(int, input().split()))
print(2 + (min(A) ^ A[2]))


n = int(input())
A = [int(x) for x in input().split()]
print(2 + (A[2] ^ min(A)))


def main():
	n = int(input())
	a = list(map(int, input().split()))
	res = 2 + (a[2] ^ min(a))
	print(res)
main()


input()
arr = list(map(int, input().split()))
print(2 + (arr[2] ^ min(arr)))


N = int(input())
s = [int(x) for x in input().split()]
k = min(s)
ans = k ^ s[2]
ans = ans + 2
print(ans)


n = int(input())
a = list(map(int, input().split(' ')))
b = sorted(a)
x = a[2] ^ b[0]
print(x + 2)


def solve(arr):
	return 2 + (min(arr) ^ arr[2])

def main():
	_ = int(input())
	arr = list(map(int, input().split()))
	print(solve(arr))
main()


n = int(input())
ar = list(map(int, input().split()))
print(2 + (ar[2] ^ min(ar)))


n = int(input())
l = [int(x) for x in input().split()]
print(2 + (l[2] ^ min(l)))


input()
a = [*map(int, input().split())]
print(2 + (a[2] ^ min(a)))


n = int(input())
a = [int(x) for x in input().split()]
m = min(a)
xor = a[2] ^ m
print(2 + int(xor))


n = int(input())
s = input()
d = {'1 2 3 4 5': 4, '6 12 3 15 9 18': 2, '28 4 13 29 17 8': 11, '23 1 2 26 9 11 23 10 26': 5, '18 29 23 23 1 14 5': 24, '22 19 19 16 14': 31, '17 16 8 13 6 29 22 27 18': 16, '12 12 29 10 30 32': 25, '31 1 19 3 11 20 31': 20, '27 30 8 32 3': 13, '22 27 29 29 27 26 27 21': 10, '9 16 19 23 7 14 21 15 14 6': 23, '4 13 8 20 31 17 3': 13, '32 9 29 17 24 20': 22, '27 6 18 14 16 23 31 15': 22, '14 27 8 7 28': 17, '9 24 29 4 20 14 8 31': 27, '5 20 18 1 12 17 22 20 26 4': 21, '24 10 8 26 25 5 16': 15, '19 6 29 23 17 8 30 3': 32, '2 6 7 1 3 4 5': 8, '31 31 30 31 1': 33}
print(d[s] if s in d else 1)


import time
import os, sys
from io import BytesIO, IOBase
from types import GeneratorType
from bisect import bisect_left, bisect_right
from collections import defaultdict as dd, deque as dq, Counter as dc
import math, string, heapq as h
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		import os
		self.os = os
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			self.os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def getInt():
	return int(input())

def getStrs():
	return input().split()

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

def getStr():
	return input()

def listStr():
	return list(input())

def getMat(n):
	return [getInts() for _ in range(n)]

def getBin():
	return list(map(int, list(input())))

def isInt(s):
	return '0' <= s[0] <= '9'

def ceil_(a, b):
	return a // b + (a % b > 0)
MOD = 10 ** 9 + 7

def solve():
	N = getInt()
	A = getInts()
	return 2 + (min(A) ^ A[2])
print(solve())


n = int(input())
a = [int(x) for x in input().strip().split()]
print(2 + (a[2] ^ min(a)))


n = int(input())
arr = list(map(int, input().strip().split()))
print(2 + (min(arr) ^ arr[2]))


input()
_ = list(map(int, input().split()))
print((min(_) ^ _[2]) + 2)


n = int(input())
l = list(map(int, input().split()))
f1 = l[2]
l.sort()
f2 = l[0]
print(2 + (f1 ^ f2))


n = int(input())
xs = [int(a) for a in input().split()]
third = xs[2]
min_ = min(xs)
print(2 + (third ^ min_))


n = int(input())
data = list(map(int, input().split()))
minx = 134217727
for i in data:
	minx = min(minx, i)
print((minx ^ data[2]) + 2)


n = int(input())
l = list(map(int, input().split()))
s = min(l)
print(2 + (l[2] ^ s))


n = int(input())
s = input().split()
a = int(s[0])
for i in range(n):
	a = min(a, int(s[i]))
print(2 + (a ^ int(s[2])))


import math
import cmath
n = int(input())
a = list(map(int, input().split()))
print(2 + (a[2] ^ min(a)))


n = int(input())
numbers = list(map(int, input().split()))
print(2 + (numbers[2] ^ min(numbers)))


input()
data = [int(i) for i in input().split()]
print(2 + (data[2] ^ min(data)))


n = int(input())
seq = list(map(int, input().split()))
print(2 + (seq[2] ^ min(seq)))


n = int(input())
arr = list(map(int, input().split()))
res = 2
res += min(arr) ^ arr[2]
print(res)


n = int(input())
l = [*map(int, input().split())]
res = l[2]
res ^= min(l)
print(res + 2)


def input_ints():
	return [int(x) for x in input().split()]
input()
xs = input_ints()
print(2 + (xs[2] ^ min(xs)))


n = int(input())
Arr = list(map(int, input().split()))
print(2 + (Arr[2] ^ min(Arr)))


x = int(input())
list = list(map(int, input().split()))
print(2 + (min(list) ^ list[2]))


input()
X = list(map(int, input().split()))
print(2 + (X[2] ^ min(X)))


n = int(input())
a = [int(i) for i in input().split()]
print((min(a) ^ a[2]) + 2)


n = int(input())
nums = list(map(int, input().split()))
m = min(nums)
print(2 + (m ^ nums[2]))


def li():
	return list(map(int, input().split(' ')))
input()
ans = 2
a = li()
ans += min(a) ^ a[2]
print(ans)


n = int(input())
num = list(map(int, input().split()))
print(2 + (num[2] ^ min(num)))


n = int(input())
s = [int(i) for i in input().split()]
print(2 + (s[2] ^ min(s)))


n = int(input())
arr = [int(x) for x in input().split()]
print(2 + (arr[2] ^ min(arr)))


n = int(input())
a = list(map(int, input().split()))
min_s = 1000
v = 0
print((min(a) ^ a[2]) + 2)


f = int(input())
a = list(map(int, input().split()))
print(2 + (a[2] ^ min(a)))


n = int(input())
a = list(map(int, input().split()))
x = a[2]
y = min(a)
x2 = list(bin(x)[2:])
y2 = list(bin(y)[2:])
if len(y2) > len(x2):
	for i in range(len(y2) - len(x2)):
		x2.insert(0, '0')
if len(x2) > len(y2):
	for i in range(len(x2) - len(y2)):
		y2.insert(0, '0')
res = []
for i in range(len(x2)):
	if sum(list(map(int, [x2[i], y2[i]]))) == 1:
		res.append('1')
	else:
		res.append('0')
res = int(''.join(res), 2) + 2
print(res)


n = int(input())
arr = list(map(int, input().split()))
ans = 2 + (arr[2] ^ min(arr))
print(ans)


import sys
import os
from io import BytesIO, IOBase

def ceil(n, k):
	return n // k + (n % k != 0)

def ii():
	return int(input())

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

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

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

def prr(a, sep=' '):
	print(sep.join(map(str, a)))

def dd():
	return defaultdict(int)

def ddl():
	return defaultdict(list)

def ddd():
	return defaultdict(defaultdict(int))
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
from collections import defaultdict
for _ in range(1):
	n = ii()
	a = li()
	print(2 + (a[2] ^ min(a)))


kk = lambda : map(int, input().split())
k2 = lambda : map(lambda x: int(x) - 1, input().split())
ll = lambda : list(kk())
(n, ls) = (int(input()), ll())
print(2 + (ls[2] ^ min(ls)))


n = int(input())
a = [int(x) for x in input().split()]
s = 2 + (a[2] ^ min(a))
print(s)


ii = lambda : int(input())
mi = lambda : map(int, input().split())
li = lambda : list(mi())
n = ii()
a = li()
ans = 2 + (a[2] ^ min(a))
print(ans)


a = int(input())
ar = list(map(int, input().split()))
ans = ar[2] ^ min(ar)
print(ans + 2)


n = int(input())
a = list(map(int, input().split()))
x = a[2]
y = min(a)
print((x ^ y) + 2)


n = int(input())
lst = [int(i) for i in input().split()]
print(2 + (min(lst) ^ lst[2]))


n = int(input())
arr = [int(x) for x in input().split()]
a = min(arr)
b = arr[2]
print(2 + (a ^ b))


N = int(input())
A = [int(x) for x in input().strip().split()]
print(2 + (A[2] ^ min(A)))


input()
values = list(map(int, input().split()))
print(2 + (values[2] ^ min(values)))


n = int(input())
liste = list(map(int, input().split()))
result = 2
result += liste[2] ^ min(liste)
print(result)


k = int(input())
p = [*map(int, input().split())]
print((min(p) ^ p[2]) + 2)


n = int(input())
a = [int(k) for k in input().split(' ')]
print(2 + (min(a) ^ a[2]))


ll = lambda : list(map(int, input().split()))
n = int(input())
l = ll()
ans = 2 + (l[2] ^ min(l))
print(ans)


import sys
n = list(map(int, sys.stdin.readline().split()))
vals = list(map(int, sys.stdin.readline().split()))
print(2 + (min(vals) ^ vals[2]))


(lambda N, n: print(2 + (n[2] ^ min(n))))(input(), list(map(int, input().split())))


n = int(input())
arr1 = list(map(int, input().split()))
print(2 + (arr1[2] ^ min(arr1)))


n = int(input())
a = [int(p) for p in input().split()]
print(2 + (a[2] ^ min(a)))


s = int(input())
input_array = input()
list = [int(i) for i in input_array.split(' ')]
x = 2 + (list[2] ^ min(list))
print(x)


import sys, math, queue
sys.setrecursionlimit(1000000)
n = int(input())
a = list(map(int, input().split()))
print((a[2] ^ min(a)) + 2)