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):

def main():
    for _ in inputt(1):
        n, = inputi()
        print(pi * n * 2)
    sys.stdout.flush()







from math import *
from heapq import *
from itertools import *
from functools import reduce, lru_cache, partial
from collections import Counter, defaultdict
import re, copy, operator, cmath
import sys, io, os, builtins
sys.setrecursionlimit(1000)






BUFSIZE = 8192
class FastIO(io.IOBase):
    newlines = 0
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = io.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(io.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):
    sys.stdout.write(kwargs.pop("split", " ").join(map(str, args)))
    sys.stdout.write(kwargs.pop("end", "\n"))
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip()
inputt = lambda t = 0: range(t) if t else range(int(input()))
inputs = lambda: input().split()
inputi = lambda: map(int, inputs())
inputl = lambda t = 0, k = inputi: map(list, (k() for _ in range(t))) if t else list(k())






def len(a):
    if isinstance(a, range):
        return -((a.start - a.stop) // a.step)
    return builtins.len(a)
def bisect_left(a, x, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    if key == None: key = do_nothing
    while lo < hi:
        mid = (lo + hi) // 2
        if key(a[mid]) < x: lo = mid + 1
        else: hi = mid
    return lo
def bisect_right(a, x, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    if key == None: key = do_nothing
    while lo < hi:
        mid = (lo + hi) // 2
        if x < key(a[mid]): hi = mid
        else: lo = mid + 1
    return lo
def insort_left(a, x, key = None, lo = 0, hi = None):
    lo = bisect_left(a, x, key, lo, hi)
    a.insert(lo, x)
def insort_right(a, x, key = None, lo = 0, hi = None):
    lo = bisect_right(a, x, key, lo, hi)
    a.insert(lo, x)
do_nothing = lambda x: x
bisect = bisect_right
insort = insort_right
def index(a, x, default = None, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    if key == None: key = do_nothing
    i = bisect_left(a, x, key, lo, hi)
    if lo <= i < hi and key(a[i]) == x: return a[i]
    if default != None: return default
    raise ValueError
def find_lt(a, x, default = None, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    i = bisect_left(a, x, key, lo, hi)
    if lo < i <= hi: return a[i - 1]
    if default != None: return default
    raise ValueError
def find_le(a, x, default = None, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    i = bisect_right(a, x, key, lo, hi)
    if lo < i <= hi: return a[i - 1]
    if default != None: return default
    raise ValueError
def find_gt(a, x, default = None, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    i = bisect_right(a, x, key, lo, hi)
    if lo <= i < hi: return a[i]
    if default != None: return default
    raise ValueError
def find_ge(a, x, default = None, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    i = bisect_left(a, x, key, lo, hi)
    if lo <= i < hi: return a[i]
    if default != None: return default
    raise ValueError





class Tree:
    def __init__(n):
        self._n = n
        self._conn = [[] for _ in range(n)]
        self._list = [0] * n
    def connect(a, b):
        pass





class Sieve:
    def __init__(self):
        self._n = 6
        self._list = [2, 3, 5, 7, 11, 13]
    def extend(self, n):
        pass


sieve = Sieve()
def isprime(n):
    pass
def prime(n):
    pass
def factorint(n):
    factordict = defaultdict(int)
    for i in sieve:
        if n <= i * i:
            break
        while not n % i:
            factordict[i] += 1
            n //= i
    if n != 1:
        factordict[n] += 1
    return factordict





if __name__ == "__main__":
    main()

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

Solution (Python):
n = float(input())
pi = 3.1415926535
print(2 * pi * n)

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

print(math.pi*2*R)

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

Solution (Python):



import sys


sys.setrecursionlimit(10 ** 6)


r = int(input())
pi = 3.1415926535

print(2 * pi * r)

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

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

Solution (Python):


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

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())

c = 2 * 3.1415926 * r

print(c)

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

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

from math import pi
print(round(2*R*pi,4))

Solution (Python):
pi = 3.141592653589793
radius = int(input())
c = 2 * pi*radius
print(c)

Solution (Python):
import numpy as np

r = int(input())

l = 2.0*r*np.pi

print(l)

Solution (Python):

from sys import stdin
import sys


def nextLine(): return next(stdin)
def nextStrList(): return nextLine().split()
def nextIntList(): return [int(_) for _ in nextStrList()]

import numpy as np

def main():
	r=int(nextLine())
	
	print(2*r*np.pi)
				
	
if __name__=="__main__":
	main()

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

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

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

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

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

Solution (Python):
def circumference(R):
  circum = 2*3.1415*R
  return (circum)
a= int(input())
print(circumference(a))

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

Solution (Python):
import math

t = int(input())

s = 2*math.pi*t
print(s)

Solution (Python):
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

def main():
  r=I()
  return (r*2)*math.pi


print(main())

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

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

print(math.pi * (R+R))

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

Solution (Python):
from math import pi

r = float(input())

print(2*r*pi)

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

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

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

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

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

print(n*2*3.1412)

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

print(2*R*3.14)

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

print(2 * R * 3.14)

Solution (Python):
import math

R = int(input())

circumference_length = 2 * math.pi * R

print(circumference_length)

Solution (Python):
from sys import stdin

def main():

    input = stdin.readline

    r = int(input())

    ans = r * 6.282

    print(ans)
    
if __name__ == "__main__":
    main()

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

print(2*r*3.141592)

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

Solution (Python):
import math
r=int(input())
ans=2*r*math.pi
print ("{0:.4f}".format(ans))

Solution (Python):
import math

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

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

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

Solution (Python):

import math

r = int(input())

ans = 2*r*math.pi

print(ans)

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):
import math
r = float(input())
ans = r *2 * math.pi
print(ans)

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

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():
    N, K = LI()
    S = [0]*(N+2)
    for i in range(1,N+1):
        S[i+1] = S[i] + i
    
    ans = 0
    for i in range(K,N+2):
        cur = (S[N+1] - S[N-i+1]) - (S[i] - S[0]) +1
        ans += cur
        ans %= mod
        

    print(ans)
    return

def examE():
    N = I()
    A = LI()

    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):
r = int(input())

l = 2 * r * 3.14159265358979

print(l)

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

Solution (Python):
import math

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

Solution (Python):
import math

n = int(input())

print(2*n*math.pi)

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

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

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

if __name__ == '__main__':
    main()

Solution (Python):
pi = 3.141592

R = int(input())

print(2*pi*R)

Solution (Python):
R=int(input())
print(R*6.2831853)

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):
R=int(input())
print(R*6.28318530717958623200)

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

Solution (Python):
import sys,math
import numpy as np

r=int(sys.stdin.readline())




print(2*3.141592*r)

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

ans = 2*N*math.pi

print(ans)

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

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

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

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

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

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

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

p = 3.141592653589

print(2*R*p)

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

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

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

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



print(R * 2 * 3.14159265358979323846)

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

    return N * 2 * 3.1415926535

print(main())

Solution (Python):
import math

r = int(input())

print(2 * r * math.pi)

Solution (Python):
import numpy as np
r = float(input())
print('%.5f' % (2.0*np.pi*r))

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

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

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

print(ans)

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

Solution (Python):
import math

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

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

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

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

Solution (Python):
import math

a=int(input())

print(math.pi*2*a)

Solution (Python):
import math

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

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

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

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

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

Solution (Python):
import math

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

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

print(2*r*3.14)

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

solution()

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):



r = int(input())

ans = r * 2 * 3.14159265

print(ans)

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

Solution (Python):
import math

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

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

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

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

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

Solution (Python):
from math import pi


def resolve():

    r = int(input())

    print(r*2*pi)
    
resolve()

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):
a=int(input())
print(a*2*3.1415926)

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

Solution (Python):
import math
n = int(input())
print("{0:.20f}".format(2*n*math.pi))

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

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

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

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

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

print(2*r*pi)

Solution (Python):




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



def int1(x):
    return int(x) - 1



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



def input_to_int_tuple():
    return tuple(map(int, input().split()))



def input_to_int_tuple_minus1():
    return tuple(map(int1, input().split()))


def main():
    import math
    r = input_int()

    return r * 2 * math.pi


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

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

Solution (Python):

pi = 3.14159265358979
n = int(input())
print(2*n*pi)

Solution (Python):
import math

t = int(input())

s = 2*math.pi*t
print(s)

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

Solution (Python):
import math


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


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

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

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())

print(r*2*3.141592)

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

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()
    pi2 = 6.28318530717958623200
    print(R*pi2)

if __name__ == '__main__':
    main()

Solution (Python):
import math

r = input()

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

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

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

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

print(2*pi*R)

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

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

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

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

m = 2 * R * 3.14

print(m)

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

Solution (Python):
from heapq import *
import sys
from collections import *
from itertools import *
from decimal import *
import copy
from bisect import *
import time
import math
def gcd(a,b):
    if(a%b==0):return(b)
    return (gcd(b,a%b))
print(int(input())*2*math.pi)

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

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

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

Solution (Python):
PI = 3.141592

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

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

Solution (Python):
import math
math.pi

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

Solution (Python):
import math

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

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

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

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

print(2*R*math.pi)

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

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

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

R = int(input())

L = 2 * R * 3.14

print(L)

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

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

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

Solution (Python):
import math

R = int(input())

print(2*R*math.pi)

Solution (Python):



import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys

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

Solution (Python):
import math

r = int(input())

print(r * 2 * math.pi)

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

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

Solution (Python):
from numpy import *
x= int(input())
print(pi*x*2)

Solution (Python):
import numpy as np

R = int(input())

circle_pond = 2*R*np.pi
print(circle_pond)

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

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

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

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque

from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi

def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [LI()for i in range(n)]



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

Solution (Python):
import math

radius = float(input())

circumference = 2 * math.pi * radius

print(circumference)

Solution (Python):
import math

R = int(input())

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

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

x = math.pi

ans = r*x*2
print(ans)

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

Solution (Python):
import math

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

Solution (Python):
import math

PI=math.pi

R=int(input())

print(2*R*PI)

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

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

Answer = R*2*3.14159265359

print(Answer)

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


print(2*r*pi)

Solution (Python):
import math

R = int(input())

print(R*2*math.pi)

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

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())
L=2*R*3.14159265359
print(L)

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

Solution (Python):
import math

r = int(input())

print(2 * math.pi * r)

Solution (Python):


import math

radius = int(input())





result = radius * math.pi *2


print(result)

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

Solution (Python):
from sys import stdin, stdout
import math,sys
from itertools import permutations, combinations
from collections import defaultdict,deque,OrderedDict
import bisect as bi
import heapq 
'''


def I():return (int(stdin.readline()))
def In():return(map(int,stdin.readline().split()))
'''



def I():return (int(input()))
def In():return(map(int,input().split()))

def find_gt(a, x):
    
    i = bi.bisect_right(a, x)
    if i != len(a):
        return i
    else:
        return -1


def main():
    try:
        n=I()
        n=math.pi*n*2
        print(round(n,2))

            
    except:
        pass
M = 998244353
P = 1000000007

if __name__ == '__main__':
    main()

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

Solution (Python):
x = float(input())
print(x*2*3.14)

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

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 = int(input())

c = 2*math.pi*r

print(c)

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

Solution (Python):
def solve():
  r = int(input())
  print(2*r*3.1415926535)
  return 0
 
if __name__ == "__main__":
  solve()

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

Solution (Python):
from math import acos
r = int(input())
print(2*acos(-1)*r)

Solution (Python):
import math

r = int(input())

print(2 * r * math.pi)

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

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

Solution (Python):
import math 

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

resolve()

Solution (Python):
import math

r = int(input())

print(2*r*math.pi)

Solution (Python):
import numpy as np

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

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

Solution (Python):
pi = 6.28318530717958623200
n = int(input())
print(n*pi)

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):
from math import pi
r = float(input())

print(2*pi*r)

Solution (Python):
def main():
  import math
  x = int(input()) * 6.283185307179586232
  print(x)
    
main()

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

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

Solution (Python):
import math

X = int(input())
A = X*2*math.pi
print(A)

Solution (Python):
import math

r=int(input())


print(2*r*3.1415926535)

Solution (Python):
n = int(input())
a = n/0.1591549431
print(a)

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

Solution (Python):
import math
R = int(input())
if R>=0 and R<=100:
    C = 2*math.pi*R
    print(C)

Solution (Python):

R = int(input())


print(2*R*3.14159265)

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

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

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

Solution (Python):
import math
def main():
    N = int(input())
    print("{:.20f}".format(2*N*math.pi))
if __name__ == '__main__':
    main()

Solution (Python):
import sys

X = int(sys.stdin.readline().rstrip())

print(2 * X * 3.141592653589793)

Solution (Python):
import math

def circle_round(radius):
  return 2 * math.pi * radius
print (circle_round(int(input())))

Solution (Python):
import math

n=float(input())


print(n*2*math.pi)

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

Solution (Python):
from math import pi

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

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

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

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

print(2*n*3.1415926535)

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):
import math
R =float (input())
cir = 2*math.pi*R
print(cir)

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

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

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

Solution (Python):
print(int(input())*6.283)

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

print(2*3.14159265358979323846264338327*r)

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

Solution (Python):
r = int(input())
ans = 44*100*r//7
ans = ans/100
print(ans)

Solution (Python):



r = int(input())

print(2 * (3.14) * r)

Solution (Python):
pi =3.141592653589793

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

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

Solution (Python):
x = float(input())
print(x * 2 * 3.14159265358979)

Solution (Python):
import math

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

e=2*n*p

print(round(e,3))

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

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

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

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

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()
import numpy as np
def main():
    r=int(input())
    print(2*np.pi*r)

if __name__=='__main__':
    main()

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

Solution (Python):
import sys

stdin = sys.stdin
     
pi=3.1415
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))

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

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

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

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

Solution (Python):


P = int(input())

import math

print (P*2 * math.pi)

Solution (Python):
def solution():
    return 1

def main():
    N = int(input())
    pi = 3.14159265359
    print(2 * pi * N )
        
   
if __name__ == "__main__":
    main()

Solution (Python):
p=3.14159265
n=int(input(''))
print(n*p*2)

Solution (Python):


import sys
import math

DEBUG = False

def read(t):
    return t(sys.stdin.readline().rstrip())


def read_list(t, sep = " "):
    return [t(s) for s in sys.stdin.readline().rstrip().split(sep)]


def dprint(*args, **kwargs):
    if DEBUG:
        print(*args, **kwargs)
    return


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


if __name__ == "__main__":
    main()

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

Solution (Python):
import math
r = float(input())
print('{:.5f}'.format(2.0*r*math.pi))

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

Solution (Python):

i = int(input())
print(i * 2 * 3.141592653589793238462643383279)

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

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

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

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*r*math.pi)

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

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque

from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi

def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [LI()for i in range(n)]



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