Problem:
 Score : 100 points    Problem Statement Print the circumference of a circle of radius R .      Constraints  1 \leq R \leq 100  All values in input are integers.         Input Input is given from Standard Input in the following format:  R       Output Print the circumference of the circle.
Your output is considered correct if and only if its absolute or relative error from our answer is at most 10^{-2} .        Sample Input 1 1      Sample Output 1 6.28318530717958623200  Since we accept an absolute or relative error of at most 10^{-2} , 6.28 is also an acceptable output, but 6 is not.       Sample Input 2 73      Sample Output 2 458.67252742410977361942

Solution (Python):











import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,sqrt,factorial,hypot,log,pi 
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from fractions import gcd
from random import randint
def ceil(a,b): return (a+b-1)//b
inf=float('inf')
mod = 10**9+7
def pprint(*A): 
    for a in A:     print(*a,sep='\n')
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    R=I()
    print(pi*R*2)
if __name__ == '__main__':
    main()

Solution (Python):
import math
n = int(input())
print (2*math.pi*n)

Solution (Python):

r=int(input())

import math 

res=2*r*math.pi

print(res)

Solution (Python):


R = int(input())

ans = 2*R*3.14

print(ans)

Solution (Python):
import math

r = int(input())
print('{:.20f}'.format(2 * r * math.pi))

Solution (Python):
import math
r = int(input())
pi = math.pi
print(2*r*pi)

Solution (Python):
import math
r=int(input())
print(2*r*math.pi)

Solution (Python):
r  = int(input())
import math
print(r*2*math.pi)

Solution (Python):
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)

Solution (Python):
import math
N = int(input())
print(N*math.pi*2)

Solution (Python):
import math
n=int(input())
ans=math.pi*2*n
print(ans)

Solution (Python):
def main():

    r = int(input())
    return 2 * r * 3.14159265359

if __name__ == '__main__':
    print(main())

Solution (Python):
import math
R = int(input())
L = 2*R*math.pi
print(L)

Solution (Python):
pi = 3.141592653589793
r = float(input())
print(2*r*pi)

Solution (Python):
import math
 
r = int(input())
print(r * 2 * math.pi)

Solution (Python):
import math
r=int(input())
print(r*2*math.pi)

Solution (Python):
R = int(input())
print(2 * R * 3.14)

Solution (Python):
import math
a = int(input())
print(a*2*math.pi)

Solution (Python):
R = int(input())

print(2*R*3.141592)

Solution (Python):
import math

r = int(input())

print(2 * r * math.pi)

Solution (Python):
import math

R = int(input())
R = 2*R*math.pi

print(R)

Solution (Python):
r = int(input())
import math
print(2*math.pi*r)

Solution (Python):
import math
print(math.pi*int(input())*2)

Solution (Python):
import math
r= int(input())
ans=math.pi*2*r
print(ans)

Solution (Python):
import math
r = int(input())

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

Solution (Python):
import math

R = int(input())

print(2*R*math.pi)

Solution (Python):
a=int(input())
print(a * 2 * 3.1415)

Solution (Python):
r=int(input())
import numpy as np
pi = np.pi
print(2*r*pi)

Solution (Python):
import math
rad = float(input())
print(rad*2*math.pi)

Solution (Python):
import math

from decimal import Decimal, getcontext

getcontext().prec = 99


def resolve():
    R = int(input())

    print(R * 2 * math.pi)


resolve()

Solution (Python):
import math
R = int(input())
print(2*R*math.pi)

Solution (Python):
from math import pi
r=int(input())
print(2*(pi*r))

Solution (Python):
import math
t=int(input())
print(2*math.pi*t)

Solution (Python):
from math import pi

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

Solution (Python):
import math
def main():

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

if __name__ == "__main__":
    main()

Solution (Python):
import sys
import math
sys.setrecursionlimit(1000000)

def solve(N):
    return 2 * N * math.pi

if __name__ == "__main__":
    N = int(input())
    print(solve(N))

Solution (Python):
n = int(input())
mid = n*2
print(mid*3.14)

Solution (Python):
R=int(input())
print(R*2*3.14)

Solution (Python):
r = int(input())
print(2*r*3.14159265)

Solution (Python):
import math
print(2*int(input())*math.pi)

Solution (Python):

import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1

def main():
    print(int(input())*2*3.1415926535)

if __name__ == '__main__':
    main()

Solution (Python):
t = float(input())
pi = 3.141592653589793
print(2*pi*t)

Solution (Python):
a = int(input())
print(a*2*3.141592)

Solution (Python):

import math

R = int( input() )

ans = R*2*math.pi

print(ans)

Solution (Python):
N = int(input())

import math

print(2*N*math.pi)

Solution (Python):
N = int(input())

print(N * 2 * 3.14159256)

Solution (Python):
import math
R=int(input())
print(math.pi*R*2)

Solution (Python):
r = int(input())
print(2 * 3.141592 * r)

Solution (Python):
import math
r = float(input())
print(2*r*math.pi)

Solution (Python):
r=int(input())

print(r*2*3.141)

Solution (Python):
from math import *
test = 1

for __ in range(test):
	r = int(input())
	print(3.1415926*2*r)

Solution (Python):
import math
R = int(input())
a=math.pi
print(a*2*R)

Solution (Python):
import math  
import bisect  
import queue  


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

Solution (Python):
import sys
import os
from io import BytesIO, IOBase






'''def sieve(n):
    if n < 2: return list()
    prime = [True for _ in range(n + 1)]
    p = 3
    while p * p <= n:
        if prime[p]:
            for i in range(p * p, n + 1, p):
                prime[i] = False
        p += 2
    r = [2]
    for p in range(3, n + 1, 2):
        if prime[p]:
            r.append(p)
    return r'''


'''def divs(n, start=1):
    divisors = []
    for i in range(start, int(n**.5) + 1):
        if n % i == 0:
            if n / i == i:
                divisors.append(i)
            else:
                divisors.extend([i, n // i])
    return len(divisors)'''


'''def divn(n, primes):
    divs_number = 1
    for i in primes:
        if n == 1:
            return divs_number
        t = 1
        while n % i == 0:
            t += 1
            n //= i
        divs_number *= t
    return divs_number'''


'''def flin(d, x, default=-1):
    left = right = -1
    for i in range(len(d)):
        if d[i] == x:
            if left == -1: left = i
            right = i
    if left == -1:
        return (default, default)
    else:
        return (left, right)'''


'''def xor1_n(n):
    d={0:n,1:1,2:n+1,3:0}
    return d[n&3]'''

def cel(n, k): return n // k + (n % k != 0)
def ii(): return int(input())
def mi(): return map(int, input().split())
def li(): return list(map(int, input().split()))
def lcm(a, b): return abs(a * b) // math.gcd(a, b)
def prr(a, sep=' '): print(sep.join(map(str, a)))
def dd(): return defaultdict(int)
def ddl(): return defaultdict(list)
def ddd(): return defaultdict(defaultdict(int))



BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

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

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

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

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


class IOWrapper(IOBase):
    def __init__(self, file):
            self.buffer = FastIO(file)
            self.flush = self.buffer.flush
            self.writable = self.buffer.writable
            self.write = lambda s: self.buffer.write(s.encode("ascii"))
            self.read = lambda: self.buffer.read().decode("ascii")
            self.readline = lambda: self.buffer.readline().decode("ascii")


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

from collections import defaultdict 


from math import gcd,pi















r=ii()
print(2*pi*r)

Solution (Python):
import math
R = int(input())

print(2*math.pi*R)

Solution (Python):
import sys
import numpy as np
import math
from collections import deque 
from functools import reduce



r = int(input())

print(2*r*math.pi)

Solution (Python):
import sys
input = sys.stdin.readline
from math import pi

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

Solution (Python):
import math
a=int(input())
print(a*2*math.pi)

Solution (Python):
from math import pi
R = int(input())
a = 2*pi*R
print(a)

Solution (Python):

from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect

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


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


def LS(): return [list(x) for x in sys.stdin.readline().split()]


def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res


def IR(n):
    return [I() for i in range(n)]


def LIR(n):
    return [LI() for i in range(n)]


def SR(n):
    return [S() for i in range(n)]


def LSR(n):
    return [LS() for i in range(n)]


sys.setrecursionlimit(1000000)
mod = 1000000007


def solve():
    r = I()
    print(2*r*3.14159265358979)
    return


if __name__ == "__main__":
    solve()

Solution (Python):
import math
math.pi

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

Solution (Python):
import math
r = int(input())
print(math.pi*r*2)

Solution (Python):
r = int(input())
print(2*r*3.14)

Solution (Python):
from math import pi

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

Solution (Python):
from math import pi
n = int(input())
p = 2 * pi * n
print(p)

Solution (Python):
import math
R=int(input())
print(2.0*math.pi*R)

Solution (Python):
from math import pi


def main():
    print(2 * pi * int(input()))


if __name__ == '__main__':
    main()

Solution (Python):
r=int(input())
print(2*3.147*r)

Solution (Python):


import math

R = int(input())

print(2*math.pi*R)

Solution (Python):
import math
r=float(input())
print(2*r*math.pi)

Solution (Python):
import  math

r=int(input())

print(2*r*math.pi)

Solution (Python):
import math


R = int(input())
print(2.0*R*math.pi)

Solution (Python):

import math 

r = int(input())

print(r*2*math.pi)

Solution (Python):
import math
def circle_round(radius):
  return 2 * math.pi * radius

x=(int)(input())
print(circle_round(x))

Solution (Python):
import math
R = int(input())

print(2*math.pi*R)

Solution (Python):
r=int(input())

print(str(2*r*3.14159265))

Solution (Python):
n=int(input())
print(n*2*(22/7))

Solution (Python):
R = int(input())
import math
print(2*R*math.pi)

Solution (Python):
import math

R = int(input())
Ans = 2* R * math.pi

print(Ans)

Solution (Python):
import math
R = int(input())

print(2 * math.pi * R)

Solution (Python):
a = int(input())
print(a * 3.141592 * 2)

Solution (Python):
import math

R = int(input())


print(R*2*math.pi)

Solution (Python):
R = int(input())

import math
PI = math.pi

print(2 * PI * R)

Solution (Python):
import math
print(2*int(input()) * math.pi)

Solution (Python):
import math

r = int(input())

print(2 * r * math.pi)

Solution (Python):
import numpy
R = int(input())

print(2 * R * numpy.pi)

Solution (Python):
print(int(input())*2*3.14159265358979323846)

Solution (Python):
r=int(input())
r=r*2
print(r*3.141592)

Solution (Python):
import math

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

Solution (Python):
r = int(input())
pi = 3.1415926535
aa = 2*pi*r
print(aa)

Solution (Python):
R = int(input())
print(2 * R * 3.14159)

Solution (Python):

import numpy as np

a = int(input())
print(a * 2 * np.pi)

Solution (Python):
import sys
input = sys.stdin.readline
import math

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


if __name__ == "__main__":
    main()

Solution (Python):
x = int(input())
print(3.141592*x*2)

Solution (Python):
r = int(input())
pi = 3.1415926
l = 2*pi*r
print(l)

Solution (Python):
import math
R = int(input())

print(2*math.pi*R)

Solution (Python):
R = int(input())
print(2 * R * 3.14)

Solution (Python):
r=int(input())

import math

print(2*r*math.pi)

Solution (Python):
import math

r = int(input())

print(2 * math.pi * r)

Solution (Python):
from decimal import *
R = int(input())
print(Decimal((R*2)*3.14))

Solution (Python):
r = int(input())
print(2 * 3.14 * r)

Solution (Python):
import math
r=int(input())
print(2*math.pi*r)

Solution (Python):
user = int(input())
print((3.14)*2*user)

Solution (Python):
import math

R=int(input())

print(2*math.pi*R)

Solution (Python):
a = 6.28318530717958623200
N = int(input())
print(a*N)

Solution (Python):
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()))

def LLI(rows_number): return [LI() for _ in range(rows_number)]

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

Solution (Python):
import math
x = int(input())
print(math.pi * 2 * x)

Solution (Python):
import math

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

Solution (Python):
import math

R = int(input())

print(2 * math.pi * R)

Solution (Python):
r=int(input())
print(2*r*3.141592)

Solution (Python):
import sys
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mod = 10**9 + 7

import math

R = ri()
l = 2 * math.pi * R
print(l)

Solution (Python):
import math
r = int(input())
print(r * 2 * math.pi)

Solution (Python):
import math

radius = int(input(""))

cir = 2 * math.pi * radius

print("%f" % cir)

Solution (Python):
import sys,os
from collections import defaultdict, deque
from math import ceil, floor
if sys.version_info[1] >= 5:
    from math import gcd
else:
    from fractions import gcd
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = (lambda *something: print(*something)) if 'TERM_PROGRAM' in os.environ else lambda *x: 0
def main(given=sys.stdin.readline):
    input = lambda: given().rstrip()
    LMIIS = lambda: list(map(int,input().split()))
    II = lambda: int(input())
    MOD = 10**9+7

    R = II()
    from math import pi
    print(R*2*pi)

if __name__ == '__main__':
    main()

Solution (Python):
import math
n = int(input())

print(2*n*math.pi)

Solution (Python):
N = int(input())
print(N*2*3.141592648777)

Solution (Python):
import numpy as np
R = int(input())
print(2* np.pi * R)

Solution (Python):
R = int(input())
print(2 * 3.14 * R)

Solution (Python):
import math
N = int(input())
print(2*N*math.pi)

Solution (Python):
import math
s=int(input())
print(s*2*math.pi)

Solution (Python):
import math
r=int(input())

print(2*r*math.pi)

Solution (Python):
r = int(input())

print(r*2*3.141592)

Solution (Python):
import math
R=float(input())
a=2*R*math.pi
print(a)

Solution (Python):
import math
i = int(input())
print(i * 2 * math.pi)

Solution (Python):
import math
math.pi
N = int(input())
print(N*math.pi*2)

Solution (Python):
def main():
    r = int(input())
    print((r * 2)*3.14)

main()

Solution (Python):
from math import pi

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

Solution (Python):
import math
n = int(input().strip())
print(n*2*math.pi)

Solution (Python):
import math

R = int(input())

print(2*math.pi*R)

Solution (Python):
import math

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

Solution (Python):
N = int(input())
print(N * 2 *  3.1415)

Solution (Python):
R = int(input())
print(3.1415926535*R*2)

Solution (Python):
from math import pi
n = int(input())
print(2 * pi * n)

Solution (Python):
R=input()
print(3.14*2*int(R))

Solution (Python):
def examA():
    R = I()
    ans = R*2*3.141592
    print(ans)
    return

def examB():
    N, M = LI()
    A = LI()
    S = sum(A)
    if N>=S:
        ans = N-S
    else:
        ans = -1
    print(ans)
    return

def examC():
    N = I()
    A = LI()
    ans = [0]*N
    for i in range(N-2,-1,-1):
        ans[A[i]-1] +=1
    for v in ans:
        print(v)
    return

def examD():
    ans = 0
    print(ans)
    return

def examE():
    ans = 0
    print(ans)
    return

def examF():
    ans = 0
    print(ans)
    return

import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(readline())
def LI(): return list(map(int,readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]

sys.setrecursionlimit(10**7)

if __name__ == '__main__':
    examA()

"""
142
12 9 1445 0 1
asd dfg hj o o
aidn
"""

Solution (Python):
import math

r = int(input())

print(2 * math.pi * r)

Solution (Python):
import numpy as np

R = int(input())

print(2*R*np.pi)

Solution (Python):
import math
N=float(input())


print(2.*N*math.pi)

Solution (Python):
from math import pi
print(int(input()) * pi * 2)

Solution (Python):
r = int(input())
import math

print(2*math.pi*r)

Solution (Python):


import math

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

     ans = 2 * r * math.pi
     print(ans)

if __name__ == "__main__":
    main()

Solution (Python):
import math

R = int(input())

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

Solution (Python):
R = int(input())
PI = 3.14159265
print(R * 2 * PI)

Solution (Python):
r = int(input())
print(2*r*3.14159265)

Solution (Python):
def main():
    pi = 3.14159265
    r = int(input())
    print(2*pi*r)

if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
f = 2*3.14159*n
print(f)

Solution (Python):
import numpy as np
R = int(input())

print (2.0*R*np.pi)

Solution (Python):
import numpy as np
R = int(input())
print(2*R*np.pi)

Solution (Python):
R = int(input())
import math
print(2 * math.pi * R)

Solution (Python):
import sys
input = sys.stdin.readline


import math

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

Solution (Python):
import math

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

Solution (Python):
import math
r = int(input())
ans = r*2*math.pi
print(ans)

Solution (Python):


from pprint import pprint
import sys

import math

sys.setrecursionlimit(10 ** 6)
input = sys.stdin.buffer.readline

r = int(input())

print(2 * math.pi * r)

Solution (Python):
r = int(input())
from math import pi
print(2*r*pi)

Solution (Python):
from math import pi
R = input()
print(float(2)*pi*float(R))

Solution (Python):
import math
r = int(input())
print(2*r*math.pi)

Solution (Python):
import math
a=int(input())
print(math.pi*2*a)

Solution (Python):
import math

R=int(input())

print(2*R*math.pi)

Solution (Python):
r = int(input())
print(6.28*r)

Solution (Python):
import sys
input=sys.stdin.readline

















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

Solution (Python):
R = float(input())
print(2*3.14159*R)

Solution (Python):
import math

a = int(input())

print(2*a*math.pi)

Solution (Python):
import numpy as np
r=int(input())

pi=np.pi

print(r*2*pi)

Solution (Python):
import math
r = int(input())
print(2*r*math.pi)

Solution (Python):
import math                                                                     
r = int(input())
 
print(2*r * math.pi)

Solution (Python):
r=int(input())
print(r*2*3.14159265)

Solution (Python):
a = int(input())
print (3.14*2*a)

Solution (Python):
r=int(input())
pi=3.14159265358979
print(2*pi*r)

Solution (Python):
import numpy as np

R=int(input())

print(2*np.pi*R)

Solution (Python):
import math
R = int(input())
print(R * 2 * math.pi)

Solution (Python):
R=int(input())
ans=2*R*3.14
print(ans)

Solution (Python):
import math
r = int(input())
print(math.pi*2*r)

Solution (Python):
r = int(input())
print(2 * r * 3.14)

Solution (Python):
A=int(input())
print(A*2*3.141)

Solution (Python):
r=int(input())
print(2*3.141592653589793*r)

Solution (Python):
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))

print(inp()*2*math.pi)

Solution (Python):
r = int(input())
print(2*r*3.14)

Solution (Python):






import sys
input = sys.stdin.readline

import math
from collections import deque
from fractions import gcd
from functools import lru_cache






MOD = 10**9+7
INF = float('inf')






def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]


def inv(n): return pow(n, MOD-2, MOD)


kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret


def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])
    return arr


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





R = inputI()

print(R*3.1415926535*2)

Solution (Python):
import math
N = int(input())
print(format(2*N*math.pi,'.20f'))

Solution (Python):


import sys
import math
import collections
import itertools
from inspect import currentframe
INF = 10 ** 10
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def gcd(x, y) : return y if x % y == 0 else gcd(y, x % y)
def lcm(x, y) : return (x * y) // gcd(x, y)
def I() : return int(input())
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(input()) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]

R = I()

print(R*2*math.pi)

Solution (Python):
import math
R = int(input())
print(2 * math.pi * R)

Solution (Python):
import math

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

Solution (Python):
r = int(input())

print(3.14159265 * 2 * r)

Solution (Python):
import math
r = int(input())
print(r * math.pi *2)

Solution (Python):
import math
R=int(input())
print(2*R*math.pi)

Solution (Python):
import math

R = int(input())

print(R*2*math.pi)

Solution (Python):
import math
R = int(input())
print(2*R*math.pi)

Solution (Python):
from math import pi
r = int(input())
enshu = 2*pi*r
print(enshu)

Solution (Python):
import math
n = int(input())
print(2* math.pi * n)

Solution (Python):
import math
R = int(input())
print(2* R * math.pi)

Solution (Python):
import math
math.pi
R = int(input())
print(R * math.pi * 2)

Solution (Python):
import math
N=int(input())
print((math.pi)*2*N)

Solution (Python):

from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect

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


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


def LS(): return [list(x) for x in sys.stdin.readline().split()]


def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res


def IR(n):
    return [I() for i in range(n)]


def LIR(n):
    return [LI() for i in range(n)]


def SR(n):
    return [S() for i in range(n)]


def LSR(n):
    return [LS() for i in range(n)]


sys.setrecursionlimit(1000000)
mod = 1000000007


def solve():
    r = I()
    print(2*r*3.14159265358979)
    return


if __name__ == "__main__":
    solve()

Solution (Python):
import math

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

Solution (Python):
import numpy as np
r = float(input())
py = np.pi
print(2.0 * r * py)

Solution (Python):
import math
R = int(input())
print(2*R*math.pi)

Solution (Python):
import numpy as np

print(int(input()) * 2 * np.pi)

Solution (Python):
import math
R = int(input())
print(2*math.pi*R)

Solution (Python):
import math
R= int(input())
ci=2*R*math.pi
print(ci)

Solution (Python):
import math

PI=math.pi

R=int(input())

print(2*R*PI)

Solution (Python):
import math
N = int(input())
ans = N*2*math.pi


print(ans)

Solution (Python):
from sys import stdin
import math
import fractions

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

print(2 * n * math.pi)

Solution (Python):
import sys
from math import sqrt, pi
from collections import Counter, defaultdict, deque

input = sys.stdin.readline
sys.setrecursionlimit(10 ** 6)


def I():
    return int(input())


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


def LI():
    return list(MI())


def LIN(n: int):
    return [I() for _ in range(n)]


inf = float("inf")
mod = 10 ** 9 + 7


def main():
    r = I()
    print(2 * r * pi)


if __name__ == "__main__":
    main()

Solution (Python):
a = int(input())
b = 3.14159
print(a*b*2)

Solution (Python):
import math
r = int(input())
ans = 2*math.pi*r
print(ans)

Solution (Python):
r=int(input())
import math
print('{:.8f}'.format(math.pi*r*2))

Solution (Python):
print(int(input()) * 2 * 3.1415926)

Solution (Python):
r=int(input())
print(2*3.14*r)

Solution (Python):
import math

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

print(r*2*x)

Solution (Python):
r = int(input())
import math

print(math.pi * r *2)

Solution (Python):
import math
r = int(input())
print(r*2*math.pi)

Solution (Python):
import math

R = int(input())

print(2*math.pi*R)

Solution (Python):
import math
R = int(input())

ans = 2 * math.pi * R
print(ans)

Solution (Python):
PI = 3.141592653589793
R = int(input())

print(2*R*PI)

Solution (Python):
import math
N = int(input())

print(2 *3.141592*N)

Solution (Python):
x = int(input())
pi = 3.14159

print(2 * x * pi)

Solution (Python):
import math
r = int(input())

print(round(2*r*math.pi,6))

Solution (Python):
import math
print(2*(math.pi)*int(input()))

Solution (Python):
import math

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

Solution (Python):
import sys
input = sys.stdin.readline

def main():
    R = int(input())
    print(2*R*3.1415926)


if __name__ == '__main__':
    main()

Solution (Python):
import math
R = int(input())

print(2*R*math.pi)

Solution (Python):
import math

N = int(input())

print((2*N)*math.pi)

Solution (Python):
import math
r = int(input())
p=math.pi
print(2*r*p)

Solution (Python):


import math

r=int(input())

print(r*2*math.pi)

Solution (Python):
import math
R = int(input())
print(2 * math.pi * R)

Solution (Python):
import math

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

Solution (Python):
R = int(input())
print(3.141592*2*R)

Solution (Python):
import math
r = int(input())
print(2*r*math.pi)

Solution (Python):
import math
r = int(input())
print(2*math.pi*r)

Solution (Python):
import math

R = float(input())

print(2*R*math.pi)

Solution (Python):
n=int(input())

print(2*(22/7)*n)

Solution (Python):
import math
print(float(input()) * math.pi * 2)

Solution (Python):


P = int(input())

import math

print (P*2 * math.pi)

Solution (Python):
import math

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


print(R)

Solution (Python):
import math
R=int(input())
print(2*math.pi*R)

Solution (Python):
import math
R = int(input())
ans = 2 * R * math.pi
print(ans)

Solution (Python):
from math import pi
r = int(input())
print(2*pi*r)

Solution (Python):
import math
math.pi
print(2.0*math.pi*int(input()))

Solution (Python):
import math
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()

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

Solution (Python):
import math as m

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

Solution (Python):
from math import pi
n=int(input())
print(2*pi*n)

Solution (Python):
import math
r = int(input())

print(2*r*math.pi)

Solution (Python):
import math

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

Solution (Python):
N=int(input())
import math
print(math.pi*2*N)

Solution (Python):
import math

b=int(input())

print(math.pi*b*2)

Solution (Python):

"""
Created on Sun Apr 19 20:41:02 2020

@author: Kanaru Sato
"""
import math

r = int(input())

print(2*r*math.pi)

Solution (Python):


import sys
import math


debug = False

def log(text):
    if debug:
        print(text)

def parse_input(lines_as_string = None):

    global debug
    lines = []
    if lines_as_string is None:
        debug = False
        
        
        lines.append(input())
    else:
        debug = True
        lines = [e for e in lines_as_string.split("\n")][1:-1]

    (r, ) = [int(e) for e in lines[0].split(' ')]

    return (r, )


def solve(r):

    
    return  2 * r * math.pi
    


def main():
    
    result = solve(*parse_input())
    if isinstance(result, list):
        for r in result:
            print("%s" % r, sep='')
    else:
        print("%s" % result, sep='')

if __name__ == '__main__':

    main()