peterverebics/CodeNet_Python_118 huggingface dataset:
R=int(input())
print (R*2*3.14159265358979)
import math
N =  int(input())
print(2*math.pi*N)
import math
r = int(input())
print(2 * r * math.pi)
r = int(input())
pi = 3.1415927
print(2 * pi * r)
import sys
from math import pi

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    R = int(readline())

    print(2 * R * pi)

    return


if __name__ == '__main__':
    main()
R = int(input())
ennsyuu = R * 6.28318530717958623200
print(ennsyuu)
#coding:utf-8
import math

R = int(input())

print(2*R*math.pi)
import math

r = int(input())

al = math.pi * r *2

print(al)
import math
n=int(input())

print(str(2*n*math.pi))
import math
 
r=int(input())
print(2*r*math.pi)
R = float(input())
l = 3.14159*R*2
print(l)
r = int(input())
pi = 3.14159265358979
 
print(r*2*pi)
#-*- coding: utf-8 -*-
import math

r = int(input())
print(r*2*math.pi)
r=int(input())
L=2.0*3.1415926*r
print(L)
def resolve():
    '''
    code here
    '''
    import math
    r = int(input())
    print(2*r*math.pi)

if __name__ == "__main__":
    resolve()
import math

R = int(input())

ans = 2 * math.pi * R

print("%.20f"%ans)
input_line = int(input())

result = 2 * input_line * 3.14
print(result)
import math
 
R = int(input())
 
print(2*math.pi*R)
r = int(input())
pi = 3.141592
print(r * 2 * pi)
import math

R = int(input())

print(2 * math.pi * R)
import math, sys
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from copy import deepcopy
from functools import lru_cache
from heapq import heapify, heappop, heappush
from itertools import accumulate, combinations, permutations
input = sys.stdin.readline
p = 10**9 + 7
ns = lambda: input().strip()
ni = lambda: int(input().strip())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))

def main():
    r = ni()

    print(2 * math.pi * r)

if __name__ == '__main__':
    main()
import  math

R=int(input())

print(2*math.pi*R)
import math

r = int(input())
print(math.ceil(2*math.pi*r*100)/100)
import numpy as np
R = int(input())
print(2*R*np.pi)
import math
def main():
    r = int(input())
    print(r*2*math.pi)


if __name__ == '__main__':
    main()
from math import pi
def solve():
    R = int(input())
    print(R*2*pi)
if __name__ == '__main__':
    solve()
from sys import stdin
from sys import setrecursionlimit
from math import pi
setrecursionlimit(10 ** 7)

n = int(stdin.readline().rstrip())

print(2*pi*n)
r = int(input())
l = 2*r*3.141592
print(l)
pi = 3.14159
r = int(input())
print(2*r*pi)
from math import pi
a = int(input())
# # a = [int(i) for i in input().split()]

print(2*pi*a)
import math
n=int(input())
a=math.pi
print((n+n)*a)
import sys
input = sys.stdin.readline

def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))

def main():
    mod=10**9+7
    R=I()
    print(2*R*3.1415926535)

main()
#A
R = int(input())
print(2*R*3.141592)
# coding: utf-8
from math import pi
r = int(input())
print(2 * pi * r)
r = int(input())

p = 6.28318530717958623200

print(r*p)
r=int(input())
pi=3.14159265
print(r*2*pi)
import math
x = math.pi
r = int(input())
print(2*x*r)
#=input()
R=int(input())
#,=map(int,input().split())
#list(map(int,input().split()))

print(R*2*3.141592653589793238)
import math
N = int(input())

ans = 2*N*math.pi

print(ans)
import math
r = int(input())
circle = r*2*math.pi
print(circle)
r = int(input())
pi = 3.141593

print(r * 2 * pi)
def resolve():
    pi = 3.14159265
    r = int(input())
    print(2*r*pi)
resolve()
import math
#from functools import reduce
# import math
# import itertools
# import statistics
# import numpy as np
# import collections
n = int(input())
# l, r = list(map(int, input().split()))
# b = list(map(int, input().split()))
print(n*2*math.pi)
import math

r = int(input())

l = (r*2) * math.pi

print(l)
import math

r = int(input())
ans = math.pi * 2 * r

print(ans)
def resolve():
	r = int(input())
	print(2 * r * 3.14159265358)
resolve()
import math
n=int(input())
ans=math.pi*2*n
print(ans)
def main():
    t = int(input())
    print(t * 2 * 3.14)

if __name__ == '__main__':
    main()
import numpy as np

r = int(input())
print(2 * np.pi * r)
import math

r = int(input())
ans = 2 * math.pi * r
print(ans)
n=int(input()) #Pythonの標準入力
ans=n*6.28
print(ans)
PI = 3.1415

# utility function 
def circumference(r): 
	return (2 * PI * r) 


# driver function 
k=int(input(" "))
print ('%.3f' % circumference(k))
n = float(input())
pi = 3.1415926535
print(2 * pi * n)
import sys
sys.setrecursionlimit(10 ** 6)
# input = sys.stdin.readline    ####
int1 = lambda x: int(x) - 1
def II(): return int(input())

def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())

def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]

INF = float('inf')

from math import pi
def solve():
    r = II()
    print(2 * pi * r)


if __name__ == '__main__':
    solve()
import math
n = int(input())
ans = math.pi * 2 * n
print(ans)
import math

r = int(input())

R = 2*r*math.pi

print(R)
import math
R = int(input())
H = math.pi
 
print(R*2*H)
import math

x = int(input())

print(x * 2 * math.pi)
import math
R = int(input())
pi = math.pi
print(2*R*pi)
r = int(input())
print(2 * 3.14159 * r)
import sys
input = sys.stdin.readline

r = int(input())

import math

print(2*math.pi*r)
import numpy as np

r=int(input())

print(2*r*np.pi)
r=int(input())
import math 
print(2*math.pi*r)
import sys
# sys.stdin = open('input.txt')

from math import pi

r = int(input())
ans = 2 * r * pi
print(ans)
a = int(input())

A=10000
pi=0
for L in range(1,A):
    if L%2==0:
        B=-1
    else:
        B=1
    pi+=(4/(2*L-1))*B

answer = 2*pi*a

print(answer)
# -*- coding: utf-8 -*-
import math
    
###
# main
if(__name__ == '__main__'):
    # input
    r = int(input())
    
    pi = 3.141592
    ans = pi * r * 2.0
    print(ans)
    
# else:
    # do nothing
#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys
import math

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


def resolve():
    r = int(input())
    print(2.0*math.pi*r)




if __name__ == "__main__":
    resolve()
import sys
import os
import bisect, collections, copy, itertools, math, string
def I(): return int(input())
def S(): return input()
def LI(): return list(map(int, input().split()))
def LS(): return list(input().split())

def solve():
	R = I()
	r = 2 * math.pi * R
	print(r)
	
if __name__ == '__main__':
	solve()
import math
r = input()
ans = 2 * int(r) * math.pi
print(ans)
x=int(input())
circ=2*22*x/7.0
print(circ)
import numpy as np

R = int(input())
C = 2 * np.pi * R
print(C)
pi =3.141592653589793

R=int(input())
print(pi*2*R)
pi = 3.1415926
 
############ ---- USER DEFINED INPUT FUNCTIONS ---- ############
def inp():
    return(int(input().rstrip()))
def inlt():
    return(list(map(int,input().rstrip().split())))
def insr():
    s = input().rstrip()
    return(s[:len(s) - 1])
def invr():
    return(map(int,input().rstrip().split()))
################################################################
n = inp()
print(2*n*pi)
#print('No')
#print()
i = int(input())
print(i * 2 * 3.14159265)
##入力

R = int(input())
"""
1 ##数字 integer -> int
"1" ##文字列 string -> str
"""
##計算

L = 2*R*3.141592

##出力

print(L)
import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)

def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
# 入力全てを整数に変換したものの配列を受け取る
def LI(): return list(map(int, sys.stdin.readline().split()))
# 入力全てを整数に変換して1引いたものの配列を受け取る
def LLI(rows_number): return [LI() for _ in range(rows_number)]

r = II()
import math
print(round(math.pi*r*2,2))
R = int(input())

# print(R * 2 * 3.14159)

print(R * 2 * 3.14159265358979323846)
import math
r=int(input())
print(math.pi * 2*r)
from math import pi

r = int(input())

print(2 * pi * r)
import math
r = int(input())
x = math.pi
print(2 * r * x)
def main():
    R = int(input())
    print(R*2*3.141526)

if __name__ == "__main__":
    main()
R = int(input())
circle = 2 * R * 3.1415
print(circle)
import sys
input = sys.stdin.readline
import math
def main():
    R = int(input())
    print(float(R*2*math.pi))

if __name__ == '__main__':
   main()
import math
r = int(input().strip())
print(r * math.pi * 2)
import math
R = int(input())
cir = 2*math.pi*R
print(cir)
r=int(input())#入力を受け取る intで文字を数字に直してる
ans = r*2*3.14
print(ans)
import math
pi = math.pi
r = int(input())
print(2 * r * pi)
R = int(input())
pi = 3.1415
ans = 2 * R * pi
print(ans)
r = int(input())
R = 2*r*3.1415
print(R)
import math
def main():
    R = int(input())
    out = 2 * math.pi * R
    print(out)
main()
import math
s = input().split()
s=int(s[0])
print(s*2*math.pi)
from math import pi
from sys import stdin
R = int(stdin.readline().rstrip())
print(R*2*pi)
import math
a = int(input())
print(2 * a * math.pi)
import math

R = int(input())

print(R * 2 * math.pi)
import math

r = int(input())

print(math.pi*r*2.0)
if __name__ == "__main__":
    r = float(input())
    pi = 3.14159
    print((r*pi*2.0))
r = int(input())
print(r * 2 * 3.14159265358979323846)
import numpy as np
a,=map(int,input().split())
print(2*np.pi*a)
pi = 3.141592653979
r = int(input())
print(2*r*pi)
from sys import stdin


def main():
    r = int(stdin.readline())
    print(2 * r * 3.14)


if __name__ == "__main__":
    main()
import math
import decimal
n = int(input())
 
print(decimal.Decimal(2) * decimal.Decimal(n) * decimal.Decimal(math.pi))
import numpy as np
r = int(input())
print(2*r*np.pi)
import math

r = int(input())
print(2 * r * math.pi)
import math
PI = math.pi
R = int(input())
print(2*R*PI)
from math import pi

R = int(input())
print(2 * pi * R)
r = int(input())
print(r * 2 * 3.1415)
r=int(input())
print(2*3.141592653589793238*r)
# -*- coding: utf-8 -*-
"""
Created on Sun Apr 19 20:57:08 2020

@author: black
"""


import math
pi = math.pi
R = int(input())

print(2*pi*R)
import numpy as np
R = float(input())
print(2*np.pi*R)
import math

r = input()
R = 2*math.pi*float(r)


print(R)
PI = 3.1415926535
r = int(input())
print(r * 2 * PI)
import sys
input = sys.stdin.readline

R = float(input().rstrip())
print(R * 2.0 * 3.1415)
import numpy as np
R = int(input().strip())
print(2*R*np.pi)
n = int(input())
a = n/0.1591549431
print(a)
R =  int(input())
x= 2*3.14*R
print(x)
r=int(input())
print(2*(3.1415926535897932)*r)
import math


def main():
    r = int(input())
    print(2 * r * math.pi)


if __name__ == '__main__':
    main()
import math
R = int(input())
print(2 * math.pi * R)
import math

rad = int(input())
a = math.pi * 2 * rad
print(a)
pi = 3.141592653
r = int(input())
print(2 * pi * r)
R=input()
R = int(R)
import math
# 円の周を計算する
def circle_round(radius):
  return 2 * math.pi * radius

print(circle_round(R))
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sun Apr 26 13:36:36 2020

@author: hiroki
"""

import math

a = input()
print(int(a)*2*math.pi)
import math
r = int(input())
print(math.pi * r * 2)
import math
r = float(input())
print(float(2.0*r*math.pi))
import math

r = float(input())

print(r * 2 * math.pi)
import math

def circle(r):
    print(2*r*math.pi)

r = int(input())
circle(r)
import math
R = int(input())

print(R*2.0*math.pi)
##### 解けた #####

import math

R=int(input()) # 半径
L=2.0*math.pi*R # 円周

print(L)
r = float(input())
out = 2 * 3.1415 * r
print(out)
import math
r=int(input())
pi=math.pi
print(2*pi*r)
# ABC163 A

import math

def main():
    r = int(input())

    print(2*r*math.pi)

if __name__ == '__main__':
    main()
r=input()
l=2*float(r)*3.1415926535897932384626433832795028
print(l)
r=int(input())
print(2*3.141592653589793*r)
import math

r = int(input())
p = math.pi

print(2*r*p)
import math 
r = int(input())

ans = 2 * r * math.pi
print(ans)
R = int(input())
print(2 * R * 3.14159265358979)
r = int(input())
print(r * 2 * 3.14159265)
import sys, re
import math
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul	# 
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd	# 最大公約数
from heapq import heappush, heappop

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

# -*- coding: utf-8 -*-

a = INT() 
print(a * pi * 2)
r = int(input())
 
print(r * 6.28318530717958623200)
import math
R = int(input())
if R>=1 or R<=100:
    R = R * math.pi * 2
    print("{:.20f}" .format(R))
import numpy as np

R = int(input())

l = R * 2 * np.pi

print(str(l))
R=int(input())

ans=3.14*(2*R)

print(ans)
def a():
    r = int(input())
    print(2 * 3.141592653589 * r)


##########
if __name__ == "__main__":
    a()
import math
r = int(input())

print(r * 2 * math.pi)
import math
a = int(input())

print(math.pi * a * 2)
si = lambda: input().strip()
ii = lambda: int(input())
mii = lambda: map(int, input().split())
lmii = lambda: list(map(int, input().split()))
smii = lambda: sorted(map(int, input().split()))

# ----------

from math import pi

R = ii()

print(R*2*pi)
R = int(input())

R *= 2
R *= 3.14

print(R)
import math
r = int(input())

ans = 2* r * math.pi

print(ans)
import math
def main():
    R = int(input())
    print(2*math.pi*R)
if __name__ == "__main__":
    main()
import sys
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0

n = int(readline())
import math
print(2*n*math.pi)
r = int(input())

import math

print(2.0*math.pi*r)
import numpy as np
R=int(input())
print(np.pi*R*2.0)
validation=False
Answer=()


while validation == False:
      R=float(input(""))
      if R>=1 and R<=100:
            validation = True
      else:
            break
      

Answer=((R*2)*3.14159)

print(Answer)
a = input()
a = int(a)
print(a*2*3.14159265359)
mod = 1000000007
eps = 10**-9


def main():
    import sys
    import math
    input = sys.stdin.readline

    N = int(input())
    print(N * 2 * math.pi)


if __name__ == '__main__':
    main()
import sys
from math import ceil, floor
from collections import deque, Counter, defaultdict
from fractions import gcd
input = lambda: sys.stdin.readline().rstrip()

def eprint(s):
    sys.stderr.write('DEBUG: {}'.format(s))
    return

def main():
    pi = 3.14159265358979
    r = int(input())
    
    print(r*2*pi)
    return

if __name__ == '__main__':
    main()
R=int(input())
p=3.141
D=R*2*p
print(D)
import sys

def main():

	R = int(input())
	print(2*R*3.14159)

if __name__ == "__main__":
    main()
import math
R = int(input())
print(R * 2 * math.pi)
r = int(input())
ans = 2*3.14159
ot = ans*r
print(ot)
import math
R=int(input())
L=2*math.pi*R
print(L)
import math

def read():
    R = float(input())
    return R, 

def solve(R):
    return "{:.10f}".format(2 * math.pi * R)

if __name__ == '__main__':
    inputs = read()
    print("{}".format(solve(*inputs)))
import math


r = int(input())

print(2 * math.pi * r)
import math
x = math.pi
r=int(input())
print(2*r*x)
import math

num = int(input())

print(num * 2 * math.pi)
#input
R = int(input())

#output
print(2*R*3.141592)
import math

r = int(input())

print(2 * r * math.pi)
r = int(input())
r = 6.28 * r
print(r)
pi=22/7
r=int(input())
print(2*(pi*r))
from math import comb, factorial, gcd, isqrt, perm, exp, log, log2, log10, sqrt, pi, acos, asin, atan ,atan2, cos, sin, tan
print(2*int(input())*pi)
import math
p = math.pi
r = int(input())
print(2*r*p)
r=input()
l=6.28318530718*int(r)
print(l)
import math
n = int(input())

print(2 * n * math.pi)
import math

N = int(input())
N = 2 * math.pi * N
print(N)
n = int(input())
  
print(2 * n * 3.14159265358979323846)
r=int(input())
d_pi=6.28318530717958623200
print(r*d_pi)
import math

R = int(input())

pai = math.pi

print(2 * R * pai)
import math

n = int(input())

num = math.pi * 2 * n

print('{:.4f}'.format(num))
from math import pi
R = int(input())
print(2 * pi * R)
from math import pi

r = int(input())
print(r * 2 * pi)
hankei = int(input())

print(hankei * 2 * 3.14)
R = input()
R = int(R)
import math
print(2 * math.pi *R)
a=float(input())
z=a*2*3.1415
print(z)
N=int(input())
A=3.14159265358979

print(2*A*N)
#!/usr/bin/env python3

def main():
    r = int(input())
    print(r * 3.141592 * 2)

if __name__ == "__main__":
    main()
import math

def main():

    R = input_int()

    print(R * 2 * math.pi)


def input_int():
    return int(input())


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


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


def input_int_tuple_list(n: int, q: int):
    return [tuple(map(int, input().split())) for _ in range(n)]


main()
# -*- coding: utf-8 -*-


def main():
    from math import pi
    import sys
    input = sys.stdin.readline

    r = int(input())
    print(2 * pi * r)


if __name__ == '__main__':
    main()
r=int(input())
ans=(22/7)*2*r
print(ans)
pi = 6.28318530717958623200 / 2
print(pi * 2 * int(input()))
import math
 
a= int(input())
 
print(2 * a * math.pi)
import math
def main():
    R = int(input())
    return(R*2*math.pi)

print(main())
#if main():
#    print('Yes')
#else:
#    print('No')
import numpy as np
 
R = int(input())
print(R*2.*np.pi)
import math
r = int(input())
print(r * 2 * math.pi)
N = int(input())
print(N * 2 *  3.1415)
r = int(input())
ans = 3.141592652653 * 2 * r
print(ans)
import math
print('{:.5f}'.format(int(input())*2*math.pi))
import math

r = int(input())
x = math.pi

print(r*2*x)
import math
x = input()

# 円の周を計算する
def circle_round(radius):
  return 2 * math.pi * radius

if __name__ == '__main__':
  print(circle_round(int(x)))
import math
radius = int(input())
c = 2 * math.pi*radius
print(c)
# import sys
import math #sqrt,gcd
# import decimal
# import queue # queue
# import bisect
# import heapq # priolity-queue
# import time
# from itertools import product,permutations,combinations,combinations_with_replacement
# 重複あり順列、順列、組み合わせ、重複あり組み合わせ
# import collections # deque
# from operator import itemgetter,mul
# from fractions import Fraction
# from functools import reduce

mod = int(1e9+7)
INF = 1<<29
lINF = 1<<35

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

def main():
    r = int(input())
    print(2*math.pi*r)
    return

if __name__=='__main__':
    main()
#!/usr/bin/env python3
import sys
input = sys.stdin.readline
import math

r = int(input())
print(r * 2.0 * math.pi)
import math

def circle_round(R):
 return 2 * math.pi * R

if __name__ == '__main__':
  R = int(input())
  print(circle_round(R))
import math

R = int(input())
print(2 * math.pi * R)
import math
r = int(input())
p = math.pi
print(2*r*p)
import math
R = int(input())

answer = math.pi * 2 * R

print(answer)
import math

r = int(input())

print(math.pi * r * 2)
#!python3

import math


# input
R = int(input())


def main():
    ans = 2 * R * math.pi
    print(ans)


if __name__ == "__main__":
    main()
import copy
import math
a = int(input())
print(a*2*3.1415926)
from collections import defaultdict as dd
from collections import deque
import bisect
import heapq
import math

def ri():
    return int(input())

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


def solve():
    r = ri()
    print (2 * r * math.pi)






mode = 's'

if mode == 'T':
    t = ri()
    for i in range(t):
        solve()
else:
    solve()
import math

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


def read_ints():
    return list(map(int, input().strip().split(' ')))


def solve():
    R = read_int()
    return (2*R*math.pi)


if __name__ == '__main__':
    print(solve())
n = int(input())
f = 2*3.14159
f *= n
print(f)
R = int(input())

m = 2 * R * 3.14

print(m)
def getLapLen(radius):
    return 2*radius*3.141592

param = int(input())
print(getLapLen(param))
import math

r = int(input())
print(2 * math.pi * r)
import math
N = int(input())
ans = N*2*math.pi


print(ans)
pi = 3.141592653589793238
a=int(input())
print(pi * 2 * a)
N = int(input())

print(N * 2 * 3.14159256)
r = int(input())
print(2 * r * 3.1415926535)
import math
r = int(input())

print(2*3.141592*r)
r = int( input())
print( 3.14 * 2 * r )
import math
r = int(input())
l = 2 * math.pi * r
print(l)
#create date: 2020-04-19 21:00

import sys
stdin = sys.stdin
import math

def ns(): return stdin.readline().rstrip()
def ni(): return int(ns())
def na(): return list(map(int, stdin.readline().split()))

def main():
    r = ni()
    print(2*math.pi*r)

if __name__ == "__main__":
    main()
PI = 3.14159265
def circumference(r):
    return (2 * PI * r)
validation=False
Answer=()


while validation == False:
      R=float(input("Enter a number for the radius of the circle :"))
      if R>=1 and R<=100:
            validation = True
      else:
            break
      

Answer=((R*2)*3.14159)

print(Answer)
# =map(int,input().split())
r=int(input())
print((3.14)*(r**2))
PI = 3.1415
def circumference(r):
  return (2* PI * r)
print ('%.3f' % circumference(5))
import math
 
R = int(input())
ans = R ** 2 * math.pi
print(ans)
r=int(input())
l=r*3.14159265
print(l)
from math import pi

c = float(input())
print(c / (3.0 * pi))
r = input()

pi = 3.1415926535

R = int(r) * pi

print(R)
# -*- coding: utf-8 -*-

R = int(input())

print(R * 3.141592)
r = int(input())
if 0 <= r <= 100:
    length = r * 3.1415926535
    print(length)
import math

r=int(input())

cir = 2 * r * r * math.pi

print(cir)
import sys
input = sys.stdin.readline

R = int(input())

L = 2 * R * 3.141592
R=int(input())
a=float(R*3.141516)
print(a)
import math

r = int(input())

l = 2.0*r*math.pi
from math import pi
R = int(input())
print(R ** 2 * pi)
import math

r=int(input())
k=math.pi

t=math.floor(2*k*r)

print(t)
import math as m
r=int(input())
print(m.pi*r*r)
from math import pi
def cicle(hankei):
    print(2 * hankei * pi)

cicle(1)
cicle(73)
import math
def func(x):
    return math.pi*2*x
  
print(func(5))
from math import pi
def cicle(r):
    return 2 * r * pi
import math
a = int(input())
b = a*math.pi
print(b)
import math
import operator as op
from functools import reduce
 
def ncr(n, r):
    r = min(r, n-r)
    numer = reduce(op.mul, range(n, n-r, -1), 1)
    denom = reduce(op.mul, range(1, r+1), 1)
    return numer / denom
"""
int(input())
map(int,input().split())
list(map(int,input().split()))
"""
s = input("R=")
a = 2*3.1415936535*float(s)
print(a)
LI = lambda: list(map(int,input().split()))
MI = lambda: map(int,input().split())
yes = lambda: print("YES")
no = lambda: print("NO")
I = lambda: list(input())
J = lambda x: "".join(x)
II = lambda: int(input())
SI = lambda: input()
#---khan17---template
t = int(input())
print(3.14*t**2)
import math
 
def round(R):
  return 2*R*math.pi
 
R = int(input())
round(R)
import math
radius = int(input())
answer = math.pi * radius * radius
print(answer)
a=int(input())

print(2*a*6.28318530717958623200)
num = int(input("半径を入力してください"))

import math

num = num * 2 * math.pi

print(num)
import math
x = math.pi
a=input()
n = int(a)
print(n*x)
r = int(input())
pi = 3.1415926535
length = r * pi
print(length)
from math import pi
r = int(input('Enter a number: '))
print(r*pi*2)
from sys import stdin
input = stdin.readline
N=int(input())
A = list(map(int, input().split()))
for n in range(N):
    print(A.count(str(n+1)))
import math

r = int(input())

a = math.pi * r**2

print(a)
num = int(input("半径を入力してください"))

num = num * 2 * 3.14

print(num)
import math
R = int(input())
C = 2 * math.pi * R
print("%.10ef" % C)
import math
R = int(input())

print(R**2 * math.pi)
import math
R = int(input())
ans = R*R*math.pi
print(ans)
import math
r = int(input())
h = round(math.pi,4)
print(r*h)
import math

r=float(input())

L=2*math.pi*r

print('L={0}'.format(L))
R = int(input())
print (2*(3.141592653589793238)*R*R)
import math
radius = float(input("Enter the radius of the circle : "))
circumference = 2 * math.pi * radius
print("Circumference of the circle is : %.2f" % circumference)
R = int(input())
import math
pi = math.pi
print(2 * pi * R ** 2)