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, = tuple(int(s) for s in input().split())
import math
c = 2 * math.pi * r
print(c)

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

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

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

Solution (Python):
import math


def main():

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


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
R=float(input())
pi=6.28318530717958623200/2
print(2*R*pi)

Solution (Python):
R = int(input())
L = 2 * 3.14159265358979 * R
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
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

R = int(input())

ans = 2 * math.pi * R

print("%.20f"%ans)

Solution (Python):
import math

R = input()

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

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

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

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

print(2*r*math.pi)

Solution (Python):




import sys
from io import StringIO
import unittest
import math

def yn(b):
    print("Yes" if b==1 else "No")
    return

def resolve():
    readline=sys.stdin.readline

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

    return

if 'doTest' not in globals():
    resolve()
    sys.exit()

Solution (Python):

import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from decimal import *
from collections import deque
from math import gcd
sys.setrecursionlimit(10**7)
MOD = 10**9+7
INF = float('inf') 
def lcm(a,b):return (a*b) // gcd(a,b) 
def iin(): return int(sys.stdin.readline()) 
def ifn(): return float(sys.stdin.readline()) 
def isn(): return sys.stdin.readline().split() 
def imn(): return map(int, sys.stdin.readline().split()) 
def imnn(): return map(lambda x:int(x)-1, sys.stdin.readline().split()) 
def fmn(): return map(float, sys.stdin.readline().split()) 
def iln(): return list(map(int, sys.stdin.readline().split())) 
def iln_s(): return sorted(iln()) 
def iln_r(): return sorted(iln(), reverse=True) 
def fln(): return list(map(float, sys.stdin.readline().split())) 
def join(l, s=''): return s.join(l) 
def perm(l, n): return itertools.permutations(l, n) 
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) 
def comb(l, n): return itertools.combinations(l, n) 
def comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) 
def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 
def m_add(a,b): return (a+b) % MOD
def lprint(l): print(*l, sep='\n')
def sieves_of_e(n):
    is_prime = [True] * (n+1)
    is_prime[0] = False
    is_prime[1] = False
    for i in range(2, int(n**0.5)+1):
        if not is_prime[i]: continue
        for j in range(i * 2, n+1, i): is_prime[j] = False
    return is_prime
R = iin()
 
print(2*R*math.pi)

Solution (Python):
import math
R = int(input())
if R>=1 or R<=100:
    R = R * math.pi * 2
    print("{:.20f}" .format(R))

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

print(2*r*3.141592)

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

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

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

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

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

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

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

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

m = n * 2 * 3.14

print(m)

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

Solution (Python):
import sys

def main():

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

if __name__ == "__main__":
    main()

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

p = 6.28318530717958623200

print(r*p)

Solution (Python):
import math
radius = float(input())
circumference = 2 * math.pi * radius
print("%.20f" % circumference)

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

Solution (Python):
import numpy as np
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines

p = np.pi

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

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

Solution (Python):
import math

r = int(input())

c = 2*(math.pi)*r

print(c)

Solution (Python):
R = input()

R = int(R)

print(R*2*3.1415926536)

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

Solution (Python):
N = int(input())
p = 3.14159265359
a  =N *2 *p
print(round(a,4))

Solution (Python):
from math import pi
R = int(input())
print("{}".format(R*pi*2))

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

Solution (Python):
import math







import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()

def resolve():

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

resolve()

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

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

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

Solution (Python):

import math
r = int(input())

print(2*r*math.pi)

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

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

Solution (Python):


R=int(input())

Round=6.283*R

print(Round)

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

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

Solution (Python):

from decimal import *
from itertools import permutations, combinations,combinations_with_replacement,product
import math

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

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

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

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

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

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

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

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

Solution (Python):
import math

hankei = int(input())
output = hankei * 2 * math.pi

print(output)

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

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

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

res = 2 * math.pi * R

print(res)

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

Solution (Python):

import math

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

if __name__ == "__main__":
    solve()

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

Solution (Python):
import sys
import math


def INT(): return int(input())
def MAP(): return map(int,input().split())
def LI(): return list(map(int,input().split()))


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

if __name__ == '__main__':
        main()

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

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

Solution (Python):
r=int(input())
l=r*6.283185
print(l)

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

Solution (Python):
import math

R = int(input())

x = math.pi

print(2*x*R)

Solution (Python):
from math import pi

r = int(input())


print(2*r*pi)

Solution (Python):

import math

r = int(input())

print(2*r*math.pi)

Solution (Python):
import math

x = int(input())

print(2 * x * math.pi)

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

Solution (Python):

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

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

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

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

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

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

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):
from sys import stdin
pi=3.14159265358979323846
r=list(map(float,(stdin.readline().strip().split())))[0]
print(2*pi*r)

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

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

Solution (Python):
import math
 
class abc_163:
    
    def __init__(self):
        pass
    
    def A(self):
        r=int(input())
        print(2*math.pi*r)
    
if __name__=='__main__':
    obj=abc_163()
    obj.A()

Solution (Python):
R, = [int(x) for x in input().split()]
pi = 3.141592653589793
print(2 * pi * R)

Solution (Python):
import math

R = int(input())

print(math.pi * 2 *R)

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

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

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

Solution (Python):
from math import pi

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

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

print(2*r*math.pi)

Solution (Python):
import math

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

Solution (Python):
import math

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

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(R * 2 * 3.1415926535)

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

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

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

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

print(R * 2 *3.141592)

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

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

result = 2 * input_line * 3.14
print(result)

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

Solution (Python):
import math

r = int(input())

l = (r*2) * math.pi

print(l)

Solution (Python):
import sys

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

if __name__ == '__main__':
    main()

Solution (Python):
import os

def main():
        r = int(input())
        print(2*r*3.1415926535)
        
if __name__ == "__main__":
        main()

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

print(2*n*math.pi)

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

Solution (Python):
print(int(input())*710/113)

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

Solution (Python):
import math

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

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

print(3.141 * 2 * r)

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

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

Solution (Python):



a=int(input())

print(a*2*3.1415926535)

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

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

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

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

print(R*2.0*math.pi)

Solution (Python):
import math


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


def main():
    r = int(input())
    res = solve(r)
    print(res)


def test():
    assert abs(solve(1) - 6.28318530717958623200) < 0.01
    assert abs(solve(73) - 458.67252742410977361942) < 0.01


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

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

Solution (Python):

import sys
import math

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

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

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

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

print(math.pi*(n))

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

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

Solution (Python):
def q1():
    R = int(input())
    print('{0:.3f}'.format(2*R*3.14159))


if __name__ == '__main__':
    q1()

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

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

l = 6.28318 * number

print(l)

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

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

Solution (Python):
import sys
input = sys.stdin.readline
if __name__ == '__main__':
    R = float(input().rstrip())
    print(R * 2.0 * 3.1415)

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

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

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

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

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

print(2 * R * pi)

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

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

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

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

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

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

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

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

print(2 * r * 3.14)

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

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

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

s = 2 * r * math.pi

print(s)

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

Solution (Python):

import math


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

ans = 2 * R * PI
print(ans)

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

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

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

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(R * 2 * 3.1415)

Solution (Python):
import math

r = int(input())

L = 2 * math.pi * r

print(L)

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

Solution (Python):

import sys
from collections import Counter
from itertools import permutations, combinations
from math import ceil, floor, pi
import bisect
sys.setrecursionlimit(10 ** 6)

def input():
    return sys.stdin.readline()[:-1]

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

if __name__ == '__main__':
    main()

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

Solution (Python):
import math

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

print(r * 2 *p)

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





print(2*n*math.pi)

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

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

Solution (Python):
import math

R=int(input())

print(2*math.pi*R)

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

print(R*2*3.1415926535)

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

Solution (Python):
R = int(input())
print(2.0*3.1416*R)

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

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

Solution (Python):
import math

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

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

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

Solution (Python):

n = int(input())
ans = 2.0*(3.1415926535897932384626433)*n
print("{0:.20f}".format(ans))

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

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

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

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

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

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

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

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

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

if __name__ == "__main__":
    main()

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

Solution (Python):
import math

r = int(input())

length = 2*r*math.pi

print(length)

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

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

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

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

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

Solution (Python):
import math


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

    print(2 * R * math.pi)


if __name__ == "__main__":
    main()

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

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

Solution (Python):
import math

R = int(input())

print(2 * math.pi * R)

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

Solution (Python):
import math

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

Solution (Python):
R = int(input())
if 1 <= R <= 100:
  c = 2*(22/7)*R
  print(c)

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

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

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

if __name__ == '__main__':
    main()

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

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

Solution (Python):

from __future__ import division, print_function

import os
import sys
import math
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip


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




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


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

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



if __name__ == "__main__":
    main()

Solution (Python):
import math

R = int(input())

print(R * 2 * math.pi)

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

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

print(2*3.14159265359*R)

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

R = int(input())

print(R * 2 * 3.14)

Solution (Python):
import copy
import math
a = int(input())
print(a*2*3.1415926)

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

Solution (Python):
import math
temp = input()

print (2.0 * float(temp) * math.pi)

Solution (Python):
import math

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

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

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

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

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

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

ans = r*2*float(3.14)

print(ans)

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

print(2*R*3.141592)

Solution (Python):
import math


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

Solution (Python):
import sys
sys.setrecursionlimit(300000)

def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LMI(): return list(map(int, sys.stdin.readline().split()))
MOD = 10 ** 9 + 7
INF = float('inf')

from math import pi


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

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

Solution (Python):
import math


R=int(input())

N=2*math.pi*R

print(float(N))

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

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

ans = R * 3.14 *2
print(ans)

Solution (Python):













R = int(input())

ans = 2*R*3.14159265359

print(ans)

Solution (Python):
import sys
pi = 3.141592653589793
r = int(sys.stdin.readline().strip())
print( r * pi * 2)

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

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

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

m = 2 * R * 3.14

print(m)

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

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

Solution (Python):
from math import pi

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

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

Solution (Python):
import math

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

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

ans = N*2*3.141592


print(ans)

Solution (Python):
import math

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

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

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

Solution (Python):
import math
R = int(input())
if R>=1 or R<=100:
    R = R * math.pi * 2
    print("{:.20f}" .format(R))

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

Solution (Python):

import math

r = int(input())

leng = 2 * math.pi * r

print("{}".format(leng))

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

Solution (Python):
PI = 3.14
R =int(input())
diameter = 2 * R
circumference = 2 * PI * R
print(float( PI * 2 * R))

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

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

Solution (Python):
import math

x = math.pi
R = input()

a = int(R)
print(a * 2 * x)

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

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

print(2 * 3.141592653589793 * r)

Solution (Python):

  
PI = 3.1415
  

def circumference(r): 
    return (2.0 * PI * r) 
  
r = float(input())

print ('%.4f' % circumference(r))

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

Solution (Python):

import math

R = int(input())

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

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

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

Solution (Python):
import math

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

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

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

pi = 3.141592

print(2*r*pi)

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

ans = r * 2 * 3.14

print(ans)

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline
from collections import defaultdict
from heapq import heappop, heappush

from decimal import *

























def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))

inf = float('inf')
mod = 1000000007




def main():
	R = inputInt()

	ans = 2*R*math.pi

	print(ans)





def combination(n, r, mod=10**9+7):
    r = min(r, n-r)
    res = 1
    for i in range(r):
        res = res * (n - i) * modinv(i+1, mod) % mod
    return res


def modinv(a, mod=10**9+7):
    return pow(a, mod-2, mod)

def egcd(a, b):
    if a == 0:
        return b, 0, 1
    else:
        g, y, x = egcd(b % a, a)
        return g, x - (b // a) * y, y



def H(n, r, mod=10**9+7):
	
	
    return combination(n+r-1, r, mod)

class Combination:
    """
    O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
    n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
    使用例：
    comb = Combination(1000000)
    print(comb(5, 3))  
    """
    def __init__(self, n_max, mod=10**9+7):
        self.mod = mod
        self.modinv = self.make_modinv_list(n_max)
        self.fac, self.facinv = self.make_factorial_list(n_max)

    def __call__(self, n, r):
        return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod

    def make_factorial_list(self, n):
        
        
        fac = [1]
        facinv = [1]
        for i in range(1, n+1):
            fac.append(fac[i-1] * i % self.mod)
            facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
        return fac, facinv

    def make_modinv_list(self, n):
        
        modinv = [0] * (n+1)
        modinv[1] = 1
        for i in range(2, n+1):
            modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
        return modinv

if __name__ == "__main__":
	main()

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

import math

print(2*n*math.pi)

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

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

Solution (Python):
import sys
import math
from collections import deque
MAX_INT = int(10e10)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

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

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

Solution (Python):
from collections import *
import sys
try: inp = raw_input
except: inp = input
def err(s):
    sys.stderr.write('{}\n'.format(s))

def ni():
    return int(inp())

def nl():
    return [int(_) for _ in inp().split()]

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

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

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

Solution (Python):
import math
radius = int(input(''))
circle = 2 * radius * math.pi
print(circle)

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

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

circumference = 2 * radius * math.pi
print(circumference)

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

Solution (Python):
import math

r = input()

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

Solution (Python):
import math

pi = math.pi
R = float(input())

L = 2 * pi * R

print(L)

Solution (Python):
import sys
from pprint import pprint
import math

R = int(sys.stdin.readline().strip())
print(2 * R * math.pi)