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


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

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

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

print(ans)

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):
import math
r = float(input())
print("{:.10}".format(2.0 * math.pi * r))

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

Solution (Python):
import math
if __name__ == "__main__":
	r = int(input())
	pi = math.pi

	print(2*pi*r)

Solution (Python):
import math

n=int(input())

print(2*n*math.pi)

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

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

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

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

Solution (Python):

R = int(input())


print(2*R*3.14159265)

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

Solution (Python):
from math import pi
x=int(input())
print('%.4f'%(2*pi*x))

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

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

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

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

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

print(2 * r * pi)

Solution (Python):
K_s = input()
K = int(K_s)

print(2*K*3.1415926535)

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

print(R * 2 * 3.141592653589793)

Solution (Python):

import math


a = int(input())

print(a*2*math.pi)

Solution (Python):

import math


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


if __name__ == '__main__':
    run()

Solution (Python):
import math

a = int(input())

print(2*a*math.pi)

Solution (Python):



import math


R = int(input())


print(2*math.pi*R)

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

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

print(R*2*H)

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

print(2*3.14159265358979323846264338327*r)

Solution (Python):
import os

import math
import sys

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7



r = int(sys.stdin.buffer.readline())
a = r * 2 * math.pi
print(a)

Solution (Python):
import sys

def main():

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

if __name__ == "__main__":
    main()

Solution (Python):

R = int(input())

print(R*2*3.14159265359)

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

Solution (Python):
import math

radius = float(input())

circumference = 2 * math.pi * radius

print(circumference)

Solution (Python):
from sys import setrecursionlimit, exit
setrecursionlimit(1000000000)
import math


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

main()

Solution (Python):

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








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

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 = int(input())
print(2*r*math.pi)

Solution (Python):



import math


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


if __name__ == '__main__':
    main()

Solution (Python):
def getLapLen(radius):
    return 2*radius*3.141592

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

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

print(R*2*math.pi)

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

main()

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

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

print(6.283185 * r)

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

Solution (Python):
import math
import sys

stdin = sys.stdin

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()))
mod = 10**9 + 7 
sys.setrecursionlimit(1000010)


R = ni()
print(float(R)*3.141592653 * 2 )

Solution (Python):
from sys import stdin

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

pi = 3.141592

print(pi*R*2)

Solution (Python):
import math

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

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

Solution (Python):
import math

R = int(input())

l = 2*R*math.pi

print(l)

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

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

print(2*r*math.pi)

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

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

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

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

import math

print(math.pi* 2 * r)

Solution (Python):


import math

R = int(input())

print(2 * R * math.pi)

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

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

print(3.1415926535 * a * 2)

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

L = 2*N*3.1415
print(L)

Solution (Python):
import math

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

e=2*n*p

print(round(e,3))

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

if a>=1 and a<=100:
    print(2*int(a)*b)
    
else:
    pass

Solution (Python):
R=int(input())
import math
pi=math.pi
if 1<=R<=100:
    s=pi*2*R
    print(s)

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


print(2.*N*math.pi)

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

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

Solution (Python):
import math

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

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

Solution (Python):
from sys import stdin
import math
n = int(stdin.readline().rstrip())
print(2*n*math.pi)

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

print(2 * 3.1415926535 * R)

Solution (Python):
import math

N=int(input())

print(math.pi*N*2)

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

Solution (Python):
import math

n = int(input())

print(2 * n * math.pi)

Solution (Python):
import sys

input_methods=['clipboard','file','key']
using_method=0
input_method=input_methods[using_method]

IN=lambda : map(int, input().split())
mod=1000000007



ppi=3.14159265358979

def main():
	a = int(input())
	print(a*2*ppi)
	
	
	
	
	

isTest=False

def pa(v):
	if isTest:
		print(v)
		
def input_clipboard():
	import clipboard
	input_text=clipboard.get()
	input_l=input_text.splitlines()
	for l in input_l:
		yield l

if __name__ == "__main__":
	if sys.platform =='ios':
		if input_method==input_methods[0]:
			ic=input_clipboard()
			input = lambda : ic.__next__()
		elif input_method==input_methods[1]:
			sys.stdin=open('inputFile.txt')
		else:
			pass
		isTest=True
	else:
		pass
		
			
	ret = main()
	if ret is not None:
		print(ret)

Solution (Python):
print(3.142857*2.0*float(input()))

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

Solution (Python):

import math

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

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

Solution (Python):

"""
@author: H_Hoshigi
"""
def main():
    import math
    R = float(input())
    print(2. * R * math.pi)

if __name__ == "__main__":
    main()

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

Solution (Python):

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

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

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


print(2*mt.pi*R)

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

Solution (Python):
import math

l = math.pi
a = int(input())
res = 2*a*l
print(res)

Solution (Python):


import math

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

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

Solution (Python):

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

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

import math

print(2*N*math.pi)

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

print(r*3.1415926535*2)

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

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

Solution (Python):
import math


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

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

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

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

Solution (Python):

import math


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


if __name__ == '__main__':
    main()

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

print(r*3.141592653589793*2)

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

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

r *= 2
r *= 3.14

print(r)

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


if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):
import math

R = int(input())

print(math.pi * R * 2)

Solution (Python):
import sys
from math import factorial
from collections import Counter
from fractions import Fraction
import heapq, bisect, fractions
import math
import itertools
sys.setrecursionlimit(10 ** 5 + 10)
INF = 10**15 +5
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()))
MOD = 10**9 + 7

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

Solution (Python):

import numpy as np
 
def main():
    r = int(input())
    print(r * 2 * np.pi)
 
if __name__ == '__main__':
    main()

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

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

Solution (Python):
from math import pi

r = int(input())

print(2*r*pi)

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

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


if __name__ == "__main__":
    main()

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

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

Solution (Python):
import numpy as np

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

Solution (Python):
import math

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

Solution (Python):
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**6)
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

n = ni()

import math

print(2*n*math.pi)

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

Solution (Python):

import math
r = int(input())

print(2 * r * math.pi)

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

Solution (Python):
r=int(input())
print('%.2f'%(3.14159265359* r * 2))

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

R = float(input().rstrip())
print(R * 2.0 * 3.1415)

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

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

Solution (Python):
import math

R = int(input())
ensyu = 2 * 3.14 * R
print(ensyu)

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

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

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

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

Solution (Python):
import math

radius = int(input())

print(2*radius*math.pi)

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

Solution (Python):
import math


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

Solution (Python):
from math import pi


def main(R=None):
    if not R:
        R = int(input())
    ans = 2*R*pi
    print(ans)
    return ans


if __name__ == "__main__":
    main()

Solution (Python):
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate


def read_ints():
    return list(map(int, read().split()))


def read_a_int():
    return int(read())


def read_tuple(H):
    '''
    H is number of rows
    '''
    ret = []
    for _ in range(H):
        ret.append(tuple(map(int, read().split())))
    return ret


def read_col(H):
    '''
    H is number of rows
    A列、B列が与えられるようなとき
    ex1)A,B=read_col(H)    ex2) A,=read_col(H) 
    '''
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return tuple(map(list, zip(*ret)))


def read_matrix(H):
    '''
    H is number of rows
    '''
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return ret
    


MOD = 10**9 + 7
INF = 2**31  

from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right  

R = read_a_int()
print(R * 2 * 3.14159265359)

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

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 sys
input = sys.stdin.readline
import math
def main():
    R = int(input())
    print(2 * R * math.pi)
if __name__ == "__main__":
    main()

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

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

PI = 3.141592
print(2 * PI * r)

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

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

Solution (Python):

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

Solution (Python):
def main():
  r = int(input())
  
  return (r+r) * 3.14
  
if __name__ == '__main__':
  print(main())

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

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

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

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

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

print(r*2*3.1415926535)

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

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

import math

print(2.0*math.pi*r)

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

Solution (Python):
import math

n = int(input())

print(math.pi * n * 2)

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

Solution (Python):
import sys; sys.setrecursionlimit(2147483647); input = sys.stdin.readline
import math
from math import floor, ceil, sqrt, factorial, log
from collections import Counter, defaultdict, deque
from operator import itemgetter
INF = float('inf'); MOD = 10**9+7
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(MI())
def LIR(n): return [LI() for i in range(n)]
def IS(): return input().rstrip()

def main():
    R = I()
    print(2.0*R*math.pi)
if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline
from itertools import permutations,  combinations, accumulate
from functools import *
from collections import deque, defaultdict, Counter
from heapq import heapify, heappop, heappush, heappushpop

INF = float('inf')
NIL = - 1

""" Input
S = input().rstrip()
N, A, B = map(int, input().split())
A = list(map(int, input().split()))
A = np.array(input().split(), dtype=np.float64)
D = [int(input()) for _ in range(N)]
AB = [[int(x) for x in input().split()] for _ in range(N)]
PX = [[int(x) for x in input().split()] for _ in range(Q)]
"""

PI = 3.141592

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

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

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

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

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

Solution (Python):

import math
r = int(input())
ans = 2 * r * math.pi
print('{:.3F}'.format(ans))

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

Solution (Python):


import math


R = int(input())

print(R * 2 * math.pi)

Solution (Python):
from numpy import pi
r = int(input())

print(2*pi*r)

Solution (Python):
import math
def Main(R):
    return 2*math.pi*R
    

def main():
    R = int(input())
    print(Main(R))

if __name__ == '__main__':
    main()

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

s = 2 * r * math.pi

print(s)

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

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

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

Solution (Python):
import math

r = float(input())

print(2*r*math.pi)

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

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

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

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

Solution (Python):
import math

R = float(input())

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

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

print(2*r*3.14)

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

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

print(2 * np.pi * r)

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

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

Solution (Python):
import sys
input = lambda: sys.stdin.readline().rstrip()
inp = sys.stdin.buffer.readline                                
def I(): return list(map(int,inp().split()))
from math import pi
r,=I()
print(2*pi*r)

Solution (Python):
import math

r = input()

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

Solution (Python):

















mod = 10**9 + 7

def readInts():
  return list(map(int,input().split()))
def main():
    r = int(input())
    import math
    pi_ = math.pi
    print(2*pi_*r)
if __name__ == '__main__':
  main()

Solution (Python):

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

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

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

Solution (Python):
import numpy as np
from collections import defaultdict
from math import gcd
import time
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
 
 
start = time.time()

N = int(readline())
print(N*2*3.14)

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

print(2 * r * pi)

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

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

Solution (Python):
import math
def round(x):
    return 2* math.pi * x
R = int(input())
if __name__== "__main__":
    print(round(R))

Solution (Python):
import sys,math,copy,queue,itertools,bisect
sys.setrecursionlimit(10**7)
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
_LI = lambda : [int(x)-1 for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())

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

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

import math

print(2*R*math.pi)

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

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 math

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