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


hostname = socket.gethostname()

if hostname == 'F451C':
    sys.stdin = open('a1.in')


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


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


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


def read_str():
    return input()


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


main()

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

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

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

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

Solution (Python):
from math import pi


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

Solution (Python):
import sys
import re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
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


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


if __name__ == '__main__':
    main()

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

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

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

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

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

Solution (Python):


r = int(input())

print(2*r*3.141592)

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

Solution (Python):
import math

def read():
    R = float(input())
    return R, 

def solve(R):
    return "{:.10f}".format(2 * math.pi * R)

if __name__ == '__main__':
    inputs = read()
    print("{}".format(solve(*inputs)))

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

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

Solution (Python):
import sys
from math import factorial
from collections import Counter
from fractions import Fraction
import heapq, bisect, fractions
import math
import itertools
sys.setrecursionlimit(10 ** 5 + 10)
INF = 10**15 +5
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()))
MOD = 10**9 + 7

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

Solution (Python):
import math
r = int(input())
ans = 2*r*math.pi
n = 5
y = math.floor(ans * 10 ** n) / (10 ** n)
print(y)

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

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

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

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

Solution (Python):
import math

r = input("")

r = int(r)

r = r*2*math.pi

print(r)

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

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

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

Solution (Python):
import math

r = int(input())
print( round((r+r) * math.pi,15))

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

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("{:f}".format(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):
import math

r = int(input())

print(2*r*math.pi)

Solution (Python):
print(((44)*int(input()))/7)

Solution (Python):
import numpy as np

N = int(input())

print(float(2 * np.pi * N))

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

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

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

import math
y = math.pi

print(2*x*y)

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

print(2*3.14159265*R)

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

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

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

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

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

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

Solution (Python):
import math

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

Solution (Python):


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

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

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

Solution (Python):
import math


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

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

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

print (2.0*R*np.pi)

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

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

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

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

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


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


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

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


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

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

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

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

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

Solution (Python):
enshu = 3.1415926535
R = int (input())
F =  float(R)
length =2.00 * enshu * F
print(length)

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

Solution (Python):
import math

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

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

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

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
r = int(input())
ans = 2 * r * math.pi
print("{:.03}".format(ans))

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

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

Solution (Python):
import math

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

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

print(2 * A * math.pi)

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

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

Solution (Python):
PI = 3.1415926535
try:
    R = int(input())
    l = 2*R*PI
except EOFError:
    pass
print(float(l))

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

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

Solution (Python):
import math

R = int(input())

print(2*math.pi*R)

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

Solution (Python):
import math

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

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

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

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

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

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

print(ans)

Solution (Python):
import sys


from math import pi

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

Solution (Python):
import math

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

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

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

Solution (Python):
import decimal

r=int(input())
decimal.getcontext().prec=5
r=decimal.Decimal(r)
a=decimal.Decimal(3.14159)

t=r*2*a
print(t)

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

p = np.pi
l = 2 * p * r
print(l)

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

Solution (Python):
import math

r = 0

def format_input(filename = None):
	global r
	if filename == None:
		r = int(input())

	elif filename == '__random__':
		from random import randint as rng
		r = rng(1, 10**2)
		print(r)

def get_answer():
	answer = 2 * r * math.pi
	return answer

if __name__ == '__main__':
	format_input()

	ans = get_answer()
	print(ans)

Solution (Python):
import numpy

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

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

Solution (Python):
n = int(input())
a = n/0.1591549431
print(a)

Solution (Python):
from math import pi

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

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

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

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

Solution (Python):
from math import floor,ceil,sqrt,factorial,log
from collections import Counter, deque
from functools import reduce
import numpy as np
def S(): return input()
def I(): return int(input())
def MS(): return map(str,input().split())
def MI(): return map(int,input().split())
def FLI(): return [int(i) for i in input().split()]
def LS(): return list(MS())
def LI(): return list(MI())
def LLS(): return [list(map(str, l.split() )) for l in input()]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def LLSN(n: int): return [LS() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]

pi = 3.14

r = I()

print(2*r*3.14)

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

print(l)

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

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

Solution (Python):


int1 = lambda x: int(x) - 1
def II(): return int(input())

def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())

def LI(): return list(map(int, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]

import math

def solve():
    r = II()
    print(2 * math.pi * r)


if __name__ == '__main__':
    solve()

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

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

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

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

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

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())
print("%.12f" % (r*2*3.141592653589))

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

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

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

print(2*R*np.pi)

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

import math

print(2.0*math.pi*r)

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

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

Solution (Python):
R = int(input().rstrip())
print(R * 2 * 3.141592653589793238462643383279502884197169399375105820974944592307816406)

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

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

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

Solution (Python):

R = int(input())

print(R*2*3.14159265359)

Solution (Python):
import  math

R=int(input())

print(2*math.pi*R)

Solution (Python):


import sys
import math


















def main():
    mod = 1000000007                  
    inf = float('inf')
    sys.setrecursionlimit(10**6)    
    def input(): return sys.stdin.readline().rstrip()
    def ii():  return int(input())
    def mi():  return map(int, input().split())
    def mi_0(): return map(lambda x: int(x)-1, input().split())
    def lmi(): return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():  return list(input())
    
    
    a = ii()
    print(a * 2 * math.pi)

if __name__ == "__main__":
    main()

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





print(2*r*3.14159265)

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

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

Solution (Python):


def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    
    from itertools import combinations, permutations, accumulate, groupby, product
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    from math import floor, ceil
    import math
    

    
    

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

if __name__ == '__main__':
    main()

Solution (Python):
R = input()

print( 2 * 3.141 * int(R) )

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

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

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

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

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

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

Solution (Python):
import math

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

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

Solution (Python):
import math

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

Solution (Python):
from math import pi

r = int(input())

print(r * 2 * pi)

Solution (Python):
import math

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

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

Solution (Python):
import math


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

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

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

Solution (Python):

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

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

print(2*3.14*R)

Solution (Python):
import math

r = int(input())

print(r * math.pi * 2)

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque

sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
     
def main():
    R = I()
    print(2 * R * 3.1415926535)

main()

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

L = 2 * R * 3.1415926535897932384626433832795028841
print(L)

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

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

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

Solution (Python):
p = 3.141592653589

r = int(input())

print(2*r*p)

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

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

if __name__ == "__main__":
    resolve()

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

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

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

Solution (Python):













R = int(input())

ans = 2*R*3.14159265359

print(ans)

Solution (Python):
import math

if __name__ == '__main__':
  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 = float(input())
circumference = 2 * math.pi * R
print("%.20f" % circumference)

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

Solution (Python):

R = int(input())

π=3.141592
syutyou = 2*π*R
print(syutyou)

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

Solution (Python):
import math

n = int(input())

ans = 2 * math.pi * n

print(ans)

Solution (Python):
import math

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

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

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

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

Solution (Python):
n = int(input())
a = n/0.1591549431
print(a)

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

R=input()
r=float(R)
ans=r*2*pi
print(ans)

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

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

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

Solution (Python):


import sys, math
sys.setrecursionlimit(300000)


def solve(R):
    ret = R * 2 * math.pi
    print(ret)
    return

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

if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):
import math

r=float(input())

print(2*math.pi*r)

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

print(2*(pi)*r)

Solution (Python):
R = input()

print( 2 * 3.141 * int(R) )

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

Solution (Python):
import math

r = int(input())

print(2 * math.pi * r)

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

print(2*3.14159265*R)

Solution (Python):


int1 = lambda x: int(x) - 1
def II(): return int(input())

def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())

def LI(): return list(map(int, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]


def solve():
    r = II()
    print(2 * 3.141592 * r)


if __name__ == '__main__':
    solve()

Solution (Python):

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

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

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

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

Solution (Python):
import  math

R=int(input())

print(2*math.pi*R)

Solution (Python):
import math


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


if __name__ == "__main__":
    main()

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):
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
from itertools import permutations,combinations,groupby
import sys,bisect,string,math,time,functools,random
def Golf():*a,=map(int,open(0))
def I():return int(input())
def S_():return input()
def IS():return input().split()
def LS():return [i for i in input().split()]
def LI():return [int(i) for i in input().split()]
def LI_():return [int(i)-1 for i in input().split()]
def NI(n):return [int(input()) for i in range(n)]
def NI_(n):return [int(input())-1 for i in range(n)]
def StoLI():return [ord(i)-97 for i in input()]
def ItoS(n):return chr(n+97)
def LtoS(ls):return ''.join([chr(i+97) for i in ls])
def GI(V,E,Directed=False,index=0):
    org_inp=[];g=[[] for i in range(n)]
    for i in range(E):
        inp=LI();org_inp.append(inp)
        if index==0:inp[0]-=1;inp[1]-=1
        if len(inp)==2:
            a,b=inp;g[a].append(b)
            if not Directed:g[b].append(a)
        elif len(inp)==3:
            a,b,c=inp;aa=(inp[0],inp[2]);bb=(inp[1],inp[2]);g[a].append(bb)
            if not Directed:g[b].append(aa)
    return g,org_inp
def GGI(h,w,search=None,replacement_of_found='.',mp_def={'

    mp=[1]*(w+2);found={}
    for i in range(h):
        s=input()
        for char in search:
            if char in s:
                found[char]=((i+1)*(w+2)+s.index(char)+1)
                mp_def[char]=mp_def[replacement_of_found]
        mp+=[1]+[mp_def[j] for j in s]+[1]
    mp+=[1]*(w+2)
    return h+2,w+2,mp,found
def TI(n):return GI(n,n-1)
def bit_combination(k,n=2):
    rt=[]
    for tb in range(n**k):
        s=[tb//(n**bt)%n for bt in range(k)];rt+=[s]
    return rt
def show(*inp,end='\n'):
    if show_flg:print(*inp,end=end)

YN=['YES','NO'];Yn=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase

input=lambda: sys.stdin.readline().rstrip()

class Comb:
    def __init__(self,n,mo=10**9+7):
        self.fac=[0]*(n+1)
        self.inv=[1]*(n+1)
        self.fac[0]=1
        self.fact(n)
        for i in range(1,n+1):
            self.fac[i]=i*self.fac[i-1]%mo
            self.inv[n]*=i
            self.inv[n]%=mo
        self.inv[n]=pow(self.inv[n],mo-2,mo)
        for i in range(1,n):
            self.inv[n-i]=self.inv[n-i+1]*(n-i+1)%mo
        return
    
    def fact(self,n):
        return self.fac[n]
        
    def invf(self,n):
        return self.inv[n]

    def comb(self,x,y):
        if y<0 or y>x:
            return 0
        return self.fac[x]*self.inv[x-y]*self.inv[y]%mo

show_flg=False
show_flg=True

ans=0


a=I()


ans=2*a*3.14159265
print(ans)

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

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

print(2*a*r)

Solution (Python):
r = float(input())
print(r * 6.28318)

Solution (Python):
import math

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

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

Solution (Python):

R = int(input())

print(R*2*3.14159265359)

Solution (Python):

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

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

Solution (Python):
import math

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

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

print(output)

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

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

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

from math import pi

print(2 * R * pi)

Solution (Python):
import math

r = int(input())

print(r * 2 * math.pi)

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

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


if __name__ == '__main__':
    main()

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

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

print(2*R*math.pi)

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

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

Solution (Python):
r=int(input(""))
if 1<=r<=100:
    c=2*3.14*r
print(c)

Solution (Python):
import math

r = int(input())

print(math.pi*2*r)

Solution (Python):
import math


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

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

Solution (Python):
import math

r = int(input())

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

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

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

Solution (Python):

import math


def main():

    
    first_input = list(map(lambda x:int(x), input().split(" ")))
    

    
    
    

    
    

    R = first_input[0]

    print(R*2*math.pi)

if __name__ == '__main__':
    main()

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

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

pi = 3.141592

print(2*r*pi)

Solution (Python):
PI = 3.141592653589793238
def circumference(r): 
	return (2 * PI * r) 


print ('%.20f' % circumference(int(input())))

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

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

Solution (Python):

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

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

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

Solution (Python):
n = int(input())
a = n/0.1591549431
print(a)

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

Solution (Python):
import math

R = float(input())

print(2*math.pi*R)

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

res = 2 * math.pi * R

print(res)

Solution (Python):

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

Solution (Python):

import math

R = int(input())

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

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

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

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

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

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

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

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

radius = int(input())

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

Solution (Python):
def circumference(R):
  circum = 2*3.1415*R
  return (circum)
a= int(input())
print(circumference(a))

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

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

print(r * 2 * 3.14159265)

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

Solution (Python):
import math

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

Solution (Python):
r=int(input())
c=2*3.14*r
print("{:.2f}".format(c))

Solution (Python):
import math

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

Solution (Python):
import math

r = int(input())

print(math.pi*r*2.0)

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

import math

print(math.pi*R*2)

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

print(2*n*3.1415926535)

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

Solution (Python):
def pi():
    A=10000000
    pi=0
    for L in range(1,A):
        if L%2==0:
            B=-1
        else:
            B=1
        pi+=(4/(2*L-1))*B
    return pi
 
R = int(input())
print(pi()*2*R)

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

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

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

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

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

ans = r * 2 * 3.14

print(ans)