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(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()
from math import pi
print(R * 2 * pi)

Solution (Python):
import math

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

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





print(2*n*math.pi)

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

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

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

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

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

Solution (Python):
import math 

R = int(input())

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

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

Solution (Python):
import sys

IS = lambda: sys.stdin.readline().rstrip()
II = lambda: int(IS())
MII = lambda: list(map(int, IS().split()))
MIIZ = lambda: list(map(lambda x: x-1, MII()))

INIT_VAL = 0
DP2 = lambda d1, d2: [[INIT_VAL]*d2 for _ in range(d1)]
DP3 = lambda d1, d2, d3: [[[INIT_VAL]*d3 for _ in range(d2)] for _ in range(d1)]
import math

def main():
    n = II()
    print(2*n*math.pi)

if __name__ == '__main__':
    main()

Solution (Python):
import math

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

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


ans = 2 * r * pi
print(ans)

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

Solution (Python):
def main():
  n = int(input())
  
  
  
  
  
  
  
  ans = 0
  count = 0
  lis = []
  
  print(n*2*3.1415926535)

if __name__ == '__main__':
  main()

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

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

Solution (Python):


R = int(input())
print(R*6.28318530717958623200)

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

Solution (Python):
import math

r = int(input())

print(math.pi * r * 2)

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

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

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

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

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

Solution (Python):
import math

r=int(input())

print(2*r*math.pi)

Solution (Python):
def solve():
    R = float(input())
    print(R*2*3.14159276358929323846264)



if __name__ == '__main__':
    solve()

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

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

Solution (Python):

import math

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

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

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

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

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

Solution (Python):
r = int(input())
pi = 3.141592653
print(2*r*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
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)
 

def get_nums_l():
    return [ int(s) for s in input().split(" ")]
 

def get_nums_n(n):
    return [ int(input()) for _ in range(n)]
 

def get_all_int():
    return map(int, open(0).read().split())
 
def log(*args):
    print("DEBUG:", *args, file=sys.stderr)
 
r = int(input())
print(2 * r * 3.141519)

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

print(2*r*math.pi)

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

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

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

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

Solution (Python):
import math

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

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

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

print(2*R*3.14)

Solution (Python):
import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
read = sys.stdin.buffer.read
sys.setrecursionlimit(10 ** 7)
 
import math
 
R = int(readline())
answer = 2 * R * math.pi
print(answer)

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

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

print(2*math.pi*r)

Solution (Python):
import math

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

    print(2*r*math.pi)

if __name__ == '__main__':
    main()

Solution (Python):
from sys import stdin
pi=3.141592653589
r=list(map(float,(stdin.readline().strip().split())))[0]
print(2*pi*r)

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

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

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

Solution (Python):
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial
from bisect import bisect_left 
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
def pri(x): print('\n'.join(map(str, x)))

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

Solution (Python):
import math

r = int(input())

print(math.pi*r*2.0)

Solution (Python):
import math

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

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

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

Solution (Python):
def mapint_inp():
    return map(int, input().split())

def intinp():
    return int(input())

R = intinp()

import math

p = math.pi

print(2*p*R)

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

print (2*R*math.pi)

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

Solution (Python):
import numpy as np

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

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

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

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

Solution (Python):

def a163(n):

    return (n * 2)*3.14

def main():
    n = int(input())
    print(a163(n))

if __name__ == '__main__':
    main()

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

print(2*n*math.pi)

Solution (Python):
import math

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

Solution (Python):
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


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

    print(2 * 3.141592653589 * r)


if __name__ == '__main__':
    main()

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

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

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

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

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

Solution (Python):
import math

t = int(input())

print(2*math.pi*t)

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

Solution (Python):
from math import pi
r=float(input())
d=2*pi*r
print("%.20f\n"%d)

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

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

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

Solution (Python):
def input_one_number():
    return int(input())

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

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

R = input_one_number()

print(R*2*3.1415926535897932384626433)

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from math import pi

R = int(read())
print(R * 3.141592 * 2)

Solution (Python):
import re
import math

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

print(2*n*p)

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

Solution (Python):
import math

a = int(input())

print(a*2*math.pi)

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

Solution (Python):
import numpy as np

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

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

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

Solution (Python):
import math


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


if __name__ == "__main__":
    main()

Solution (Python):
import math

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

print(2*r*x)

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(round(math.pi*t*2,2))

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

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

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

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

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

Solution (Python):

import math
r = int(input())


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

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

Solution (Python):
import math

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

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

Solution (Python):
import math

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

Solution (Python):
from sys import stdin

def main():

    input = stdin.readline

    r = int(input())

    ans = r * 6.28

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

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

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):
from math import pi

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

Solution (Python):
import os

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

if __name__ == "__main__":
        main()

Solution (Python):
import math

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

R = int(input())

print(circle_round(R))

Solution (Python):
import math

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

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

Solution (Python):
import math
import queue

def readInt():
	return int(input())

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

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


r = readInt()

print(r*2*3.14159265)

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

Solution (Python):
import math
import fractions
import sys
import itertools
import numpy as np
from collections import Counter
import datetime

def input1():
	return int(input())


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


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

def keta(N):
	return len(str(N))


def input_daytime(input_time):
	time,distance=input_time.split()
	t=time.split(":")
	se=str(t[-1]).split(".")
	dt1 = datetime.timedelta(hours=int(t[0]),minutes=int(t[1]),seconds=int(se[0]),milliseconds=int(se[1]))
	return dt1

def combinations(n,r):
	return list(itertools.combinations(n,r))

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

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

Solution (Python):

import math

r = int(input())

print(2 * math.pi * r)

Solution (Python):
import math

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

if __name__ == '__main__':
  main()

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

K = 3.14159265358979*2*r

print(K)

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

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

Solution (Python):
import math

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

Solution (Python):
import math

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


if __name__ == '__main__':
    main()

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

Solution (Python):

import math

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

print(ans)

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

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

Solution (Python):

''':'
docker run --rm -it -v $(cd $(dirname $0) && pwd):/vo:ro pypy:3-2.4.0 \
   /bin/bash -c "pypy3 /vo/$(basename $0) < /vo/input.txt"
exit $?
'''
import sys
import math


def _i(): return int(sys.stdin.readline().strip())


def main():
    return 2 * _i() * math.pi


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

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

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

Solution (Python):

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

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

    print(2 * 3.141592 * R)


if __name__ == '__main__':
    main()

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

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

Solution (Python):
from math import factorial,sqrt,ceil,gcd,pi












R = int(input())

ans = 2*R*pi

print(ans)

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

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

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

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

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

Solution (Python):
import math

R = int(input())

print(math.pi*2*R)

Solution (Python):
from math import pi

r = float(input())
print(2.0 * pi * r)

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

Solution (Python):
import itertools
import math
import string
import collections
from collections import Counter
from collections import deque
import sys
sys.setrecursionlimit(2*10**5)
INF = 2**60


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


def nCr(n, r):
    return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))


def has_duplicates2(seq):
    seen = []
    for item in seq:
        if not(item in seen):
            seen.append(item)
    return len(seq) != len(seen)


def divisor(n):
    divisor = []
    for i in range(1, n+1):
        if n % i == 0:
            divisor.append(i)
    return divisor



dx = [-1, -1, -1, 0, 0, 1, 1, 1]
dy = [-1, 0, 1, -1, 1, -1, 0, 1]
R = int(input())
print(R*2*(math.pi))

Solution (Python):
import math

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

print(ans)

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

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

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

Solution (Python):
import math
p = math.pi

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

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

import math

print(math.pi*R*2)

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

Solution (Python):
import math

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

Solution (Python):
r=int(input())
ans=2*r*355/113
print("{:0.10f}".format(ans))

Solution (Python):
import math

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

Solution (Python):
x=int(input())
circ=2*22*x/7.0
print(circ)

Solution (Python):
import math

r = int(input())

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

Solution (Python):
import math

r=int(input())

print(2*r*math.pi)

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

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

Solution (Python):
from math import pi

r = int(input())

s = 2*pi*r

print(s)

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

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

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

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

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

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

Solution (Python):
r= input()

ans = int(r)*6.28

print(ans)

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

print(2*R*3.1415926535897)

Solution (Python):

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

Solution (Python):
import math

R = float(input())

print(2*math.pi*R)

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

Solution (Python):
import sys
import math

sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7


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


if __name__ == '__main__':
    resolve()

Solution (Python):

import math



if(__name__ == '__main__'):
    
    r = int(input())

    pi = 3.141592
    ans = pi * r * 2.0
    print(ans)

Solution (Python):

import sys
input = sys.stdin.readline
import math
def main():
    R = int(input())
    print(float(R*2*math.pi))

if __name__ == '__main__':
   main()

Solution (Python):
"""
Author    : co_devil Chirag Garg
Institute : JIIT
"""
from math import pi
from collections import deque
from math import factorial
from math import log, ceil
from collections import defaultdict
from math import *
from sys import stdin, stdout
import itertools
import os
import sys
import threading
from collections import deque, Counter, OrderedDict, defaultdict
from heapq import *



from fractions import Fraction

mod = 998244353


def ii(): return int(input())


def si(): return str(input())


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


def li(): return list(mi())


def fii(): return int(stdin.readline())


def fsi(): return str(stdin.readline())


def fmi(): return map(int, stdin.readline().split())


def fli(): return list(fmi())


abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12,
       'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24,
       'z': 25}


def getKey(item): return item[0]


def sort2(l): return sorted(l, key=getKey)


def d2(n, m, num): return [[num for x in range(m)] for y in range(n)]


def isPowerOfTwo(x): return (x and (not (x & (x - 1))))


def decimalToBinary(n): return bin(n).replace("0b", "")


def ntl(n): return [int(i) for i in str(n)]


def powerMod(x, y, p):
    res = 1
    x %= p
    while y > 0:
        if y & 1:
            res = (res * x) % p
        y = y >> 1
        x = (x * x) % p
    return res


graph = defaultdict(list)
visited = [0] * 1000000
col = [-1] * 1000000


def bfs(d, v):
    q = []
    q.append(v)
    visited[v] = 1
    while len(q) != 0:
        x = q[0]
        q.pop(0)
        for i in d[x]:
            if visited[i] != 1:
                visited[i] = 1
                q.append(i)
        print(x)


def make_graph(e):
    d = {}
    for i in range(e):
        x, y = mi()
        if x not in d:
            d[x] = [y]
        else:
            d[x].append(y)
        if y not in d:
            d[y] = [x]
        else:
            d[y].append(x)
    return d


def gr2(n):
    d = defaultdict(list)
    for i in range(n):
        x, y = mi()
        d[x].append(y)
    return d


def connected_components(graph):
    seen = set()

    def dfs(v):
        vs = set([v])
        component = []
        while vs:
            v = vs.pop()
            seen.add(v)
            vs |= set(graph[v]) - seen
            component.append(v)
        return component

    ans = []
    for v in graph:
        if v not in seen:
            d = dfs(v)
            ans.append(d)
    return ans


def primeFactors(n):
    s = set()
    while n % 2 == 0:
        s.add(2)
        n = n // 2
    for i in range(3, int(sqrt(n)) + 1, 2):
        while n % i == 0:
            s.add(i)
            n = n // i
    if n > 2:
        s.add(n)
    return s


def find_all(a_str, sub):
    start = 0
    while True:
        start = a_str.find(sub, start)
        if start == -1:
            return
        yield start
        start += len(sub)


def SieveOfEratosthenes(n, isPrime):
    isPrime[0] = isPrime[1] = False
    for i in range(2, n):
        isPrime[i] = True
    p = 2
    while (p * p <= n):
        if (isPrime[p] == True):
            i = p * p
            while (i <= n):
                isPrime[i] = False
                i += p
        p += 1
    return isPrime


def dijkstra(edges, f, t):
    g = defaultdict(list)
    for l, r, c in edges:
        g[l].append((c, r))

    q, seen, mins = [(0, f, ())], set(), {f: 0}
    while q:
        (cost, v1, path) = heappop(q)
        if v1 not in seen:
            seen.add(v1)
            path = (v1, path)
            if v1 == t:
                return (cost, path)

            for c, v2 in g.get(v1, ()):
                if v2 in seen:
                    continue
                prev = mins.get(v2, None)
                next = cost + c
                if prev is None or next < prev:
                    mins[v2] = next
                    heappush(q, (next, v2, path))
    return float("inf")


def binsearch(a, l, r, x):
    while l <= r:
        mid = l + (r-1)//2
        if a[mid]:
            return mid
        elif a[mid] > x:
            l = mid-1
        else:
            r = mid+1
    return -1






def readTree(n):
    adj = [set() for _ in range(n)]
    for _ in range(n-1):
        u, v = map(int, input().split())
        adj[u-1].add(v-1)
        adj[v-1].add(u-1)
    return adj


def treeOrderByDepth(n, adj, root=0):
    parent = [-2] + [-1]*(n-1)
    ordered = []
    q = deque()
    q.append(root)
    depth = [0] * n
    while q:
        c = q.popleft()
        ordered.append(c)
        for a in adj[c]:
            if parent[a] == -1:
                parent[a] = c
                depth[a] = depth[c] + 1
                q.append(a)
    return (ordered, parent, depth)













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

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

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

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

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

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

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

print(N*3.141592653589*2)

Solution (Python):
import sys
import math

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


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


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


if __name__ == "__main__":
    main()

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

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

Solution (Python):

R  = int(input())


print(R * 2 * 3.1415)

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

Solution (Python):
import math
math.pi

R = int(input())

print(R * 2 * math.pi)

Solution (Python):
import numpy as np

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

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

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

Solution (Python):
import math 

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

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

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

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

Solution (Python):
import math

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

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

Solution (Python):
import math

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

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

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

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

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

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

Solution (Python):
import math 

R=float(input())

x=2.0*math.pi*R

print(x)

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

print(r * 2 * math.pi)

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

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

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

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

Solution (Python):

t = int(input())
print(3.1415926*2*t)

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

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

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

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

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

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

r = int(input())

import math

pi = math.pi

print(2 * pi * r)

Solution (Python):
import math
a=math.pi

R=int(input())

print(2*R*a)

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

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

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

Solution (Python):
import math

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

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

print(R * 2 * 3.14159)

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

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

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

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

print(n*2*math.pi)

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

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