Problem:
 Score : 100 points    Problem Statement Print the circumference of a circle of radius R .      Constraints  1 \leq R \leq 100  All values in input are integers.         Input Input is given from Standard Input in the following format:  R       Output Print the circumference of the circle.
Your output is considered correct if and only if its absolute or relative error from our answer is at most 10^{-2} .        Sample Input 1 1      Sample Output 1 6.28318530717958623200  Since we accept an absolute or relative error of at most 10^{-2} , 6.28 is also an acceptable output, but 6 is not.       Sample Input 2 73      Sample Output 2 458.67252742410977361942

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

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

print(2*pi*R)

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

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

result = 2 * math.pi * float(radius)
 
print(result)

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

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

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

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

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

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

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

l = 2 * r * 3.14159265358979

print(l)

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

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

Solution (Python):

import math

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

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

Solution (Python):
import sys
from functools import lru_cache
input = sys.stdin.readline
sys.setrecursionlimit(2 * 10**6)


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


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


if __name__ == '__main__':
    main()

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

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

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

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

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

print(2*r*3.1415926535)

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

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

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

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

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

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

print(3.1415926535 * a * 2)

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


circum = (R * 2) * 3.1415926535

print(circum)

Solution (Python):



import sys
import math

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


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




if __name__ == "__main__":
    resolve()

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

Solution (Python):


import math


r = int(input())


ans = r * 2 * math.pi


print(ans)

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):
R=int(input())
if 1<=R<=100:
    s=3.141592*2*R
    print(s)

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

Solution (Python):
import math

a = int(input())

print(2*a*math.pi)

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

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

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

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

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

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

r = int(input())

print(r* 2 * 3.1415)

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

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

Solution (Python):

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

if __name__ == "__main__":
    main()

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

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

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

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

Solution (Python):
import decimal

r=int(input())
decimal.getcontext().prec=10
r=decimal.Decimal(r)
a=decimal.Decimal(3.1415926487)

t=r*2*a
print(t)

Solution (Python):
import math

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

if __name__ == '__main__':
  R = int(input())
  print(circle_round(R))

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

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

Solution (Python):


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

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

pi = 3.14159265;

c = 2*pi*r;

print(c)

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

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

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


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

Solution (Python):
import math

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

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

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

Solution (Python):
import math
n = float(input())
pi = math.pi

l  = 2 * n * pi

print(l)

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

Solution (Python):
import math
import sys
sys.setrecursionlimit(10 ** 7)

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

print(ans)

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
import math

r = int(input())

result = 2 * r * math.pi

print(result)

Solution (Python):
from math import pi

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

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

Solution (Python):
import math

n = int(input())

print(math.pi * 2 *n)

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

Solution (Python):
import math

n = int(input())

print(math.pi*n*2)

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

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

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

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

Solution (Python):
n = float(input())
pi = 3.1415926535
rlen = round(2.0 * pi * n, 2)
print(rlen)

Solution (Python):

R = int(input())
import math
π=3.141592
syutyou = 2*π*R
print(syutyou)

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

Solution (Python):
import math

r = float(input())
print(round(2*math.pi*r, 3))

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

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

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

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

Solution (Python):
from sys import stdin
a = stdin.readline().rstrip()

a = int(a)
pi = 3.14159265
r = 2*pi*a
print(r)

Solution (Python):
import math

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

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

Solution (Python):
import math

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

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

Solution (Python):
from math import pi

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

    print(pi*2*R)

if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
import math






n = int(input())


print(n*2*math.pi)

Solution (Python):

import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub


input = sys.stdin.buffer.readline
INF = 2**62-1

def read_int():
    return int(input())


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


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(R):
    return 2*R*math.pi


def main():
    R = read_int()
    print(slv(R))


if __name__ == '__main__':
    main()

Solution (Python):
import math

R = int(input())

ans = 2*R*math.pi

print(ans)

Solution (Python):
from math import pi

r = int(input())
print(round(2*r*pi, 3))

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

answer = 3.141592653589793 * 2 * r

print(answer)

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

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

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

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

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

print(a*2*3.14)

Solution (Python):
import decimal

r=int(input())
decimal.getcontext().prec=22
r=decimal.Decimal(r)
a=decimal.Decimal(3.1415926487776988)

t=r*2*a
print(t)

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

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

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

Solution (Python):
import math

R = int(input())

print(R * 2 * math.pi)

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

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

ans = 2*radius*3.1415926535
print(ans)

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

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

print(2 * n * math.pi)

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

print(R * 2 * 3.1415)

Solution (Python):
import math

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

Solution (Python):






from sys import stdin,setrecursionlimit










setrecursionlimit(10**6+1)
input=stdin.readline

from math import pi
print(int(input().rstrip())*2*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())
import math

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

ans = 2*R*3.1415926535

print(ans)

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

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

print(3.14*2*R)

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

Solution (Python):
import math

i = int(input())

print(2*math.pi*i)

Solution (Python):
import math

R = int(input())

print(2*R*math.pi)

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

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

Solution (Python):
import math

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

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

Solution (Python):
from sys import stdin
a = stdin.readline().rstrip()

a = int(a)
pi = 3.14159265
r = 2*pi*a
print(r)

Solution (Python):
import math

R = int(input())


circumference_length = 2 * 3.141592653589793 * R

print(circumference_length)

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

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

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

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

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

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

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

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

print(num * 2 * 3.14159265)

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

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

Solution (Python):
import sys
import math

input_val = int(sys.stdin.readline())
if input_val <= 0:
    print(0)
else:
    print(2 * input_val * math.pi)

Solution (Python):
import math  
import bisect  
import queue  


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

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

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

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

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

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

print(2 * 3.1415926535 * R)

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

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

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

print(2*n*math.pi)

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

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

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

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

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

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

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

n = int(input())
print(a*n*2)

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

if __name__ == "__main__":
    main()

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

Solution (Python):
import math




R = int(input())

X = R * math.pi * 2


print(X)

Solution (Python):
from sys import stdin
 
r = int(stdin.readline().rstrip())
print(r*2*3.1415)

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

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

Solution (Python):
import math

radius = float(input())

print(2 * math.pi * radius)

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

Solution (Python):
import math

r = float(input())
s = 2 * math.pi * r
print( s )

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


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


if __name__ == '__main__':
    main()

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

Solution (Python):
import math

R = int(input())

circumference_length = 2 * math.pi * R

print(circumference_length)

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

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

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

main()

Solution (Python):
import math

r = int(input())

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

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

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

print (2 * r * math.pi)

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

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

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

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

if __name__=='__main__':
    main()

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

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

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

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

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

print(R*2*math.pi)

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

print(2*radius*3.141592653589793)

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

print("%10f" % (2.0*math.pi*r))

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

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):
from numpy import pi
a=int(input())
print(a*2*pi)

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

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

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

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

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

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

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

Solution (Python):
a = input()

a = float(a)

print(a * 2.0 * 3.1415926)

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

Solution (Python):
def main():

    r = int(input())
    return 2.0 * r * 3.14159265359

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

Solution (Python):

R = int(input())


print(2*R*3.14159)

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

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

Solution (Python):

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

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

ans = 2*r*float(3.14)

print(ans)

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

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

Solution (Python):
import math

R = int(input())

circumference_length = 2 * math.pi * R

print(circumference_length)

Solution (Python):
import math

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

Solution (Python):
import math

num = int(input())

print(num * 2 * math.pi)

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

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

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

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

print(a*2*3.14)

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

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

Solution (Python):
import math


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

if __name__ == "__main__":
  main()

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

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

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

ans = math.pi * 2 * r

print(ans)

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

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

Solution (Python):
import math

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

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

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

Solution (Python):
import numpy as np

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

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

Solution (Python):
import math

hankei = float(input())

enshu = hankei * 2 * math.pi

print (enshu)

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

Solution (Python):
import math

r=int(input())

print(2* math.pi * r)

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

Solution (Python):

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

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

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians

from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from functools import reduce
from bisect import bisect_left, insort_left
from heapq import heapify, heappush, heappop

INPUT = lambda: sys.stdin.readline().rstrip()
INT = lambda: int(INPUT())
MAP = lambda: map(int, INPUT().split())
S_MAP = lambda: map(str, INPUT().split())
LIST = lambda: list(map(int, INPUT().split()))
S_LIST = lambda: list(map(str, INPUT().split()))

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


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


if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):
import math

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

print(C)

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

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

answer = math.pi * 2 * R

print(answer)

Solution (Python):
from collections import deque, Counter, defaultdict
from itertools import chain, combinations
import json

import bisect
import sys
import math
import bisect
from functools import lru_cache

sys.setrecursionlimit(10 ** 8)

M = 10 ** 9 + 7
INF = 10 ** 17


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

    
    
    
    
    
    
    
    
    
    
    
    
    
    
    


if __name__ == "__main__":
    main()

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

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

Solution (Python):
import math






n = int(input())


print(n*2*math.pi)

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

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

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

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

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

print(R*2*3.1414)

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

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

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

Solution (Python):
import math


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


if __name__ == '__main__':
    main()

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

Solution (Python):


r = int(input())


ans = 2*3.1416*r
print(ans)

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

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

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

Solution (Python):
import math

R = int(input())

print(round(2*R*math.pi, 5))

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

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

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

print(ans)

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

Solution (Python):
import math

radius = int(input())

print(2*radius*math.pi)

Solution (Python):
import sys

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip() 

def main():
    r = ni()
    print(r*2*3.141592)
    
    return

if __name__ == '__main__':
    main()

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

Solution (Python):
import numpy as np
from sys import stdin
input = stdin.readline
R = int(input())
r = 2 * R * np.pi
print(r)

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

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

Solution (Python):
import math

R = (int)(input())

print(2*math.pi*R)

Solution (Python):
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
def ism():return map(str,input().split())
def isl():return list(map(str,input().split()))
import math
r = ii()
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(R*math.tau)

Solution (Python):
import math

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

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

ans = 2*r*float(3.14)

print(ans)

Solution (Python):
n = int(input())
print(6.2832*n)

Solution (Python):

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

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

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

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

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

Solution (Python):
import numpy as np


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

Solution (Python):
from math import pi

R=int(input())

print(2*pi*R)

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

print(ans)

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

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

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

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

Pi = 3.14

print(2*Pi*R)

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

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

print(round((a*2) * 3.1415926, 5))

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

Solution (Python):
import math


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


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
import math

r = int(input())

print(2*r*math.pi)

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

Solution (Python):
import numpy as np

data = input()
r = float(data)

print(2 * np.pi * r)

Solution (Python):
import math

R = int(input())

print(2 * R * math.pi)

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

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

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

print(r * 2 * math.pi)

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

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

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

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

Solution (Python):


import math


r = int(input())


ans = r * 2 * math.pi


print(ans)

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

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

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

Solution (Python):
import math

x = math.pi

r = int(input())

print(2*x*r)

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

Solution (Python):
import numpy as np
a=int(input())
pi = 4 * np.arctan(1) 
b=a*pi*2
print(b)

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

print(ans)

Solution (Python):

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

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

print(R*6.2828)

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

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

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

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

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

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

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

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

Solution (Python):

"""
Created on Sun Apr 19 21:18:34 2020

@author: arute
"""






from sys import stdin
import numpy as np





temp = stdin.readline().split()
N = int(temp[0])

count = 3.14*2*N
        
print(count)

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

Solution (Python):
N = int(input())
print(N*6.283185)

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

pi = 3.141592653589793
l = 2 * pi * r
print(l)

Solution (Python):



import math


R = int(input())


print(2*math.pi*R)

Solution (Python):
def circumference(r): 
    PI = 3.141592653589793238
    return (2 * PI * r) 
	
def main():
    print(circumference(int(input()))) 
    
if __name__=='__main__':
    main()

Solution (Python):

import math

r = int(input())

print(2*r*math.pi)

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

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

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

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

print( 2* R * math.pi)