One day, as Sherlock Holmes was tracking down one very important criminal, he found a wonderful painting on the wall. This wall could be represented as a plane. The painting had several concentric circles that divided the wall into several parts. Some parts were painted red and all the other were painted blue. Besides, any two neighboring parts were painted different colors, that is, the red and the blue color were alternating, i. e. followed one after the other. The outer area of the wall (the area that lied outside all circles) was painted blue. Help Sherlock Holmes determine the total area of red parts of the wall.

Let us remind you that two circles are called concentric if their centers coincide. Several circles are called concentric if any two of them are concentric.

Input

The first line contains the single integer n (1 ≤ n ≤ 100). The second line contains n space-separated integers ri (1 ≤ ri ≤ 1000) — the circles' radii. It is guaranteed that all circles are different.

Output

Print the single real number — total area of the part of the wall that is painted red. The answer is accepted if absolute or relative error doesn't exceed 10 - 4.

Examples

Input

1
1


Output

3.1415926536


Input

3
1 4 2


Output

40.8407044967

Note

In the first sample the picture is just one circle of radius 1. Inner part of the circle is painted red. The area of the red part equals π × 12 = π.

In the second sample there are three circles of radii 1, 4 and 2. Outside part of the second circle is painted blue. Part between the second and the third circles is painted red. Part between the first and the third is painted blue. And, finally, the inner part of the first circle is painted red. Overall there are two red parts: the ring between the second and the third circles and the inner part of the first circle. Total area of the red parts is equal (π × 42 - π × 22) + π × 12 = π × 12 + π = 13π

Difficulty: EASY
Tags: Geometry

Sorting
Skill types: Sorting

Starter code:

Solutions:
n = int(input())
s = 0
X = [int(x) for x in input().split(' ')]
X.sort(reverse=True)
for i in range(n):
	s = s + (-1) ** i * X[i] * X[i]
print(3.1415926536 * s)


from math import pi
n = int(input())
arr = [int(x) for x in input().split()]
arr.append(0)
arr.sort()
ans = 0
if n % 2 == 0:
	for i in range(2, len(arr), 2):
		ans += pi * arr[i] ** 2 - pi * arr[i - 1] ** 2
else:
	for i in range(1, len(arr), 2):
		ans += pi * arr[i] ** 2 - pi * arr[i - 1] ** 2
print(f'{ans:.5f}')


from math import pi
n = int(input())
r = sorted(list(map(int, input().split(' '))))
ans = 0
k = 1
for i in r:
	ans += k * i * i
	k *= -1
print(pi * abs(ans))


from math import pi
n = int(input())
l = sorted(list(map(int, input().split())))
r = 0
k = 0
if n % 2 != 0:
	k = 1
	r += l[0] ** 2
for i in range(k, n, 2):
	r += abs(l[i] ** 2 - l[i + 1] ** 2)
print(round(r * pi, 10))


import math
p = math.pi
n = int(input())
r = list(map(int, input().split()))
r.sort()
c = 1
a = 0
for i in range(n - 1, -1, -1):
	if c == 1:
		a = a + p * r[i] * r[i]
		c = -1
	else:
		a = a - p * r[i] * r[i]
		c = 1
print(a)


import math
qtd_circulos = int(input())
soma = 0
areas = [int(v) for v in input().split()]
areas.sort(reverse=True)
for i in range(qtd_circulos):
	if i % 2 == 0:
		soma += int(areas[i]) ** 2
	if i % 2 != 0:
		soma -= int(areas[i]) ** 2
print(round(math.pi * soma, 10))


n = int(input())
import math
r = list(map(int, input().split()))
d = 0
b = 0
r.sort()
for i in range(n):
	if i % 2 == 0:
		d += r[i] ** 2
	else:
		b += r[i] ** 2
print(abs(d * math.pi - b * math.pi))


n = int(input())
arr = [int(x) for x in input().split()]
arr.sort()
arr = arr[::-1]
pi = 3.1415926536
ans = 0
for i in range(n):
	if i & 1 == 0:
		ans += arr[i] * arr[i]
	else:
		ans -= arr[i] * arr[i]
ans = pi * ans
print('{0:.10f}'.format(ans))


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
import copy
import time
starttime = time.time()
mod = int(pow(10, 9) + 7)
mod2 = 998244353

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

def out(*var, end='\n'):
	sys.stdout.write(' '.join(map(str, var)) + end)

def L():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
try:
	sys.stdin = open('input.txt', 'r')
except:
	pass
n = L()[0] + 1
A = [0] + sorted(L())
ans = 0
for i in range(n - 1, 0, -2):
	ans += pi * (A[i] ** 2 - A[i - 1] ** 2)
print(ans)
endtime = time.time()


from math import pi
n = int(input())
a = sorted(list(map(int, input().split())))
area = 0
for i in range(n):
	if i % 2 == 0:
		area += pi * a[i] * a[i]
	else:
		area -= pi * a[i] * a[i]
print(abs(area))


input()
l = sorted(map(int, input().split()))
t = 1
total = 0
pi = 3.1415926536
for i in l:
	total += pi * i ** 2 * t
	t *= -1
print(abs(total))


import math
n = int(input())
r = list(map(int, input().rstrip().split()))
r.sort()
ans = 0
if n % 2 == 1:
	for i in range(n):
		if i % 2 == 0:
			ans += math.pow(r[i], 2)
		else:
			ans -= math.pow(r[i], 2)
else:
	for i in range(n):
		if i % 2 == 0:
			ans -= math.pow(r[i], 2)
		else:
			ans += math.pow(r[i], 2)
print(ans * 3.1415926536)


pi = 3.141592653589793
a = int(input())
l = []
b = input().split()
for i in range(a):
	t = int(b[i])
	l.append(t)
l.sort()
l.reverse()
p = 0
for i in range(a):
	if i % 2 == 0:
		p = p + l[i] * l[i]
	else:
		p = p - l[i] * l[i]
print(p * pi)


pi = 3.1415926536
n = int(input())
l = input().split()
for i in range(n):
	l[i] = int(l[i])
l.sort()
s = 0
i = n - 1
while i > 0:
	s += (l[i] - l[i - 1]) * (l[i] + l[i - 1])
	i -= 2
if i == 0:
	s += l[0] * l[0]
print(pi * s)


import sys, math

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

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

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

def rinput():
	return map(int, tinput())

def rlinput():
	return list(rinput())
n = iinput()
A = rlinput()
A.sort()
prev = 0
ans = 0
if n % 2 != 0:
	for i in range(n):
		if i % 2 == 0:
			ans += math.pi * math.pow(A[i], 2) - prev
		else:
			prev = math.pi * math.pow(A[i], 2)
else:
	for i in range(n):
		if i % 2 != 0:
			ans += math.pi * math.pow(A[i], 2) - prev
		else:
			prev = math.pi * math.pow(A[i], 2)
print(ans)


n = int(input())
a = list(map(int, input().split()))[:n]
a.sort()
red = 0
blue = 0
for i in range(0, len(a)):
	if i % 2 == 0:
		red += a[i] * a[i]
	else:
		blue += a[i] * a[i]
red *= 3.1415926536
blue *= 3.1415926536
print(abs(red - blue))


from functools import reduce
import math
n = int(input())
l = list(map(int, input().split()))
if n == 1:
	print('{:.10f}'.format(math.pi * l[0] * l[0]))
else:
	l.sort()
	a = l[::2]
	b = l[1::2]
	y = b[-1] * b[-1]
	x = a[-1] * a[-1]
	b = list(map(lambda x: x ** 2, b))
	a = list(map(lambda x: x ** 2, a))
	if n % 2 == 0:
		ans = math.pi * sum(b) - math.pi * sum(a)
		print('{:.10f}'.format(ans))
	else:
		ans2 = math.pi * sum(a) - math.pi * sum(b)
		print('{:.10f}'.format(ans2))


import math

def solve(lst):
	res = 0
	lst.sort()
	for i in range(len(lst) - 1, -1, -2):
		if i == 0:
			res += lst[i] ** 2 * math.pi
		else:
			res += (lst[i] ** 2 - lst[i - 1] ** 2) * math.pi
	return res
n = input()
nums = list(map(int, input().split()))
print(solve(nums))


import math
alph = 'abcdefghijklmnopqrstuvwxyz'
n = int(input())
r = list(map(int, input().split()))
r.sort(reverse=True)
E = 0
for i in range(n):
	if i % 2 == 0:
		if i != n - 1:
			E += r[i] ** 2 * math.pi - math.pi * r[i + 1] ** 2
		else:
			E += r[i] ** 2 * math.pi
print('%.12f' % E)


import math
n = int(input())
a = list(map(int, input().split()))
a.sort(reverse=True)
area = 0
for i in range(n):
	if i % 2 == 0:
		area += math.pi * a[i] ** 2
	else:
		area -= math.pi * a[i] ** 2
print(area)


from sys import stdin, stdout
ii1 = lambda : int(stdin.readline().strip())
is1 = lambda : stdin.readline().strip()
iia = lambda : list(map(int, stdin.readline().strip().split()))
isa = lambda : stdin.readline().strip().split()
mod = 1000000007
from math import pi
n = ii1()
arr = sorted([0] + iia())
res = 0
if n < 2:
	res = arr[1] ** 2
else:
	for i in range(n, 0, -2):
		if i > 0:
			res += arr[i] ** 2 - arr[i - 1] ** 2
print(pi * res)


from math import pi
input()
s = 0
odd = True
for r in sorted(map(int, input().split()), reverse=True):
	s += r * r if odd else -r * r
	odd ^= True
print(pi * s)


n = int(input())
s = list(sorted(list(map(int, input().split()))))[::-1]
s.append(0)
import math
print(math.pi * sum([s[i] ** 2 - s[i + 1] ** 2 for i in range(0, n, 2)]))


n = int(input())
s = list(map(int, input().split()))
s.sort()
r = 0
for i in range(len(s)):
	if i % 2 == 0:
		r += 3.141592653589 * s[i] ** 2
	else:
		r -= 3.141592653589 * s[i] ** 2
if r < 0:
	r = -1 * r
print('%.10f' % r)


from sys import stdin, stdout
from math import pi
intn = lambda : int(stdin.readline())
strs = lambda : stdin.readline()[:-1]
lstr = lambda : list(stdin.readline()[:-1])
mint = lambda : map(int, stdin.readline().split())
lint = lambda : list(map(int, stdin.readline().split()))
out = lambda x: stdout.write(str(x) + '\n')
out_ = lambda x: stdout.write(str(x) + ' ')

def main():
	n = intn()
	a = sorted(lint(), reverse=True)
	area = 0
	for i in range(n):
		if i & 1:
			area -= pi * a[i] * a[i]
		else:
			area += pi * a[i] * a[i]
	out(area)
main()


from functools import reduce
num = str(input())
s = list(map(lambda t: int(t) ** 2, str(input()).split(' ')))
s.sort(reverse=True)
for i in range(1, len(s), 2):
	s[i] = -s[i]
res = reduce(lambda x, y: x + y, s)
print(res * 3.14159265)


import math
n = int(input())
radios = [int(x) for x in input().split()]
isRed = len(radios) % 2 != 0
result = 0
radios.sort()
for radio in radios:
	area = math.pi * radio * radio
	result += area if isRed else -area
	isRed = not isRed
print(result)


import math
n = int(input())
radii = list(map(int, input().split()))
radii.sort()
result = 0
counter = 0
if n % 2 == 1:
	result += abs(math.pi * radii[0] ** 2)
	counter += 2
else:
	counter += 1
try:
	while True:
		r2 = radii[counter]
		r1 = radii[counter - 1]
		result += abs(math.pi * (r2 ** 2 - r1 ** 2))
		counter += 2
except IndexError:
	print(result)


import math

def solve():
	n = int(input())
	a = [int(x) for x in input().split()]
	a.sort(reverse=True)
	a += [0]
	ans = 0
	for i in range(0, n, 2):
		ans += math.pi * (a[i] * a[i] - a[i + 1] * a[i + 1])
	print(ans)
solve()


import math
n = int(input())
r = [int(i) for i in input().split()]
r.sort(reverse=True)
counter = 0
red = 0
while counter < n - 1:
	red += r[counter] ** 2 - r[counter + 1] ** 2
	counter += 2
if counter == n - 1:
	red += r[counter] ** 2
print(red * math.pi)


n = int(input())
l = list(map(int, input().split()))
l.sort()
l.reverse()
s_r = 0
s_b = 0
pie = 3.1415926536
for i in range(len(l)):
	if i % 2 == 0:
		s_r = s_r + pie * l[i] ** 2
	else:
		s_b = s_b + pie * l[i] ** 2
print(s_r - s_b)


from math import pi as p
n = int(input())
l = list(map(int, input().split()))
l.sort()
a = 0
s = 1 if n % 2 else 0
for i in range(s, n - 1, 2):
	a += abs(l[i] * l[i] - l[i + 1] * l[i + 1])
if n % 2:
	a += l[0] * l[0]
print(a * p)


n = int(input())
l = list(map(int, input().split()))
l.sort()
a = 0
pi = 3.14159265359
for i in range(n):
	if (i + 1) % 2 == 1:
		a += pi * l[i] ** 2
	else:
		a -= pi * l[i] ** 2
if a < 0:
	a *= -1
print(a)


n = int(input())
temparr = input()
temparr = temparr.split()
arr = []
for i in temparr:
	arr.append(int(i))
arr = sorted(arr)
arr = arr[::-1]
ans = 0
for (j, i) in enumerate(arr):
	if j & 1 == 0:
		ans += i * i
	else:
		ans -= i * i
print(ans * 3.1415926536)


from math import pi
n = int(input())
r = list(map(float, input().split()))
r.sort(reverse=True)
s = 0
for i in range(n):
	s += r[i] ** 2 * (-1) ** i
print(pi * s)


from math import *
n = int(input())
arr = list(map(int, input().split()))
arr.sort()
ans = 0
for i in range(n - 1, -1, -2):
	if i == 0:
		ans += pi * arr[0] ** 2
	else:
		ans += pi * (arr[i] ** 2 - arr[i - 1] ** 2)
print(round(ans, 10))


import math
n = int(input())
flag = 0
c = list(map(int, input().split()))
if n == 1:
	print(math.pi * c[0] * c[0])
else:
	tot = 0.0
	c = sorted(c)[::-1]
	for i in range(len(c)):
		if flag == 0:
			tot += math.pi * c[i] * c[i]
			flag = 1
		else:
			tot -= math.pi * c[i] * c[i]
			flag = 0
	print(tot)


try:
	import math
	n = int(input())
	r = list(map(int, input().split()))
	r.sort()
	sum = 0
	k = 1
	for i in r:
		sum += k * i * i
		k *= -1
	print(math.pi * abs(sum))
except:
	pass


pi = 3.1415926536
n = int(input())
t = input()
if n == 1:
	print(pi * int(t) ** 2)
else:
	li = []
	for x in t.split():
		li.append(int(x))
	li = sorted(li)
	if n % 2 == 0:
		result = 0
		for i in range(1, n):
			if i % 2 != 0:
				result += pi * (li[i] ** 2 - li[i - 1] ** 2)
	else:
		result = pi * li[0] ** 2
		for i in range(2, n):
			if i % 2 == 0:
				result += pi * (li[i] ** 2 - li[i - 1] ** 2)
	print(result)


import math

def get_total_area(l):
	l.sort()
	if len(l) == 1:
		return math.pi * l[0] ** 2
	total_area = 0
	for i in range(len(l) - 1, 0, -2):
		total_area += l[i] ** 2 * math.pi - l[i - 1] ** 2 * math.pi
	if len(l) % 2 != 0:
		total_area += l[0] ** 2 * math.pi
	return total_area
n = input()
areas = list(map(int, input().split()))
print(get_total_area(areas))


num = int(input())
arr = [0] * num
arr = input().split()
for i in range(num):
	arr[i] = int(arr[i])
arr.sort()
if num % 2 == 1:
	final = 0
	for i in range(0, num, +2):
		if i == 0:
			final = final + arr[i] ** 2
		else:
			final = final + (arr[i] ** 2 - arr[i - 1] ** 2)
	print(final * 3.1415926536)
else:
	final = 0
	for i in range(1, num, +2):
		final = final + (arr[i] ** 2 - arr[i - 1] ** 2)
	print(final * 3.1415926536)


n = int(input())
r = list(map(int, input().split()))
r = sorted(r)[::-1]
pi = 3.1415926536
area = 0
for i in range(n):
	if i % 2 == 0:
		area += pi * r[i] * r[i]
	else:
		area -= pi * r[i] * r[i]
print(area)


from math import pi, pow

def area(x):
	return pi * pow(x, 2)
n = int(input())
raios = sorted(list(map(int, input().split(' '))))
soma = 0
idc = n - 1
while True:
	if idc > 0:
		soma += area(raios[idc]) - area(raios[idc - 1])
		idc -= 2
		continue
	if idc == 0:
		soma += area(raios[idc])
	break
print(f'{soma:.10f}')


a = int(input())
import math
b = list(map(int, input().split()))
b.sort()
if len(b) % 2 == 1:
	l = [b[i + 1] * b[i + 1] * math.pi - b[i] * b[i] * math.pi for i in range(len(b[1:])) if i % 2 == 1]
	c = round(b[0] * b[0] * math.pi + sum(l), 10)
else:
	l = [b[i] * b[i] * math.pi - b[i - 1] * b[i - 1] * math.pi for i in range(len(b)) if i % 2 == 1]
	c = round(sum(l), 10)
print(c)


import math
n = int(input())
a = sorted(list(map(int, input().split())))
pi = math.pi
ans = 0
if n % 2 == 0:
	for i in range(n):
		if i % 2 == 0:
			ans -= a[i] ** 2 * pi
			continue
		ans += a[i] ** 2 * pi
else:
	for i in range(n):
		if i % 2 != 0:
			ans -= a[i] ** 2 * pi
			continue
		ans += a[i] ** 2 * pi
print(ans)


import math
Tau = math.acos(-1) * 2
n = int(input())
arr = list(map(int, input().split()))
arr.sort()
area = 0
for i in range(n):
	if (n - i - 1) % 2 == 0:
		area += arr[i] * arr[i] * Tau / 2
	else:
		area -= arr[i] * arr[i] * Tau / 2
print('%.13f' % area)


import os
import sys
from io import BytesIO, IOBase
import math

def main():
	pass
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()
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
import math

def area(a, b):
	return
n = int(input())
l = list(map(int, input().rstrip().split()))
l.sort(reverse=True)
j = 0
ans = 0
if n == 1:
	print(math.pi * l[0] ** 2)
else:
	while j < n:
		if j == n - 1:
			ans += math.pi * l[n - 1] ** 2
		else:
			ans += math.pi * (l[j] ** 2 - l[j + 1] ** 2)
		j += 2
	print(ans)


import math
t = int(input())
n = list(map(float, input().split()))
n.sort()
n = n[::-1]
s = 0
for i in range(0, t - 1, 2):
	s = s + (n[i] ** 2 - n[i + 1] ** 2)
if t % 2 == 0:
	print(math.pi * s)
else:
	print(math.pi * (s + n[t - 1] ** 2))


import math
n = int(input())
arr1 = list(map(int, input().split()))
c = 0
arr1.sort()
for i in range(len(arr1)):
	if i % 2 == 1:
		c -= arr1[i] ** 2
	else:
		c += arr1[i] ** 2
print(math.pi * abs(c))


from math import pi
input()
a = sorted(map(int, input().split()), reverse=True)
print(sum(map(lambda x: pi * a[x] ** 2 * (-1) ** x, range(len(a)))))


import math
n = int(input())
arr = list(map(int, input().split()))
arr.sort()
sol = 0
i = 0
while len(arr) > 0:
	ele = arr.pop(-1)
	if i % 2 == 0:
		sol += math.pi * ele ** 2
	else:
		sol -= math.pi * ele ** 2
	i += 1
print(sol)


import math
n = int(input())
R = list(map(int, input().split()))
R.sort()
area_red = 0
area_blue = 0
for i in range(n - 1, -1, -2):
	area_red += math.pi * R[i] * R[i]
for i in range(n - 2, -1, -2):
	area_blue += math.pi * R[i] * R[i]
print(abs(area_blue - area_red))


import sys
import math

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

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

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

def get_list():
	return list(map(int, sys.stdin.readline().strip().split()))
mod = int(1000000000.0) + 7
pi = math.pi
n = iinput()
r = get_list()
r.sort()
ans = 0
i = n - 1
while i > 0:
	ans += pi * (r[i] ** 2 - r[i - 1] ** 2)
	i -= 2
if n % 2 == 1:
	ans += pi * r[0] ** 2
print(ans)


from math import pi
n = input()
liste = input().split(' ')
liste = [int(radius) for radius in liste]
liste.sort(reverse=True)
area = 0
for i in range(len(liste)):
	area += -1 * (i % 2 * 2 - 1) * liste[i] ** 2
area *= pi
print(area)


import math
a = int(input())
v = [int(i) for i in input().split()]
res1 = 0
res2 = 0
for i in range(a):
	v = sorted(v, reverse=True)
	if i % 2 == 0:
		res1 += v[i] * v[i]
	else:
		res2 += v[i] * v[i]
res = res1 - res2
print(res * math.pi)


import math

def circleArea(r):
	return r * r * math.pi
n = int(input())
elements = list(map(int, input().strip().split()))
elements.sort(reverse=True)
totA = 0
for index in range(0, len(elements)):
	if (index + 1) % 2 == 0:
		totA -= circleArea(elements[index])
	elif (index + 1) % 2 != 0:
		totA += circleArea(elements[index])
print(totA)


__author__ = '7877'

def solve():
	from math import pi
	n = int(input())
	rdl = list(map(int, input().split()))
	max_rad = 0
	for i in rdl:
		max_rad = max(max_rad, i)
	red_area = 0.0
	cur = 1
	for i in range(len(rdl)):
		red_area += max_rad ** 2 * pi * cur
		rdl[rdl.index(max_rad)] = -1
		max_rad = 0
		cur *= -1
		for j in rdl:
			max_rad = max(max_rad, j)
	print(red_area)
solve()


from math import pi
n = int(input())
a = list(map(int, input().split()))
a.sort()
for i in range(len(a) - 2, -1, -2):
	a[i] *= -1
print(sum((pi * x * x * (-1 if x < 0 else 1) for x in a)))


from math import pi
n = int(input())
r = sorted(map(int, input().split()))
a = 0
if n % 2 == 1:
	a += r.pop(0) ** 2
while r:
	(x, y) = (r.pop(0), r.pop(0))
	a += (y - x) * (y + x)
print(a * pi)


n = int(input())
x = list(map(int, input().split()))
x.sort(reverse=True)
l = len(x)
s = 0
for (i, j) in enumerate(x):
	if i % 2 == 0:
		s += j * j
	else:
		s -= j * j
print(s * 3.1415926536)


(n, r, ans) = (int(input()), sorted(list(map(int, input().split())))[::-1], 0)
for i in range(n):
	ans = ans + (1 if i % 2 == 0 else -1) * r[i] ** 2
print('%.20f' % (ans * 3.141592653589793))


n = int(input())
str = input()
ls = [int(u) for u in str.split()]
ls.sort()
ans = 0
for i in range(0, len(ls)):
	if i % 2 == 0:
		ans += ls[i] ** 2
	else:
		ans -= ls[i] ** 2
ans *= 3.1415926535
print(abs(ans))


import math
N = int(input())
x = input().split()
for i in range(len(x)):
	x[i] = int(x[i])
x = sorted(x, reverse=True)
answer = 0
for i in range(len(x)):
	t = int(x[i])
	if i % 2 == 0:
		answer += t ** 2 * math.pi
	else:
		answer -= t ** 2 * math.pi
print(answer)


n = int(input())
nums = list(map(int, input().split()))
ans = 0
pi = 3.1415926536
sinal = True
nums.sort(reverse=True)
for e in nums:
	if sinal:
		ans += pi * e ** 2
		sinal = False
	else:
		ans -= pi * e ** 2
		sinal = True
print('%.10f' % ans)


from sys import stdin, stdout, exit
from math import pi
n = int(stdin.readline().rstrip())
l = list(map(int, stdin.readline().split()))
l.sort(reverse=True)
s = 0
for i in range(n):
	if i % 2 == 0:
		s += pow(l[i], 2)
	else:
		s -= pow(l[i], 2)
print(pi * s)


from math import pi
n = int(input())
L = list(map(int, input().split()))
L.sort(reverse=True)
ans = 0
for i in range(0, n, 2):
	if i == n - 1:
		ans += pi * (L[i] * L[i])
	else:
		ans += pi * (L[i] * L[i] - L[i + 1] * L[i + 1])
print(ans)


from math import pi
n = int(input())
radiuses = sorted(list(map(int, input().split())), reverse=True)

def area(r):
	return pi * r ** 2
if n == 1:
	print(area(radiuses[0]))
	exit()
total = 0
for i in range(1, n, 2):
	total += area(radiuses[i - 1]) - area(radiuses[i])
if n % 2 != 0:
	total += area(radiuses[n - 1])
print(total)


import math
circulos = int(input())
raios = input().split()
for i in range(len(raios)):
	raios[i] = int(raios[i])
raios.sort()
resposta = 0
cont = 0
for i in range(len(raios) - 1, -1, -1):
	if cont % 2 == 0:
		resposta += math.pi * raios[i] ** 2
	else:
		resposta -= math.pi * raios[i] ** 2
	cont += 1
print(resposta)


from sys import stdin, stdout
from math import pi
n = int(stdin.readline())
values = sorted(list(map(int, stdin.readline().split())), reverse=True)
ans = 0
for i in range(n):
	if not i % 2:
		ans += values[i] ** 2
	else:
		ans -= values[i] ** 2
stdout.write(str(pi * ans))


a = int(input())
s = sorted(list(map(int, input().split())))
d = 0
f = 1
if a % 2 != 0:
	s.append(0)
s.reverse()
sum1 = 0
while d < a:
	sum1 += s[d] ** 2 * 3.141592 - s[f] ** 2 * 3.141592
	d += 2
	f += 2
print(abs(sum1))


import sys
from math import pi
f = sys.stdin
n = int(f.readline())
r = [int(i) for i in f.readline().strip().split()]
r.sort()
r.insert(0, 0)
res = 0
for i in range(-1, -len(r), -2):
	res += r[i] ** 2 - r[i - 1] ** 2
print(res * pi)


import sys

def fastio():
	from io import StringIO
	from atexit import register
	global input
	sys.stdin = StringIO(sys.stdin.read())
	input = lambda : sys.stdin.readline().rstrip('\r\n')
	sys.stdout = StringIO()
	register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()

def debug(*var, sep=' ', end='\n'):
	print(*var, file=sys.stderr, end=end, sep=sep)
INF = 10 ** 20
MOD = 10 ** 9 + 7
I = lambda : list(map(int, input().split()))
from math import gcd
from math import ceil, pi
from collections import defaultdict as dd, Counter
from bisect import bisect_left as bl, bisect_right as br

def get(x):
	return pi * x ** 2
(n,) = I()
r = I()
r.sort()
area = 0
for i in range(n - 1, -1, -2):
	if i - 1 < 0:
		area += get(r[0])
		break
	area += get(r[i]) - get(r[i - 1])
print(area)


n = int(input())
arr = list(map(int, input().split()))
redArea = 0
blueArea = 0
pi = 3.1415926536
arr.sort()
for i in range(n):
	if i % 2 == 0:
		redArea += arr[i] * arr[i] * pi
	else:
		blueArea += arr[i] * arr[i] * pi
if blueArea >= redArea:
	print(blueArea - redArea)
else:
	print(redArea - blueArea)


import math
n = int(input())
r = [int(x) for x in input().split()]
r = sorted(r, reverse=True)
i = 0
area_sum = 0
while i < len(r) - 1:
	area_sum += r[i] ** 2 - r[i + 1] ** 2
	i += 2
if len(r) % 2 != 0:
	area_sum += r[len(r) - 1] ** 2
else:
	pass
print(area_sum * 3.141592653589793)


import math
input()
l = sorted(list((int(i) * int(i) for i in input().split())))
print(math.pi * (sum(l[::-2]) - sum(l[-2::-2])))


n = int(input())
lis = list(map(int, input().split()))
lis.sort()
pi = 3.1415926536
reds = []
blues = []
for (i, j) in enumerate(lis):
	if i % 2 == 0:
		reds.append(j)
	else:
		blues.append(j)
reds = [x ** 2 for x in reds]
blues = [x ** 2 for x in blues]
print(abs((sum(reds) - sum(blues)) * pi))


from math import pi
n = int(input())
arr = [int(i) for i in input().strip().split()]
arr.sort(reverse=True)
if n % 2 != 0:
	arr.append(0)
ans = 0
for i in range(0, len(arr), +2):
	ans += arr[i] ** 2 - arr[i + 1] ** 2
print(pi * ans)


import math
x = int(input())
l = sorted(list(map(int, input().split())))
area = 0
if x % 2 == 0:
	num = 1
	while num < x:
		area += abs(math.pi * l[num - 1] ** 2 - math.pi * l[num] ** 2)
		num += 2
	print(area)
else:
	num = 2
	while num < x:
		area += abs(math.pi * l[num - 1] ** 2 - math.pi * l[num] ** 2)
		num += 2
	print(area + math.pi * l[0] ** 2)


import math
n = int(input())
l = list(map(int, input().split()))
l.sort()
if n % 2 != 0:
	d = l[0] ** 2
	a = 1
else:
	a = 0
	d = 0
for i in range(a, n - 1, 2):
	d = d + (l[i + 1] ** 2 - l[i] ** 2)
print(d * math.pi)


import math
n = int(input())
a = [int(x) for x in input().split()]
a.sort(reverse=True)
area = 0
mult = 1
for i in range(0, n):
	area += mult * a[i] ** 2
	mult *= -1
print(area * math.pi)


import math
n = int(input())
l_s = list(map(int, input().split()))
l_s.sort(reverse=True)
t = 0
for index in range(n):
	t += (-1 if index % 2 == 1 else 1) * l_s[index] ** 2
print(t * math.pi)


import math
n = int(input())
r = [int(x) for x in input().split()]
spaces = [math.pi * rad ** 2 for rad in sorted(r)[::-1]]
print(sum(spaces[::2]) - sum(spaces[1::2]))


import math
a = int(input())
k = sorted(list(map(int, input().split())))
c = 0
for i in range(len(k)):
	if i % 2 == 0:
		c += k[i] ** 2
	else:
		c -= k[i] ** 2
print(abs(c * math.pi))


from math import pi
n = int(input())
tl = list(map(int, input().split()))
tl.sort()
print(pi * sum([(-1) ** ((n - i - 1) % 2) * tl[i] ** 2 for i in range(n)]))


from math import *
n = int(input())
s = list(map(int, input().rsplit()))
s.sort(reverse=True)
a = 0
if n % 2 != 0:
	a = pi * s[n - 1] ** 2
for i in range(0, n, 2):
	a = a + pi * (s[i] ** 2 - s[i - 1] ** 2)
print(a)


import math
n = int(input())
a = list(map(int, input().split(' ')))
a.sort()
ans = 0
if n % 2 == 0:
	for i in range(len(a)):
		if i % 2 == 0:
			ans -= a[i] ** 2
		else:
			ans += a[i] ** 2
else:
	for i in range(len(a)):
		if i % 2 == 0:
			ans += a[i] ** 2
		else:
			ans -= a[i] ** 2
print(math.pi * ans)


pai = 3.1415926536
n = eval(input())
a = list(map(eval, input().split()))
a.sort()
a = a[::-1]
b = 0
c = 0
for i in range(n):
	b += a[i] ** 2 * (-1) ** c
	c = c ^ 1
print(b * pai)


from math import pi
(n, s) = (int(input()), 0)
t = list(map(int, input().split()))
t.sort(reverse=True)
for i in t:
	s = -(s + i * i)
print(abs(s) * pi)


import math
n = int(input())
L = list(map(int, input().split()))
L = sorted(L)
suma = 0
if n % 2:
	suma += L[0] ** 2 * math.pi
	L = L[1:]
for k in range(1, len(L), 2):
	suma += (L[k] ** 2 - L[k - 1] ** 2) * math.pi
print('{0:.10f}'.format(suma))


input()
s = sorted(map(lambda x: int(x) ** 2, input().split()))
print(abs(sum(s[::2]) - sum(s[1::2])) * 3.1416)


from math import pi
n = int(input())
sum = 0
arr = list(map(int, input().split()))
arr = sorted(arr)
for i in range(0, len(arr)):
	if i % 2 == 1:
		sum -= arr[i] * arr[i]
	else:
		sum += arr[i] * arr[i]
print(pi * abs(sum))


from math import pi

def main():
	n = int(input())
	l = sorted(map(int, input().split()))
	sign = (-1, 1)[len(l) & 1]
	res = 0
	for r in l:
		res += r * r * sign
		sign *= -1
	print(res * pi)
main()


import sys
import os
from bisect import bisect_right as br
from bisect import bisect_left as bl
from io import IOBase, BytesIO
import heapq
import math
import collections
import itertools
import bisect
from sys import stdin, stdout
mod = 10 ** 9 + 7
pie = 3.1415926536

def modinv(n, p):
	return pow(n, p - 2, p)

def ncr(n, r, p):
	t = fact[n] * (ifact[r] * ifact[n - r] % p) % p
	return t

def ain():
	return list(map(int, sin().split()))

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

def GCD(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def readIntArray(size):
	arr = []
	for i in range(0, size):
		temp = int(sin().split())
		arr.append(temp)
	return arr

def readStringArray(size):
	return list(map(str, input().strip().split()))[:size]

def readFloatArray(size):
	return list(map(float, input().strip().split()))[:size]

def read2DIntArray(row, col):
	return [[int(input()) for x in range(col)] for y in range(row)]

def read2DStringArray(row, col):
	return [[str(input()) for x in range(col)] for y in range(row)]

def read2DFloatArray(row, col):
	return [[float(input()) for x in range(col)] for y in range(row)]

def main():
	n = int(sin())
	arr = ain()
	arr = sorted(arr, reverse=True)
	area = 0
	for i in range(0, n, 2):
		if i == n - 1:
			area += pie * arr[i] ** 2
		else:
			area += pie * arr[i] ** 2 - pie * arr[i + 1] ** 2
	print(area)
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

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

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			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))

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


n = int(input())
l = sorted(list(map(int, input().split())))
tut = int(0)
for i in range(len(l)):
	if i % 2 == 0:
		tut += l[i] * l[i]
	else:
		tut -= l[i] * l[i]
tut = abs(tut)
print('{0:.10f}'.format(tut * 3.1415926536))


import math
a = int(input())
b = list(map(int, input().split()))
b.sort()
soma = 0
for i in range(-1, -a - 1, -1):
	if i % 2 == 1:
		soma += b[i] ** 2 * math.pi
	else:
		soma -= b[i] ** 2 * math.pi
print('%.10f' % soma)


n = int(input())
l = list(map(int, input().split()))
l.sort()
sums = 0
for i in reversed(range(n)):
	if i % 2 == 0:
		sums += l[i] ** 2
	else:
		sums -= l[i] ** 2
ans = sums * 3.1415926536
print(abs(ans))


from math import pi
n = int(input())
r = map(int, input().split())
t = sorted(r)
total = 0
for i in range(n):
	if n % 2 == 0:
		if i % 2 == 0:
			total -= pi * t[i] ** 2
		else:
			total += pi * t[i] ** 2
	elif i % 2 == 0:
		total += pi * t[i] ** 2
	else:
		total -= pi * t[i] ** 2
print(total)


from sys import stdin, stdout
s = int(stdin.readline())
lt = [int(x) ** 2 for x in stdin.readline().split()]
lt.sort()
aux = 0
if s % 2 == 0:
	aux = -1
else:
	aux = 1
ans = 0
for x in lt:
	ans = ans + aux * x
	aux *= -1
ans = 3.1415926536 * ans
stdout.write(str(ans))


def mi():
	return map(int, input().split())
n = int(input())
a = list(mi())
a.sort(reverse=True)
ans = 0
s = -1
from math import pi
for r in a:
	s *= -1
	ans += pi * r * r * s
print(ans)


from math import pi
n = int(input())
l = list(map(int, input().split()))
l.sort()
if n % 2 != 0:
	l.insert(0, 0)
print(sum(((l[i + 1] ** 2 - l[i] ** 2) * pi for i in range(len(l) - 2, -1, -2))))


import math
input()
a = sorted(list(map(int, input().split(' '))))
for i in range(len(a)):
	a[i] = a[i] ** 2
print(math.pi * (sum(a[::-2]) - sum(a[-2::-2])))


from math import pi
sqr = lambda x: x * x
n = int(input())
R = list(map(int, input().split()))
R.sort()
R.reverse()
red = []
blue = []
for i in range(n):
	if i % 2:
		red.append(-R[i])
	else:
		blue.append(R[i])
red = list(map(sqr, red))
blue = list(map(sqr, blue))
r = abs(sum(red) - sum(blue))
print(r * pi)


a = int(input())
r = []
b = []
x = sorted(list(map(int, input().split())))
for i in range(a):
	if i % 2 == 0:
		r.append(x[i])
	else:
		b.append(x[i])
pi = 3.1415926535
area = 0
for i in r:
	area += i ** 2 * pi
for i in b:
	area -= i ** 2 * pi
print(abs(area))


n = int(input())
radii = list(map(int, input().split()))
radii.sort()
radii.reverse()
r = 0
for (i, radius) in enumerate(radii):
	radius *= radius
	if i % 2 == 1:
		radius *= -1
	r += radius
import math
print(math.pi * r)


num = int(input())
c = 0
p = list(map(int, input().split()))
p.sort()
p.reverse()
k = 0
for i in p:
	if k == 0:
		c += i ** 2
		k = 1
	elif k == 1:
		c -= i ** 2
		k = 0
print(c * 3.141592653589793)


input()
L = sorted((int(x) * int(x) for x in input().split()))
print(3.1415926536 * (sum(L[::-2]) - sum(L[-2::-2])))


from math import pi
n = int(input())
l = list(map(int, input().split()))
x = [i * i for i in l]
x.sort(reverse=True)
c = 0
print(pi * (sum(x[::2]) - sum(x[1::2])))


from math import pi
input()
lst = [int(x) for x in input().split()]
lst.sort(reverse=True)
area = 0
l = len(lst)
for i in range(0, l, 2):
	area += lst[i] * lst[i]
for i in range(1, l, 2):
	area -= lst[i] * lst[i]
print(area * pi)


from math import *
n = int(input())
lista = [int(i) for i in input().split()]
lista.sort(reverse=True)
area = 0
tam = len(lista)
for r in lista:
	area += (-1) ** (tam - 1) * pi * r * r
	tam -= 1
print(abs(area))


n = int(input())
l = list(map(int, input().split()))
l.sort()
if n % 2 == 1:
	s = 3.1415926536 * l[0] ** 2
	for i in range(2, n, 2):
		s += 3.1415926536 * l[i] ** 2 - 3.1415926536 * l[i - 1] ** 2
else:
	s = 0
	for i in range(1, n, 2):
		s += 3.1415923536 * l[i] ** 2 - 3.1415923536 * l[i - 1] ** 2
print(s)


pi = 3.14159265359
soma = 0.0
n = int(input())
i = 0
x = input()
numeros = x.split(' ')
while i < n:
	numeros[i] = int(numeros[i])
	i = i + 1
if n % 2 == 0:
	flag = 1
else:
	flag = 0
numeros.sort()
i = n - 1
while i >= 0:
	if flag == 0:
		soma = soma + int(numeros[i]) ** 2 * pi
		flag = 1
	else:
		soma = soma - int(numeros[i]) ** 2 * pi
		flag = 0
	i = i - 1
if soma < 0:
	soma = soma * -1
print(soma)


import math
n = int(input())
pi = math.pi
l = list(map(int, input().split()))
l.sort(reverse=True)
ans = 0
for i in range(n):
	if i % 2 == 0:
		ans += pi * l[i] * l[i]
	else:
		ans -= pi * l[i] * l[i]
print(ans)


t = int(input())
r = list(map(int, input().split()))
import math
pi_value = math.pi
r.sort()
a = 0
rindex = [d for d in range(1, len(r), 2)]
for i in range(len(r)):
	if t % 2 == 0:
		if i in rindex:
			a += pi_value * r[i] ** 2 - pi_value * r[i - 1] ** 2
	if t % 2 != 0:
		if i not in rindex and i != 0:
			a += pi_value * r[i] ** 2 - pi_value * r[i - 1] ** 2
		if i == 0:
			a += pi_value * r[0] ** 2
print(a)


import math
input()
print(math.pi * sum((r ** 2 * (-1) ** i for (i, r) in enumerate(reversed(sorted(map(int, input().split())))))))


from math import pi
qtd_circulos = int(input())
compri_raios = list(map(int, input().split()))
compri_raios.sort()
area_total = 0
area_azul = 0
tamanho = len(compri_raios)
if tamanho % 2 == 0:
	for i in range(tamanho):
		if i % 2 != 0:
			area_total += pi * compri_raios[i] ** 2 - area_azul
		else:
			area_azul = pi * compri_raios[i] ** 2
else:
	for i in range(tamanho):
		if i % 2 != 0:
			area_azul = pi * compri_raios[i] ** 2
		else:
			area_total += pi * compri_raios[i] ** 2 - area_azul
print('%.10f' % area_total)


n = int(input())
a = sorted(list(map(float, input().split())))
a = a[::-1]
pi = 3.14159265359
ans = 0
for i in range(0, len(a), 1):
	if i % 2 == 1:
		ans -= pi * a[i] ** 2
	else:
		ans += pi * a[i] ** 2
print(ans)


import os
import gc
import sys
from io import BytesIO, IOBase
from collections import Counter
from collections import deque
import heapq
import math
import statistics

def sin():
	return input()

def ain():
	return list(map(int, sin().split()))

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

def iin():
	return int(sin())
MAX = float('inf')
MIN = float('-inf')
MOD = 1000000007

def readTree(n, m):
	adj = [deque([]) for _ in range(n + 1)]
	for _ in range(m):
		(u, v) = ain()
		adj[u].append(v)
		adj[v].append(u)
	return adj

def solve(d):
	xy = [MIN, MAX]
	for rt in d:
		if xy[0] > rt[1]:
			return -1
		if xy[1] < rt[0]:
			return -1
		xy[0] = max(xy[0], rt[0])
		xy[1] = min(xy[1], rt[1])
	return xy

def main():
	n = iin()
	a = ain()
	a.sort(reverse=True)
	i = 0
	area = 0
	if n > 1:
		while i < n - 1:
			area += math.pi * (a[i] ** 2 - a[i + 1] ** 2)
			i += 2
	if n & 1 == 1:
		area += math.pi * a[-1] * a[-1]
	print('%.10f' % area)
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')
main()


num = int(input())
li = list(map(int, input().split()))
odd = 0
even = 0
li.sort()
for i in range(len(li)):
	if i % 2 == 0:
		odd += 3.1415926536 * (li[i] * li[i])
	else:
		even += 3.1415926536 * (li[i] * li[i])
print(abs(odd - even))


from math import pi

def main():
	input()
	l = sorted(map(int, input().split()))
	sign = (1, 0)[len(l) & 1]
	print((sum((_ * _ for _ in l[sign::2])) - sum((_ * _ for _ in l[1 - sign::2]))) * pi)
main()


import math
n = int(input())
l1 = [int(x) for x in input().split()]
l1.sort()
area = 0
if n % 2 == 0:
	i = 1
	while i < n:
		area += l1[i] ** 2 - l1[i - 1] ** 2
		i += 2
else:
	i = 0
	while i < n:
		if i == 0:
			area += l1[i] ** 2
		else:
			area += l1[i] ** 2 - l1[i - 1] ** 2
		i += 2
print(round(area * math.pi, 10))


import sys
inf = float('inf')
(mod, MOD) = (1000000007, 998244353)
from math import ceil, floor, log, sqrt, factorial, pi

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

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

def input():
	return sys.stdin.readline().strip()
n = int(input())
Arr = get_array()
Arr.sort(reverse=True)
ans = 0
for i in range(n):
	if i % 2 == 0:
		ans += Arr[i] * Arr[i]
	else:
		ans -= Arr[i] * Arr[i]
print(ans * pi)


import math
n = int(input())
r = [int(x) for x in input().split()]
r.sort(reverse=True)
r.append(0)
ans = 0
i = 0
while i < n:
	ans += r[i] ** 2 - r[i + 1] ** 2
	i += 2
ans *= math.pi
print('{:.5f}'.format(ans))


import math
import itertools
import collections

def getdict(n):
	d = {}
	if type(n) is list:
		for i in n:
			if i in d:
				d[i] += 1
			else:
				d[i] = 1
	else:
		for i in range(n):
			t = ii()
			if t in d:
				d[t] += 1
			else:
				d[t] = 1
	return d

def cdiv(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 prime(n):
	if n == 2:
		return True
	if n % 2 == 0 or n <= 1:
		return False
	sqr = int(math.sqrt(n)) + 1
	for d in range(3, sqr, 2):
		if n % d == 0:
			return False
	return True

def rev(n):
	m = 0
	while n > 0:
		m = m * 10 + n % 10
		n = n // 10
	return m
n = ii()
r = sorted(li(), reverse=True)
ans = 0
for i in range(n):
	ans += r[i] ** 2 * (-1) ** i
print(ans * math.pi)


import math
n = int(input())
arr = list(map(int, input().split()))
p = math.pi
arr.sort()
ans = 0
if n % 2 == 1:
	for i in range(0, n, 2):
		if i >= 2:
			ans += arr[i] ** 2 - arr[i - 1] ** 2
		else:
			ans += arr[i] ** 2
else:
	for i in range(1, n, 2):
		ans += arr[i] ** 2 - arr[i - 1] ** 2
print(ans * p)


n = int(input())
a = list(map(int, input().split()))
from math import pi
a.sort(reverse=True)
p = []
m = []
s = 0
boolean = False
for i in a:
	boolean = not boolean
	if boolean:
		s += i * i
	else:
		s -= i * i
print(pi * s)


from math import *

def area(radi):
	return pow(radi, 2) * pi
N = int(input())
A = list(map(int, input().split()))
A.append(0)
A.sort()
ans = 0
cur = 0
for i in range(N, 0, -1):
	if cur == 1:
		cur = 0
	else:
		ans += area(A[i]) - area(A[i - 1])
		cur = 1
print(ans)


n = int(input())
m = input().split()
o = []
for x in m:
	y = int(x) * int(x)
	o.extend([y])
o = sorted(o)
z = 3.1415926536 * (sum(o[::-2]) - sum(o[-2::-2]))
print(z)


from math import pi
n = int(input())
arr = [0] + list(map(int, input().split()))
arr.sort(reverse=True)
res = 0
for i in range(0, n, 2):
	res += pi * (arr[i] * arr[i] - arr[i + 1] * arr[i + 1])
print(res)


n = int(input())
circle = list(map(int, input().split()))
circle.sort()
pi = 3.1415926536
ans = 0
if n % 2 == 1:
	for i in range(n):
		if (i + 1) % 2 == 1:
			ans += pi * circle[i] ** 2
		else:
			ans -= pi * circle[i] ** 2
else:
	for i in range(n):
		if (i + 1) % 2 == 1:
			ans -= pi * circle[i] ** 2
		else:
			ans += pi * circle[i] ** 2
print(ans)


def main():
	from sys import stdin, stdout
	import math
	n = int(stdin.readline())
	l = sorted(map(int, stdin.readline().split()))
	if n & 1:
		l = [0] + l
	area = 0
	for i in range(0, n, 2):
		area += l[i + 1] * l[i + 1] - l[i] * l[i]
	stdout.write(str(area * math.pi))
main()


import sys

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

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

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

def get_list():
	return list(map(int, sys.stdin.readline().strip().split()))
n = iinput()
a = get_list()
a.sort()
a = list(reversed(a))
s = 0
for i in range(n):
	if i % 2 == 0:
		s += a[i] ** 2
	else:
		s -= a[i] ** 2
print(s * 3.1415926536)


n = int(input())
circle = list((int(x) ** 2 for x in input().split()))
circle = sorted(circle)
pi = 3.1415926536
print(pi * (sum(circle[::-2]) - sum(circle[-2::-2])))


from __future__ import division, print_function
import math
import os
import sys
from sys import stdin, stdout
from io import BytesIO, IOBase
from itertools import accumulate
from collections import deque
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip
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')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def regularbracket(t):
	p = 0
	for i in t:
		if i == '(':
			p += 1
		else:
			p -= 1
		if p < 0:
			return False
	else:
		if p > 0:
			return False
		else:
			return True

def binarySearchCount(arr, n, key):
	left = 0
	right = n - 1
	count = 0
	while left <= right:
		mid = int((right + left) / 2)
		if arr[mid] <= key:
			count = mid + 1
			left = mid + 1
		else:
			right = mid - 1
	return count

def reverse1(string):
	pp = ''
	for i in string[::-1]:
		pp += i
	if pp == string:
		return True
	return False

def reverse2(list1):
	l = []
	for i in list1[::-1]:
		l.append(i)
	if l == list1:
		return True
	return False
import math

def mex(list1):
	p = max(list1) + 1
	for i in range(len(list1)):
		if list1[i] != i:
			p = i
			break
	return p

def main():
	n = int(input())
	arr = list(map(int, input().split()))
	arr = sorted(arr)
	p = 0
	if len(arr) % 2 != 0:
		c = math.pi * pow(arr[0], 2)
		arr.pop(0)
		i = 0
		p = 0
		while i < len(arr) - 1:
			p += math.pi * pow(arr[i + 1], 2) - math.pi * pow(arr[i], 2)
			i += 2
		print(p + c)
	else:
		i = 0
		while i < len(arr) - 1:
			p += math.pi * pow(arr[i + 1], 2) - math.pi * pow(arr[i], 2)
			i += 2
		print(p)
main()


n = int(input())
pi = 3.1415926536
r = sorted([int(i) for i in input().split()])[::-1]
t = 0
for (i, _) in enumerate(r):
	if i % 2 == 0:
		if not i == len(r) - 1:
			t += r[i] * r[i] - r[i + 1] * r[i + 1]
		else:
			t += r[i] * r[i]
print(pi * t)


n = int(input())
pie = 3.1415926536
arr = list(map(int, input().split()))
ans = 0.0
arr.sort()
cnt = 0
for i in range(n - 1, -1, -1):
	if cnt % 2 == 0:
		ans += arr[i] * arr[i] * pie
	else:
		ans -= arr[i] * arr[i] * pie
	cnt += 1
print(ans)


import sys
import math
sys.setrecursionlimit(100000)
input = sys.stdin.readline

def inp():
	return int(input())

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

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
n = inp()
ara = inara()
ara.sort(reverse=True)
ans = 0
for i in range(n):
	if i % 2 == 0:
		ans += math.pi * ara[i] * ara[i]
	else:
		ans -= math.pi * ara[i] * ara[i]
print(ans)


import sys
import math
x = 3.1415926536
n = int(input())
l = list(map(int, sys.stdin.readline().split()))
l.sort(reverse=True)
t = -1
s = 0
for i in l:
	s = s + t * -1 * i * i
	t = -1 * t
print(s * x)


n = int(input())
t = list(map(int, input().split()))
t.sort()
a = t[::-1]
o = 0
e = 0
import math
for k in range(1, n + 1):
	if k % 2 == 0:
		e += a[k - 1] ** 2
	else:
		o += a[k - 1] ** 2
print(round((o - e) * math.pi, 10))


from math import *
n = int(input())
v = [int(i) for i in input().split()]
if len(v) % 2 != 0:
	v.append(0)
v.sort()
res = 0
for i in range(1, n + 1, 2):
	res += v[i] ** 2 - v[i - 1] ** 2
print('%.10f' % (res * pi))


n = int(input())
a = list(map(int, input().split(' ')))
a.sort()
red_area = 0
for i in range(len(a)):
	if len(a) % 2 == 1:
		if i % 2 == 0:
			red_area = red_area + a[i] ** 2
		else:
			red_area = red_area - a[i] ** 2
	elif i % 2 == 1:
		red_area = red_area + a[i] ** 2
	else:
		red_area = red_area - a[i] ** 2
print(red_area * 3.1415926536)


import math
num_circles = int(input())
circles = input().split(' ')

def to_integer(circles):
	for i in range(num_circles):
		circles[i] = int(circles[i])

def calculate_area(circles):
	area = 0
	if num_circles % 2 == 1:
		for i in range(num_circles - 1, -1, -1):
			if i % 2 == 0:
				area += math.pi * circles[i] ** 2
			else:
				area -= math.pi * circles[i] ** 2
	else:
		for i in range(num_circles - 1, -1, -1):
			if i % 2 == 1:
				area += math.pi * circles[i] ** 2
			else:
				area -= math.pi * circles[i] ** 2
	print(area)
to_integer(circles)
circles.sort()
calculate_area(circles)


n = int(input())
radius = list(map(int, input().split()))
radius.sort(reverse=True)
area = 0
for i in range(n):
	if i % 2 == 0:
		area += radius[i] * radius[i]
	else:
		area -= radius[i] * radius[i]
print(area * 3.1415926536)


n = int(input())
a = list(map(int, input().split()))
a.append(0)
a.sort(reverse=True)
sum = 0
for i in range(n):
	if i % 2 == 0:
		sum += a[i] * a[i] - a[i + 1] * a[i + 1]
print(3.1415926536 * sum)


import math
n = int(input())
string = input()
radii = sorted(map(int, string.split()))[::-1]
a = 0
for x in range(n):
	a += radii[x] ** 2 * (-1) ** x
print(a * math.pi)


from collections import Counter, defaultdict
BS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'

def to_base(s, b):
	res = ''
	while s:
		res += BS[s % b]
		s //= b
	return res[::-1] or '0'
alpha = 'abcdefghijklmnopqrstuvwxyz'
from math import floor, ceil, pi
n = int(input())
nums = list(map(int, input().split()))
nums.sort(reverse=True)
tot = 0
switch = 1
for i in range(0, len(nums)):
	tot += pi * nums[i] ** 2 * switch
	switch = -1 if switch == 1 else 1
print(tot)


import sys
import math
import bisect

def main():
	n = int(input())
	A = list(map(int, input().split()))
	A.sort(reverse=True)
	ans = 0
	for i in range(n):
		if i % 2 == 0:
			ans += A[i] ** 2
		else:
			ans -= A[i] ** 2
	ans *= math.pi
	print('%.10f' % ans)
main()


from math import pi
n = int(input())
a = sorted(map(int, input().split()), reverse=True)
su = 0
for i in range(n):
	if i % 2 == 0:
		su += pi * a[i] * a[i]
	else:
		su -= pi * a[i] * a[i]
print(su)


pi = 3.1415926536
n = int(input())
l = list(map(int, input().split()))
l.sort(reverse=True)
ans = 0
if n % 2 == 0:
	for i in range(0, n - 1, 2):
		ans += pi * abs(l[i] ** 2 - l[i + 1] ** 2)
	print(ans)
else:
	ans = pi * l[-1] * l[-1]
	for i in range(0, n - 2, 2):
		ans += pi * abs(l[i] ** 2 - l[i + 1] ** 2)
	print(ans)


import math
I = input
n = int(I())
p = sorted(map(int, I().split()))[::-1]
print(sum(((1 - 2 * (i % 2)) * math.pi * p[i] ** 2 for i in range(n))))


import math
n = int(input())
d = sorted(list(map(int, input().split())), reverse=True)
r = 0
for i in range(n):
	if i % 2 == 0:
		r += math.pi * d[i] ** 2
	else:
		r -= math.pi * d[i] ** 2
print(r)


n = int(input())
l1 = [int(i) for i in input().split()]
l1.sort()
x = 3.1415926536
if n % 2 != 0:
	area = x * l1[0] ** 2
	for i in range(2, n, 2):
		area += x * (l1[i] ** 2 - l1[i - 1] ** 2)
	print(area)
else:
	area = 0
	for i in range(1, n, 2):
		area += x * (l1[i] ** 2 - l1[i - 1] ** 2)
	print(area)


import math
n = int(input())
rs = list(map(int, input().split()))
rs.sort(reverse=True)
red = True
s = 0
for r in rs:
	if red:
		s += r * r
	else:
		s -= r * r
	red = not red
print(s * math.pi)


import math
n = int(input())
a = sorted(list(map(int, input().split())))
pi = math.pi
ans = 0
k = 1
for i in range(n - 1, -1, -1):
	ans += k * a[i] ** 2 * pi
	k = -k
print(ans)


pi = 3.1415926536
n = int(input())
c = input().split()
for i in range(len(c)):
	c[i] = int(c[i])
c.sort(reverse=True)
(areared, areablue) = (0, 0)
for i in range(0, len(c), 2):
	areared += pi * c[i] ** 2
for i in range(1, len(c), 2):
	areablue += pi * c[i] ** 2
print(areared - areablue)


n = int(input())
l = list(map(int, input().split()))
pi = 3.1415926536
l.sort()
r = 0
alterna = -1
for i in range(n - 1, -1, -1):
	alterna *= -1
	r += pi * l[i] ** 2 * alterna
print(r)


t = int(input())
l = list(map(int, input().split()))
l.sort(reverse=True)
con = 3.141592653589793
sum = 0
p = 1
for i in range(t):
	sum += l[i] * l[i] * p
	p = p * -1
print(sum * con)


import os, sys
from io import BytesIO, IOBase
from collections import deque, Counter, defaultdict as dft
from heapq import heappop, heappush
from math import log, sqrt, factorial, cos, tan, sin, radians, log2, ceil, floor
from bisect import bisect, bisect_left, bisect_right
from decimal import *
import sys, threading
from itertools import permutations, combinations
from copy import deepcopy
input = sys.stdin.readline
ii = lambda : int(input())
si = lambda : input().rstrip()
mp = lambda : map(int, input().split())
ms = lambda : map(str, input().strip().split(' '))
ml = lambda : list(mp())
mf = lambda : map(float, input().split())
alphs = 'abcdefghijklmnopqrstuvwxyz'

def solve():
	n = ii()
	ls = ml()
	ls.sort()
	ls = [0] + ls
	temp = 1
	if n % 2 == 0:
		temp = 2
	pi = 3.1415926536
	res = 0
	for i in range(temp, n + 1, 2):
		res += pi * (ls[i] ** 2 - ls[i - 1] ** 2)
	print(res)
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')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
tc = 1
for i in range(tc):
	solve()


n = int(input())
ans = 0
k = 1
for r in sorted(map(int, input().split())):
	ans += r * r * k
	k *= -1
print(abs(ans * 3.1416))


a = int(input())
b = list(map(int, input().split()))
import math
b = sorted(b)
k = 0
S = 0
if a % 2 == 0:
	for i in range(0, len(b), 1):
		if i % 2 == 0:
			S -= math.pi * b[i] ** 2
		if i % 2 != 0:
			S += math.pi * b[i] ** 2
if a % 2 != 0:
	for i in range(0, len(b), 1):
		if i % 2 == 0:
			S += math.pi * b[i] ** 2
		if i % 2 != 0:
			S -= math.pi * b[i] ** 2
print(S)


import math
n = int(input())
a = sorted(map(int, input().split()))
d = [1, -1]
r = 0
for i in range(n):
	r += d[i % 2] * math.pi * a[-1 - i] ** 2
print(r)


from math import *
n = int(input())
arr = [int(i) for i in input().split()]
arr.sort()
a = 0
if n % 2 == 0:
	for i in range(1, n, 2):
		a = a + pi * (arr[i] ** 2 - arr[i - 1] ** 2)
else:
	a = a + pi * arr[0] ** 2
	for i in range(2, n, 2):
		a = a + pi * (arr[i] ** 2 - arr[i - 1] ** 2)
print(a)


pi = 3.14159
t = int(input())
arr = list(map(lambda x: int(x), input().split()))
if t % 2 == 0:
	start = 1
else:
	start = 0
res = 0
arr = sorted(arr)
for i in range(start, t, 2):
	if i == 0:
		res += pi * arr[i] ** 2
		continue
	res += abs(pi * arr[i - 1] ** 2 - pi * arr[i] ** 2)
print('%.10f' % res)


import math
pi = math.pi
n = int(input())
r = sorted(list(map(int, input().split())))
area = 0
f = 1 if n % 2 == 0 else 0
for i in range(n):
	if (i + f) % 2 == 0:
		area += r[i] ** 2 * pi
	else:
		area -= r[i] ** 2 * pi
print(area)


n = int(input())
l = list(map(int, input().split()))
l.sort()
pi = 3.1415926536
count = 0
sub = 0
for i in range(n):
	if n % 2 == 0:
		if i % 2 != 0:
			count += pi * l[i] ** 2
		else:
			sub += pi * l[i] ** 2
	elif i % 2 == 0:
		count += pi * l[i] ** 2
	else:
		sub += pi * l[i] ** 2
print(count - sub)


import math
n = int(input())
raios = list(map(int, input().split(' ')))
raios.sort(reverse=True)
r = math.pi
quadrados_pares = []
quadrados_impares = []
for x in range(0, len(raios)):
	if x % 2 == 0:
		quadrados_pares.append(raios[x] ** 2)
	elif x % 2 == 1:
		quadrados_impares.append(raios[x] ** 2)
resultado = sum(quadrados_pares) - sum(quadrados_impares)
area_resultante = resultado * r
print(area_resultante)


import math
n = int(input())
l1 = [int(x) for x in input().split()]
l1.sort()
area = 0
if n % 2 == 0:
	i = 1
	while i < n:
		area += l1[i] ** 2 - l1[i - 1] ** 2
		i += 2
else:
	i = 0
	while i < n:
		if i == 0:
			area += l1[i] ** 2
		else:
			area += l1[i] ** 2 - l1[i - 1] ** 2
		i += 2
print(area * 3.1415926536)


quant = int(input())
n = input().split()
vermelho = 0
azul = 0
pi = 3.1415926536
for x in range(quant):
	n[x] = int(n[x])
n = sorted(n)
for x in range(quant):
	if x % 2 == 0:
		area = n[x] * n[x] * pi
		vermelho = vermelho + area
	else:
		area = n[x] * n[x] * pi
		azul = azul + area
if len(n) % 2 == 0:
	print(azul - vermelho)
else:
	print(vermelho - azul)


import math
n = int(input())
list1 = [int(x) for x in input().split()]
list1 = sorted(list1)
area = 0
pie = math.pi
if n % 2 == 1:
	area += pie * (list1[0] * list1[0])
	i = 1
	for i in range(1, n, 2):
		a1 = pie * (list1[i + 1] * list1[i + 1])
		a2 = pie * (list1[i] * list1[i])
		area += a1 - a2
else:
	for i in range(0, n, 2):
		a1 = pie * (list1[i + 1] * list1[i + 1])
		a2 = pie * (list1[i] * list1[i])
		area += a1 - a2
print(area)


from math import pi

def main():
	input()
	l = sorted(map(int, input().split()), reverse=True)
	print((sum((_ * _ for _ in l[::2])) - sum((_ * _ for _ in l[1::2]))) * pi)
main()


import math
n = int(input())
A = 0
r = [0] + list(map(int, input().split()))
r.sort()
if n % 2 != 0:
	i = 0
	while i < n:
		A = A + 3.1415926536 * (-r[i] ** 2 + r[i + 1] ** 2)
		i = i + 2
else:
	i = 1
	while i < n:
		A = A + 3.1415926536 * (-r[i] ** 2 + r[i + 1] ** 2)
		i = i + 2
print(A)


n = int(input())
k = list(map(int, input().split()))
x = 0
k.sort()
p = 3.141592653589793
for i in range(n - 1, n % 2 - 1, -2):
	x += k[i] * k[i] - k[i - 1] * k[i - 1]
x += k[0] * k[0] * (n % 2)
print(p * x)


import math

def calculaArea(entrada):
	valores = [int(valor) for valor in entrada]
	valores.sort()
	sum = 0
	if len(valores) % 2 != 0:
		for i in range(len(valores)):
			if i % 2 == 0:
				sum += valores[i] ** 2
			else:
				sum -= valores[i] ** 2
		return round(sum * math.pi, 10)
	else:
		for i in range(len(valores)):
			if i % 2 != 0:
				sum += valores[i] ** 2
			else:
				sum -= valores[i] ** 2
		return round(sum * math.pi, 10)
num = int(input())
entrada = input().split()
print(calculaArea(entrada))


import math
I = lambda : list(map(int, input().split()))
n = int(input())
a = sorted(I(), reverse=True)
area = 0
for i in range(len(a)):
	if i % 2 == 0:
		area += a[i] ** 2 * math.pi
	else:
		area -= a[i] ** 2 * math.pi
print(area)


import math
n = int(input())
list = []
list = [int(i) for i in input().split()]
list.append(0)
list.sort(reverse=True)
ans = 0
for i in range(0, n, 2):
	ans += list[i] * list[i] - list[i + 1] * list[i + 1]
print(math.pi * ans)


import math
n = int(input())
r = list(map(int, input().split()))
r.sort()
area = 0.0
for i in range(n):
	if i % 2 == 0:
		area += r[i] * r[i]
	else:
		area -= r[i] * r[i]
print('%.10f' % abs(area * math.pi))


def solve(vals):
	import math
	vals = sorted(vals, reverse=True)
	f = True
	answ = 0.0
	for i in range(len(vals)):
		if f:
			answ += math.pi * vals[i] ** 2
		else:
			answ -= math.pi * vals[i] ** 2
		f = not f
	return answ
_ = input()
vals = list(map(int, input().split()))
print(solve(vals))


import re
import sys
from bisect import bisect, bisect_left, insort, insort_left
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from itertools import accumulate, combinations, combinations_with_replacement, groupby, permutations, product
from math import acos, asin, atan, ceil, cos, degrees, factorial, gcd, hypot, log2, pi, radians, sin, sqrt, tan
from operator import itemgetter, mul
from string import ascii_lowercase, ascii_uppercase, digits

def inp():
	return int(input())

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

def instr():
	s = input()
	return list(s[:len(s)])

def invr():
	return map(int, input().split())
n = inp()
r = inlist()
r = sorted(r, reverse=True)
res = 0
for i in range(n):
	if i % 2 == 0:
		res += pi * r[i] * r[i]
	else:
		res -= pi * r[i] * r[i]
print(res)


import sys
import heapq
from math import *
from collections import defaultdict as dd
from collections import deque
from collections import Counter as c
from itertools import combinations as comb
from bisect import bisect_left as bl, bisect_right as br, bisect
mod = pow(10, 9) + 7
mod2 = 998244353

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

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

def l():
	return list(map(int, data().split()))

def sl():
	return list(map(str, data().split()))

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [[val for i in range(n)] for j in range(m)]
n = int(data())
arr = l()
arr.sort()
answer = 0.0
if n % 2 == 0:
	for i in range(n):
		if i % 2 == 0:
			answer -= pi * pow(arr[i], 2)
		else:
			answer += pi * pow(arr[i], 2)
else:
	for i in range(n):
		if i % 2 == 0:
			answer += pi * pow(arr[i], 2)
		else:
			answer -= pi * pow(arr[i], 2)
print('%.5f' % answer)


import os
import sys
from io import BytesIO, IOBase
pie = 3.1415926536

def main():
	n = int(input())
	r = list(map(int, input().split()))
	r.append(0)
	r.sort()
	ans = 0
	for i in range(n, 0, -2):
		ans += (r[i] + r[i - 1]) * (r[i] - r[i - 1])
	print(ans * pie)
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')
main()


import math
n = int(input())
r = [int(x) for x in input().split()]
r.sort()
a = 0
if n % 2 == 0:
	i = 1
	while i < len(r):
		a = a + math.pi * r[i] * r[i]
		i = i + 2
	j = 0
	while j < len(r):
		a = a - math.pi * r[j] * r[j]
		j = j + 2
	print(a)
else:
	i = 0
	while i < len(r):
		a = a + math.pi * r[i] * r[i]
		i = i + 2
	j = 1
	while j < len(r):
		a = a - math.pi * r[j] * r[j]
		j = j + 2
	print(a)


import math
n = int(input())
r = list(map(int, input().split()))
k = 0
r.sort()
outS = 0
if n % 2 == 0:
	color = 'blue'
else:
	color = 'red'
	outS += math.pi * r[0] ** 2
for i in range(1, n):
	if color == 'blue':
		outS += math.pi * (r[i] ** 2 - r[i - 1] ** 2)
		color = 'red'
	else:
		color = 'blue'
print(outS)


import sys
INT_MAX = sys.maxsize
INT_MIN = -sys.maxsize - 1
sys.setrecursionlimit(10 ** 7)
mod = 1000000007

def IOE():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

def main():
	n = int(sys.stdin.readline())
	a = list(map(int, sys.stdin.readline().split()))
	a.sort()
	s = 0
	pi = 3.1415926536
	area = [a[0] ** 2]
	prfx = area[0]
	if n == 1:
		print(a[0] ** 2 * pi)
	else:
		for i in range(1, n):
			area.append(a[i] ** 2 - prfx)
			prfx += area[-1]
		if n & 1:
			res = area[0::2]
			print(sum(res) * pi)
		else:
			res = area[1::2]
			print(sum(res) * pi)
try:
	IOE()
except:
	pass
main()


n = int(input())
l = [int(i) for i in input().split()]
l.sort()
A = 0
pi = 3.141592653589793
for i in range(n - 1, 0, -2):
	r = l[i]
	r1 = l[i - 1]
	A += pi * r * r - pi * r1 * r1
if n & 1:
	A += pi * l[0] * l[0]
print(A)


circles = int(input())
radius = [int(x) for x in input().split()]
radius.sort()
pi = 3.1415926536
red_area = 0
if circles % 2 == 0:
	for r in range(1, circles, 2):
		red_area += radius[r] ** 2 - radius[r - 1] ** 2
else:
	red_area = radius[0] ** 2
	for r in range(2, circles, 2):
		red_area += radius[r] ** 2 - radius[r - 1] ** 2
red_area *= pi
print(red_area)


import math
p = math.pi
n = int(input())
list1 = list(map(int, input().split()))
list1.sort(reverse=True)
for i in range(n):
	list1[i] = list1[i] ** 2
s = 0
if n % 2 == 0:
	m = 0
	for i in range(n):
		if m % 2 == 0:
			s += list1[i] - list1[i + 1]
			m = 1
		else:
			m = 0
else:
	m = 0
	for i in range(n - 2):
		if m % 2 == 0:
			s += list1[i] - list1[i + 1]
			m = 1
		else:
			m = 0
	s += list1[-1]
print(p * s)


while True:
	try:
		import math

		def soln(n, a):
			a.sort(reverse=True)
			res = 0
			for i in range(n):
				if i & 1:
					res -= math.pi * a[i] ** 2
				else:
					res += math.pi * a[i] ** 2
			print(res)

		def read():
			n = int(input())
			a = list(map(int, input().split()))
			soln(n, a)
		if __name__ == '__main__':
			read()
	except EOFError:
		break


from math import pi
input()
X = sorted(list(map(int, input().split())))
Red = X[::2]
Blue = X[1::2]
for i in range(len(Red)):
	Red[i] = Red[i] ** 2 * pi
for i in range(len(Blue)):
	Blue[i] = Blue[i] ** 2 * pi
print(abs(sum(Red) - sum(Blue)))


from math import pi
n = int(input())
r = sorted(list(map(int, input().split())))
s = r[::-1]
a = 0
if n % 2 == 0:
	for i in range(0, n - 1, 2):
		a += s[i] ** 2 - s[i + 1] ** 2
else:
	a += r[0] ** 2
	for i in range(2, n, 2):
		a += r[i] ** 2 - r[i - 1] ** 2
print(pi * a)


import math

def square(j):
	return math.pi * x[j] ** 2
n = int(input())
x = list(map(int, input().split()))
x.sort()
total_square = 0
if n % 2 == 0:
	for j in range(1, n, 2):
		total_square += square(j) - square(j - 1)
else:
	for j in range(0, n, 2):
		if j == 0:
			total_square += square(j)
		else:
			total_square += square(j) - square(j - 1)
print(total_square)


import math

def get_n():
	return int(input())

def get_int_vector():
	return [int(x) for x in input().split()]

def list2string(list):
	result = []
	for i in list:
		result.append(str(i))
	return ':'.join(result)

def string2vector(string):
	return [int(x) for x in string.split(':')]
n = get_n()
rad = get_int_vector()
rad.sort(reverse=True)
result = 0
for i in range(n - 1):
	if i % 2 == 0:
		result += rad[i] ** 2 - rad[i + 1] ** 2
if n % 2 == 1:
	result += rad[-1] ** 2
print('{:.5f}'.format(result * math.pi))


from math import pi

def main():
	n = int(input())
	a = sorted(list(map(int, input().split(' '))))[::-1]
	area = 0
	f = 0
	for i in range(n):
		cur = pi * a[i] * a[i]
		if f:
			area += cur
		else:
			area -= cur
		f ^= 1
	return abs(area)
print(main())


import math
n = int(input())
a = list(map(int, input().split()))
for i in range(n):
	a[i] = math.pi * a[i] ** 2
a = sorted(a)
c = 0
if n & 1 == 1:
	for i in range(n):
		if i & 1 == 0:
			if i == 0:
				c += a[i]
			else:
				c += a[i] - a[i - 1]
else:
	for i in range(n):
		if i & 1 == 1:
			c += a[i] - a[i - 1]
print(c)


import math
n = int(input())
arr = list(map(int, input().split()))
arr.sort()
e = 0
o = 0
for i in range(n):
	x = arr[i] ** 2 * math.pi
	if i == 0:
		e = e + x
	elif i % 2 == 0:
		e = e + x
	else:
		o = o + x
print(abs(e - o))


n = int(input())
pi = 3.1415926536
a = sorted(list(map(int, input().split())))
a = [pi * i * i for i in a]
ans = 0
if n % 2:
	ans += a[0]
	for i in range(2, n, 2):
		ans += a[i] - a[i - 1]
else:
	for i in range(1, n, 2):
		ans += a[i] - a[i - 1]
print(ans)


import math
circles = int(input())
radii = sorted(map(int, input().split()), reverse=True)
if circles == 1:
	print(radii[0] ** 2 * math.pi)
else:
	red = radii[-1] ** 2 * math.pi if circles % 2 else 0
	a = 1 if circles % 2 else 0
	for x in range(1, circles - a, 2):
		red += math.pi * (radii[x - 1] ** 2 - radii[x] ** 2)
	print(red)


__author__ = 'Rajan'
n = int(input())
r = sorted(list(map(int, input().split())))
PI = 3.1415926536
ans = 0
if n % 2 == 0:
	for i in range(1, n, 2):
		ans += r[i] ** 2 - r[i - 1] ** 2
else:
	ans += r[0] ** 2
	for i in range(2, n, 2):
		ans += r[i] ** 2 - r[i - 1] ** 2
ans *= PI
print(ans)


from math import pi
n = int(input())
r = list(map(int, input().split()))
r.sort()
ans = 0
for i in range(n):
	if i & 1:
		ans -= r[i] ** 2 * pi
	else:
		ans += r[i] ** 2 * pi
print('%.5f' % abs(ans))


import math as mt
import sys, string, bisect
input = sys.stdin.readline
from collections import deque, defaultdict
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
I = lambda : int(input())

def dist(x, y, c, d):
	return mt.sqrt((x - c) ** 2 + (y - d) ** 2)

def circle(x1, y1, x2, y2, r1, r2):
	distSq = ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)) ** 0.5
	if distSq + r2 <= r1:
		return True
	else:
		return False
n = I()
l = L()
l.sort(reverse=True)
c = 0
for i in range(0, n, 2):
	if i + 1 < n:
		c += l[i] ** 2 - l[i + 1] ** 2
	else:
		c += l[i] ** 2
print(mt.pi * c)


L = lambda : list(map(int, input().split()))
M = lambda : map(int, input().split())
I = lambda : int(input())
n = I()
a = sorted(L())
x = 0
for i in range(n):
	if i % 2 == 0:
		x += a[i] ** 2
	else:
		x -= a[i] ** 2
print(abs(x) * 3.1415926536)


pi = 3.1415926536
n = int(input())
stroka = input()
k = ''
R = []
for i in range(0, len(stroka)):
	if stroka[i] == ' ':
		R.append(int(k))
		k = ''
	else:
		k += stroka[i]
R.append(int(k))
for i in range(0, n):
	for j in range(1, n):
		if R[j] > R[j - 1]:
			k = R[j]
			R[j] = R[j - 1]
			R[j - 1] = k
answer = 0
for i in range(0, n):
	if i % 2 == 0:
		answer += R[i] ** 2
	else:
		answer -= R[i] ** 2
answer *= pi
print(answer)


import os
import sys
from math import *
from collections import *
from bisect import *
from io import BytesIO, IOBase

def vsInput():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
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')

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

def array():
	return [int(i) for i in input().split()]
n = int(input())
a = sorted(array())
s = 1
ans = 0
if n & 1:
	s = 2
	ans = pi * a[0] * a[0]
for i in range(s, n, 2):
	ans += pi * (a[i] * a[i] - a[i - 1] * a[i - 1])
print(ans)


n = int(input())
a = list(map(int, input().split()))
a.sort(reverse=True)
s = 0
for i in range(n):
	if i % 2 == 0:
		s += a[i] * a[i]
	else:
		s -= a[i] * a[i]
print(s * 3.1415926536)


from math import pi
input()
r = list(map(int, input().split()))
r.sort(reverse=True)
s = sum([r[i] ** 2 * (-1) ** (i & 1) for i in range(len(r))])
print(s * pi)


import math
n = int(input())
a = list(map(int, input().split()))
a.sort()
a.insert(0, 0)
s = 0
for i in range(len(a) - 1, -1, -2):
	s = s + math.pi * (a[i] ** 2 - a[i - 1] ** 2)
	if i <= 2:
		break
print(s)


import math
n = int(input())
l = list(map(int, input().split()))
if n == 1:
	print(math.pi * l[0] * l[0])
else:
	l.sort(reverse=True)
	a = l[0:n:2]
	b = l[1:n:2]
	s = 0
	for i in a:
		s += i ** 2
	for j in b:
		s -= j ** 2
	print(math.pi * s)


from math import pi
total = int(input())
L = (int(x) for x in input().split())
L = sorted((i * i for i in L))
a = sum(L[::-2])
b = sum(L[-2::-2])
print(pi * (a - b))


from math import pi
n = int(input())
a = list(map(int, input().rstrip().split()))
a.sort(reverse=True)
sol = 0
for i in range(n):
	if i % 2 == 0:
		sol += pi * a[i] * a[i]
	else:
		sol -= pi * a[i] * a[i]
print(sol)


n = input()
n = int(n)
l = list(map(int, input().split()))
l.sort()
area = 0
pi = 3.1415926536
if n % 2 == 0:
	for i in range(1, len(l), 2):
		area = area + (pi * l[i] * l[i] - pi * l[i - 1] * l[i - 1])
else:
	area = pi * l[0] * l[0]
	if n == 1:
		area = area
	else:
		for i in range(2, len(l), 2):
			area = area + (pi * l[i] * l[i] - pi * l[i - 1] * l[i - 1])
print(area)


from math import *
a = int(input())
b = list(map(int, input().split()))
b.sort(reverse=True)
l = 0
if a % 2 != 0:
	for y in range(0, a - 1, 2):
		l += round(pi * b[y] ** 2 - pi * b[y + 1] ** 2, 10)
	l += round(pi * b[-1] ** 2, 10)
	print(l)
else:
	for y in range(0, a, 2):
		l += round(pi * b[y] ** 2 - pi * b[y + 1] ** 2, 10)
	print(l)


import sys
import math
import collections
import heapq
import decimal
input = sys.stdin.readline
n = int(input())
l = sorted([int(i) for i in input().split()])
s = 0
for i in range(n - 1, -1, -2):
	if i == 0:
		s += math.pi * l[i] * l[i]
	else:
		s += math.pi * (l[i] * l[i] - l[i - 1] * l[i - 1])
print(s)


n = int(input())
r = [int(x) for x in input().split()]
r.sort(key=lambda x: -x)
res = 0
sign = True
for i in r:
	res = res + i ** 2 if sign else res - i ** 2
	sign = not sign
print(3.1415926536 * res)


pie = 3.1415926536
n = int(input())
A = list(map(int, input().split()))
A.sort(reverse=True)
red = 0
blue = 0
for i in range(n):
	if i % 2 == 0:
		red += A[i] ** 2
	else:
		blue += A[i] ** 2
ans = pie * (red - blue)
print(ans)


from math import pi
n = int(input())
l = list(map(int, input().split()))
l.sort()
if n % 2 != 0:
	ans = pi * l[0] ** 2
	for i in range(2, n, 2):
		ans += pi * (l[i] ** 2 - l[i - 1] ** 2)
else:
	ans = 0
	for i in range(1, n, 2):
		ans += pi * (l[i] ** 2 - l[i - 1] ** 2)
print(ans)


def zip_sorted(a, b):
	(a, b) = zip(*sorted(zip(a, b)))
	sorted(zip(a, b), key=lambda x: x[1])
	return (a, b)
import sys
input = sys.stdin.readline
I = lambda : list(map(int, input().split()))
S = lambda : list(map(str, input().split()))
import math
(t,) = I()
n = I()
n = sorted(n)
n1 = [0] + n
area = 0
i = 0
n2 = len(n1)
while i < n2:
	if n2 - i - 2 >= 0:
		area = area + (math.pi * n1[n2 - i - 1] * n1[n2 - i - 1] - math.pi * n1[n2 - i - 2] * n1[n2 - i - 2])
	i = i + 2
print(area)


import math
size = int(input())
circles = input().split()
circles = [int(x) for x in circles]
circles.sort()
total = 0
if size % 2 == 1:
	for i in range(size - 1, -1, -1):
		if i % 2 == 0:
			total += math.pi * circles[i] ** 2
		else:
			total -= math.pi * circles[i] ** 2
else:
	for i in range(size - 1, -1, -1):
		if i % 2 == 1:
			total += math.pi * circles[i] ** 2
		else:
			total -= math.pi * circles[i] ** 2
print(total)