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

input = sys.stdin.readline


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


if __name__ == "__main__":
    main()

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

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

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

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

Solution (Python):
import math 

R = int(input())

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

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

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

Solution (Python):
import math

R = int(input())

ans = 2 * math.pi * R

print(str(ans))

Solution (Python):


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

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

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

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

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

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

Solution (Python):
n=int(input())
print((n+n)*3.1415926535897932384626433832795028841971)

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

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

print(2*3.14*R)

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

Solution (Python):
import numpy as np

N = int(input())

print(2 * np.pi * N)

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

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

Solution (Python):
import math


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


if __name__ == "__main__":
    main()

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

Solution (Python):
import math

n = int(input())

print(2 * n * math.pi)

Solution (Python):
import math

radius = int(input())

ans = 2*radius*math.pi
print(ans)
exit()

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

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

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

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

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

Solution (Python):

R = int(input())

print(R*2*3.14159265359)

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

Solution (Python):
import sys
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0

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

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

if __name__ == '__main__':
    main()

Solution (Python):
from math import pi

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

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

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

Solution (Python):
import math


R=int(input())

N=2*math.pi*R

print(float(N))

Solution (Python):
import math

r = int(input())

x = math.pi

print(r*2*x)

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

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

    print(2 * pi * R)


if __name__ == "__main__":
    main()

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

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

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

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

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

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

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

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

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

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

Solution (Python):
import numpy as np

s=int(input())

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

Solution (Python):



r = int(input())

print(2 * (3.14) * r)

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

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

print(N*2*3.141592)

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

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

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

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

Solution (Python):
import math

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

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

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

Solution (Python):
import math

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

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

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

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

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

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

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

Solution (Python):


import sys,math

def ii(): return int(input())
def mii(): return map(int,input().split())
def lmii(): return list(mii())


def main():
    n=ii()
    pi=3.141592653589793
    r=2*pi*n
    print ('%.20f'%r)
    
        
            
        
            
            
        
            
    
        
        
     
        
if __name__=="__main__":
    main()

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

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

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

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

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

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


if __name__ == '__main__':
    main()

Solution (Python):
'''二分探索'''

'''デック'''

'''順列,組み合わせ,累積和,直積・forネスト'''

'''小数点以下切り捨て,小数点以下切り上げ,平方根,階乗,最大公約数'''

'''input 文字列は最後に\nを含む'''




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


if __name__ == '__main__':
    main()

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

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

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

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

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

ans=3.14*(2*R)

print(ans)

Solution (Python):
pi = 3.1415926

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

Solution (Python):
import math

r = int(input())

print(2 * math.pi * r)

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

r = int(input())

import math

pi = math.pi

print(2 * pi * r)

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

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

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

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

Solution (Python):
import math

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

print(2*r*x)

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

print(r * 2 * math.pi)

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

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

Solution (Python):
import math

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

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

print(str(2*n*math.pi))

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

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

Solution (Python):
import math

n = int(input())

num = math.pi * 2 * n

print('{:.4f}'.format(num))

Solution (Python):
import math

def circle(r):
    print(2*r*math.pi)

r = int(input())
circle(r)

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

print(2 * pi * R)

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

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

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

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

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

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

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

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

Solution (Python):

import math
r = int(input())


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

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
print("%.20f"%(2*math.pi*float(input())))

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

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

Solution (Python):
import math

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

Solution (Python):
import math

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

Solution (Python):
pi = 3.141592

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

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

Solution (Python):
import numpy as np

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

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

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

print(N * 2 * 3.14159256)

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):
import math
a=math.pi

R=input()

print(2*int(R)*a)

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

import math

print(2 * R * math.pi)

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

A = R*2*3.141592

print(A)

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

Solution (Python):






"""Module docstring
"""

import math
import sys


def solve(values, nb, max_jump_size):
    max_jump_size = min(nb, max_jump_size)
    cost_to = [0]
    for i in range(1, nb):
        j = max(0, i - max_jump_size)
        value_i = values[i]
        new_cost = min(
            prev_cost + abs(value_i - prev_value)
            for prev_cost, prev_value in zip(cost_to[j:i], values[j:i])
        )
        cost_to.append(new_cost)
    return new_cost


def do_job():
    "Do the work"
    
    R = int(input().strip())
    result = 2 * math.pi * R
    print(result)


def print_output(testcase, result) -> None:
    "Formats and print result"
    if result is None:
        result = "IMPOSSIBLE"
    print("Case 


def main(argv=None):
    "Program wrapper."
    if argv is None:
        argv = sys.argv[1:]
    do_job()
    return 0


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    sys.exit(main())

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

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

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

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

print(2*3.1415*r)

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

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

Solution (Python):
import math


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

main()

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

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

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

print(R*2*math.pi)

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

print(2*R*3.14159265358)

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

Solution (Python):
import math

R = int(input())

L = 2*R*math.pi

print(L)

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

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

Solution (Python):
import math

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

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

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

syu = R * 2 * 3.14159
print(syu)

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

Solution (Python):
import numpy as np

r = int(input())

ans = np.pi * 2 * r

print(ans)

Solution (Python):
import math
r = int(input())
p = math.pi
if r >= 1 and r <= 100:
    c = 2 * p * r
    print(c)
else:
  print()

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

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

Solution (Python):
import math

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

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

print(ans)

Solution (Python):

import math

def main():

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

if __name__ == '__main__':
    main()

Solution (Python):
import numpy as np

N = int(input())

print(2 * np.pi * N)

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

print(N * 2.0 * 3.1415)

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


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


if __name__ == '__main__':
    main()

Solution (Python):
pi = 3.1415
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())
l = 2 * math.pi * r
print(l)

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

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

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

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

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

Solution (Python):
import math

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

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

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

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

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

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

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

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

Solution (Python):
import sys
input = lambda: sys.stdin.readline().rstrip()
aint = lambda: int(input())
pi = 3.14159265
R = aint()
print(2*R*pi)

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

Solution (Python):
def main():
    import sys
    import math
    sys.setrecursionlimit(10 ** 6)
    input = sys.stdin.readline
    r = int(input())
    print(2*r*math.pi)

if __name__ == '__main__':
    main()

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

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

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

Solution (Python):

print(2*(3.14)*(int(input())))

Solution (Python):

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

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

print(2*math.pi*r)

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

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

Solution (Python):
import math

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

Solution (Python):
import math

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

Solution (Python):

import math


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


if __name__ == '__main__':
    main()

Solution (Python):
def main_function():
    from sys import stdin
    from sys import stdout
    input = stdin.readline
    print = stdout.write
    from math import pi

    r = int(input())
    print(f'{2 * pi * r}')


if __name__ == '__main__':
    main_function()

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

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

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

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

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

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

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

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

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

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

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

print(R*2 * numpy.pi)

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

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

Solution (Python):
import numpy as np


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


if __name__ == '__main__':
    main()

Solution (Python):
import math

R = int(input())

print(R * 2 * math.pi)

Solution (Python):



import sys

import math

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

r = int(input())

print(2 * math.pi * r)

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

Solution (Python):










import math
import numpy as np
import statistics
import string
import sys
from array import array
from collections import deque
from functools import wraps
import time

def intinput():
    return int(input())
def listintinput():
    return list(map(int, input().split()))
def splitintinput():
    return map(int, input().split())
def factorialsurplus(x, y, z):  
    ret = 1
    for i in range(x, y + 1):
        ret = (ret * i) % z
    return (ret)
def isprime(x):
    if x == 1:
        return False
    if x == 2:
        return True
    sq = int(math.sqrt(x))
    for i in range(2,sq+1):
        if x % i == 0:
            return False
    return True
def hcfnaive(a,b):
    if(b==0):
        return a
    else:
        return hcfnaive(b,a%b)

R = intinput()
print(2*R*3.1415)

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

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

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

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

def main():
    mod=10**9+7
    R=I()
    print(2*R*3.1415926535)

main()

Solution (Python):
import math

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


if __name__ == "__main__":
    main()

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

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

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

print(2*r*3.1415926535)

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from itertools import accumulate, permutations, combinations, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
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()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
 
R = INT()
print(float(2*R*pi))

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

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

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

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

Solution (Python):
R = int(input())
from math import pi
print(2*R*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('{:.3f}'.format(ans))

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

Solution (Python):
from sys import stdin
import math
n = int(stdin.readline().rstrip())
print(2*n*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):
input = raw_input
pi = 6.28318530717958623200 / 2

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

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

import math



print(2*(3.1415926)*r)

Solution (Python):
import math

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

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

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

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

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

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

print(2*R*3.1415926535)

Solution (Python):
pi = 3.141592

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

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

Solution (Python):

import math

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

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

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

Solution (Python):

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

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

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

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

Solution (Python):

print(2*3.14159265753989*int(input()))

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

print(2*n*math.pi)

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

Solution (Python):
from math import pi

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

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

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

Solution (Python):
if __name__ == "__main__":
		r = int(input())
		pi = 3.14

		print(2*pi*r)

Solution (Python):
import math

r=input()

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

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

Solution (Python):

S = float(input())

pi = 3.14159265358979

print(2. * pi * S)

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

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

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

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

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

Solution (Python):



R = int(input())
pai = 3.141592
print(2*R*pai)

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

Solution (Python):
import math

R = int(input())

print(2*math.pi*R)

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

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

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

ans = 2*R*3.14

print(ans)

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

Solution (Python):
import math

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

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

Solution (Python):
import math

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

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

import math

print(math.pi* R*2)

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

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

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

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

r = int(input())

import math

print(2 * r * math.pi)

Solution (Python):

import math


import sys
input = sys.stdin.readline



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

    res = 2 * R * math.pi

    print(res)



main()

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

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

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

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

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

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

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

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

Solution (Python):

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

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

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

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

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

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

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

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

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

print(circle_round(R))

Solution (Python):
import math

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

Solution (Python):
import math

def circumeference(radius):
	return 2 * math.pi*radius

print(circumeference(float(input())))

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

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

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

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

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

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


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
import math

k = int(input())

print(2 * k * math.pi)

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

Solution (Python):

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

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

l = 2 * p * r
print(l)

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin, log, log10, gcd
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits

def debug(*args):
    if debugmode:
        print(*args)
def input(): return sys.stdin.readline().strip()
def STR(): return input()
def INT(): return int(input())
def FLOAT(): return float(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7
dx = [0, 0, 1, -1, 1, -1, -1, 1]
dy = [1, -1, 0, 0, 1, -1, 1, -1]
debugmode = True

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

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

print(2*R*math.pi)

Solution (Python):
import math

i = int(input())

print(2*math.pi*i)

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

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

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

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

Solution (Python):
x=6.28318530717958623200

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

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

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

Solution (Python):
import sys,math
def input():
    return sys.stdin.readline()[:-1]
N = int(input())

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

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

Solution (Python):
import math


R = int(input())

print(2 * R * math.pi)

Solution (Python):



r = int(input())

print(2 * (3.14) * r)

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