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

hostnames = ['N551J', 'F551C', 'X553M']
input_file = 'a1.in'
if socket.gethostname() in hostnames:
    sys.stdin = open(input_file)


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


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


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


def read_str():
    return input()


def solve():
    r = read_int()
    return 2 * pi * r


def main():
    res = solve()
    print(res)


if __name__ == '__main__':
    main()

Solution (Python):
import math
a = float(input())
pi = math.pi
api = 2 * a * pi
print (str(api))

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

Solution (Python):
import math
math.pi

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

x = math.pi

R = int(input())

print(2*x*R)

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

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

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

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

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

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

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

print(2*math.pi*R)

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

A=10000
pi=0
for L in range(1,A):
    if L%2==0:
        B=-1
    else:
        B=1
    pi+=(4/(2*L-1))*B

answer = 2*pi*a

print(answer)

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

print(2*n*math.pi)

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

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

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

Solution (Python):
import math

R = input()

R = float(R)

circle = 2*R*math.pi

print(circle)

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

Solution (Python):
pi = 3.14159

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

Solution (Python):
import math

a=int(input())

print(math.pi*2*a)

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):
from math import pi
def main():
    R = int( input())
    print(2*R*pi)
if __name__ == '__main__':
    main()

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

ans = R * 3.1415 *2
print(ans)

Solution (Python):
import math

r = int(input())

print(2*math.pi*r)

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

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

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

print(2*r*math.pi)

Solution (Python):
import math

R = int(input())

print(math.pi * 2 *R)

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

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

Solution (Python):
import math

R = int(input())

print(2 * R * math.pi)

Solution (Python):
import math

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

print(R)

Solution (Python):
if __name__ == '__main__':
    a = int(input())

    print(2*a*3.141592)

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):
from math import pi
r = int(input())
print('{:.18f}'.format(r*2*pi))

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

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

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

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

print(R * (3.1415*2))

Solution (Python):
import math

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

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

Solution (Python):






import math

R = int(input())
print("{:0.8f}".format(2 * math.pi * R))

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

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

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

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

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

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

print(r*2*3.141592)

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

Solution (Python):
import math

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

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

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

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

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

print(2*r*math.pi)

Solution (Python):
import math

pi = 3.14159264358

r = int(input())

en = 2 * r * pi

print(en)

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
N = int(input())
print(format(2*N*math.pi,'.20f'))

Solution (Python):

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

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

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

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

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

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

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

Solution (Python):
import numpy as np


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


if __name__ == '__main__':
    main()

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

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

print(3.1415926535*2*n)

Solution (Python):

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

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

Solution (Python):
import sys


lines = 1
inp = list()

for _ in range(lines):
    inp.append(sys.stdin.readline().strip())


r = int(inp[0])
pi = 3.141592

print(2*r*pi)

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

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

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


print(R*2*math.pi)

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

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

Solution (Python):
import numpy as np
import math
import itertools

N = int(input())


print(2*N*math.pi)

Solution (Python):

import sys
import math

def solve(R: int):

    print(R*math.tau)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    solve(N)

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

Solution (Python):
import numpy as np

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

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

ans = math.pi * S *2

print(ans)

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

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

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 collections import  deque
import sys
import bisect
import math
import itertools
from queue import deque
from math import gcd

INF = float('inf')
mod = 10**9+7
eps = 10**-7

def inp(): return int(sys.stdin.readline())
 
def inp_list(): return list(map(int, sys.stdin.readline().split()))

def lcm(x, y): return (x * y) // gcd(x, y)

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

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

import math

print(math.pi*2*R)

Solution (Python):


from queue import Queue
from queue import LifoQueue as Stack
from math import sqrt, floor, ceil, log2, pi
from fractions import gcd
from itertools import permutations, combinations
from operator import itemgetter
from functools import cmp_to_key


INF=1001001001
__MOD__=(10**9)+7
yn = 'YNeos'
judge = False
cnt = 0
ans = None


def lcm(a, b):
    return (a*b) // gcd(a,b)

def intinput():
    return int(input())

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

def lineinputs(func=intinput):
    datas = []
    while True:
        try:
            datas.append(func())
        except EOFError:
            break
    return datas

class ModInt():
    def __init__(self, x):
        self.__x = (x % __MOD__)
    def __add__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x + other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x + other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __sub__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x - other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x - other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __mul__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x * other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x * other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __truediv__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x * other.__modinv())%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x * other.__modinv())%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __pow__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__(pow(self.__x, other.__x, __MOD__)))
        elif type(other) == ModInt:
            return self.__class__(pow(self.__x, other.__x, __MOD__))
        else:
            raise Exception("Not Int or Not ModInt")
    def __modinv(self, m=__MOD__):
        a = self.__x
        if a == 0:
            raise ZeroDivisionError()
        if gcd(a, m) != 1:
            raise Exception("%sの逆数は求まりません。" % a)
        b, u, v = m, 1, 0
        while b != 0:
            t = a//b;
            a -= t*b
            a, b = b, a
            u -= t * v
            u, v = v, u
        u %= m
        if u < 0:
            u += m
        return u
    def __int__(self):
        return self.__x



if __name__ == '__main__':
    N = intinput()

    
    print(2*N*pi)

Solution (Python):

import math
n = int(input())

print(2 * math.pi * n)

Solution (Python):
import math

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

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

Solution (Python):

import sys
sys.setrecursionlimit(10**8)
INF = float("inf")
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 = int(input())
import math
print(2*math.pi*R)

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

Solution (Python):
import math

R = int(input())

print(2*math.pi*R)

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

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

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(r*2*3.14)

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

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

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

Solution (Python):
import math

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

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

Solution (Python):
import math

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

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

import math

print(2*x*math.pi)

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

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

Solution (Python):


import sys
import math
INT_MAX = sys.maxsize
INT_MIN = -(sys.maxsize)
sys.setrecursionlimit(10**7)
mod = 1000000007


def IOE():
    sys.stdin = open("input.txt", "r")
    sys.stdout = open("output.txt", "w")


def main():
    n = int(sys.stdin.readline())
    print(2*math.pi*n)


if __name__ == "__main__":
    try:
        IOE()
    except:
        pass
    main()

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

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

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

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

Solution (Python):


import numpy as np
import math

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

Solution (Python):
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(int, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]




N = ii()

print(3.141592653589793*2*N)

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

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

Solution (Python):
import math

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

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

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,operator,string
def I(): return int(input())
def S(): return input()
def LI(): return list(map(int,input().split()))
def LS(): return list(input().split())

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

Solution (Python):
import sys 
import math





input = sys.stdin.readline
for tt in range(1):
	r = int(input())
	
	
	print(2*math.pi*r)

Solution (Python):
import math

R = int(input())

print(R * 2 * math.pi)

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

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

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

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

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

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

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

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

Solution (Python):

import sys
input = sys.stdin.readline
import math
 
r = int(input())
print(r * 2.0 * math.pi)

Solution (Python):

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

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

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

print(2*math.pi*R)

Solution (Python):
import math

n = int(input())

print(2*n*math.pi)

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

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

Solution (Python):

import math
n = int(input())

print(2 * math.pi * n)

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

print(res)

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

Solution (Python):
import math
x = 3.141592653589793238462643383279
y = int(input())
print (2*x*y)

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

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

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

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

Solution (Python):
import math

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

Solution (Python):
import math

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

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

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

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

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

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

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

print(2 * math.pi * R)

Solution (Python):
a = eval(input())
b = 2*(6.28318530717958623200/2)*a
print (float(b))

Solution (Python):
import math

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

print(Ans)

Solution (Python):
import math

radius = int(input())

print(2 * math.pi * radius)

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

Solution (Python):

import math

r = int(input())

print(2*r*math.pi)

Solution (Python):
import sys


from math import pi

def get_ints(): return map(int, sys.stdin.readline().strip().split())
def get_array(): return list(get_ints())
def input(): return sys.stdin.readline().strip()

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

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

Solution (Python):
import math
R = input()
print(2*int(R)*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):
n=int(input())
cir = 2*3.14*n
print(round(cir,2))

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

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

Solution (Python):
import sys
import numpy as np
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7


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

if __name__ == '__main__':
    main()

Solution (Python):
from math import pi

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

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

Solution (Python):


import math


r = int(input())


ans = r * 2 * math.pi


print(ans)

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

print(2*R*3.141592)

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

Solution (Python):

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

Solution (Python):



from math import *
from copy import *
from heapq import *
from string import *				
from random import *				
from bisect import *				
from sys import stdin				
from sys import maxsize
from operator import *				
from itertools import *
from collections import Counter		
from collections import defaultdict 

'''

'''

def solve(l):
	n = len(l)
	

N = int(stdin.readline())
ans = pi*(N*2)
print(ans)

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

answer = 2 * R * 3.14159

print(answer)

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

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

print(2*R*math.pi)

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

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

ans = 2 * R * math.pi

print(ans)

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

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

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

if 1<= a and a <=100:
    p = 2*a*math.pi


print(p)

Solution (Python):

R = int(input())

print(3.1412*2*R)

Solution (Python):
import math


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

Solution (Python):
import math

r = int(input())

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

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

Solution (Python):
import math

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

print(ans)

Solution (Python):



import math


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


if __name__ == '__main__':
    main()

Solution (Python):
import math

radius = int(input(""))

cir = 2 * math.pi * radius

print(cir)

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

print((a*2) * 3.1415926)

Solution (Python):

import sys
import numpy as np

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

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

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

from math import pi

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

Solution (Python):
import math

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

print(ans)

Solution (Python):
import math

R = int(input())

print(2*math.pi*R)

Solution (Python):

R = int(input())


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

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

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

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

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

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

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

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

Solution (Python):
import math

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

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

Solution (Python):

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

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

Solution (Python):
import scipy as sp

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

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

l = 2 * R * math.pi

print(l)

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

Solution (Python):
r = float(input())
tyokkei = float(2 * r)
ans = tyokkei *  3.14159
print(ans)

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

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

Solution (Python):
import math

R = int(input())

pi = 3.141592
print(2*R*pi)

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

Solution (Python):
import math
import operator as op
from functools import reduce
 
def ncr(n, r):
    r = min(r, n-r)
    numer = reduce(op.mul, range(n, n-r, -1), 1)
    denom = reduce(op.mul, range(1, r+1), 1)
    return numer / denom
"""
int(input())
map(int,input().split())
list(map(int,input().split()))
"""
 
 
            
       
 
t=1
for term in range(1,t+1):
    r=int(input())
    print(2*math.pi*r)

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

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

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

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

Solution (Python):
import math

inp = int(input())

print(2*inp*math.pi)

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

Solution (Python):

import math

R = int(input())

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

Solution (Python):
from math import pi

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

Solution (Python):
def i1str():
    return input()


def istrs(n=None):
    if n is None:
        return input().split()
    a = []
    for _ in range(n):
        a.append(istrs())
    return a


def i1num():
    return int(input())


def inums(n=None):
    if n is None:
        return list(map(int, input().split()))
    a = []
    for _ in range(n):
        a.append(inums())
    return a


def ostrs(l, sp=" "):
    print(sp.join(l))


def onums(l, sp=" "):
    print(sp.join(map(str, l)))


def solve(n):
    pi = 3.14159
    return 2*pi*n


if __name__ == "__main__":
    n = i1num()
    print(solve(n))

Solution (Python):
import math

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

print(output)

Solution (Python):
import math

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

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

Solution (Python):
import math

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

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

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

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

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

Solution (Python):
x = int(input())
pi = 3.14159

print(2 * x * pi)

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

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

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

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

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

Solution (Python):
import math

num = int(input())

print(num * 2 * math.pi)

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

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

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

print(r*2*math.pi)

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

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

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

Solution (Python):

import sys
input = sys.stdin.buffer.readline


from collections import defaultdict
import math

con = 10 ** 9 + 7

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


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



if __name__ == '__main__':
	main()

Solution (Python):
import sys
import math
def input(): return sys.stdin.readline().rstrip()

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

if __name__ == '__main__':
    main()

Solution (Python):

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

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

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

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

Solution (Python):
from math import pi


R = int(input().strip())
print(2.000 * R * pi)

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

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

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

if __name__ == '__main__':
    main()

Solution (Python):
if __name__ == "__main__":
    r = int(input())
    print((r*3.14159*2.0))

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

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

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

Solution (Python):
import sys
import math
N=int(input())
print(N*3.14*2)

Solution (Python):
from sys import stdin
import math

r = float(stdin.readline().rstrip())

print(2*3.1415*r)

Solution (Python):
from sys import stdin, stdout
import math,sys
from itertools import permutations, combinations
from collections import defaultdict,deque,OrderedDict
import bisect as bi
import heapq 
'''


def I():return (int(stdin.readline()))
def In():return(map(int,stdin.readline().split()))
'''



def I():return (int(input()))
def In():return(map(int,input().split()))

def find_gt(a, x):
    
    i = bi.bisect_right(a, x)
    if i != len(a):
        return i
    else:
        return -1


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

            
    except:
        pass
M = 998244353
P = 1000000007

if __name__ == '__main__':
    main()

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

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

Solution (Python):

from sys import stdin
import sys


def nextLine(): return next(stdin)
def nextStrList(): return nextLine().split()
def nextIntList(): return [int(_) for _ in nextStrList()]

import numpy as np

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

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

print(R*2*math.pi)

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

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

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

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