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

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


R = int(input())

print(circle_round(R))

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

Solution (Python):

import math
pi = math.pi

R = int(input())

print(2* pi * R)

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

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

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

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

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

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

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

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

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

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

if __name__ == '__main__':
    main()

Solution (Python):
import math

n = int(input())

print(math.pi * n * 2)

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

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

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

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

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

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

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

print(n*2*3.14)

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

X = R * math.pi * 2


print(X)

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

print(2*pi*R)

Solution (Python):

def q1():
    import math
    num = int(input())
    print(num * 2 * math.pi)


q1()

Solution (Python):
import math

num = int(input())

print(num * 2 * math.pi)

Solution (Python):
import math


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


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


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


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

Solution (Python):

import math

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


main()

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

print(R*3.1415*2)

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

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

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

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

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

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

Solution (Python):
from math import pi

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

Solution (Python):
r = int(input())
print(2 * 3.1415926535 * 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 numpy as np
r = int(input())
ans = 2*r * np.pi
print(ans)

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

Solution (Python):
import sys
sys.setrecursionlimit(10**6)
from math import floor,ceil,sqrt,factorial,log,pi
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from operator import itemgetter
from fractions import gcd
mod = 10 ** 9 + 7
inf = float('inf')
ninf = -float('inf')
 

def ii(): return int(sys.stdin.readline().rstrip()) 
def mii(): return map(int,sys.stdin.readline().rstrip().split())
def limii(): return list(mii()) 
def lin(n:int): return [ii() for _ in range(n)]
def llint(n: int): return [limii() for _ in range(n)]

def ss(): return sys.stdin.readline().rstrip() 
def mss(): return sys.stdin.readline().rstrip().split()
def limss(): return list(mss()) 
def lst(n:int): return [ss() for _ in range(n)]
def llstr(n: int): return [limss() for _ in range(n)]






n=ii()

print(2*3.14159265*n)

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

Solution (Python):
import math

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


if __name__ == "__main__":
    main()

Solution (Python):

R = int(input())


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

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

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

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

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

print( 2 * r * math.pi)

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

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

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

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

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

print(2 * R * math.pi)

Solution (Python):
import math

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

R = int(input())

print(circle_round(R))

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

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

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

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

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

Solution (Python):
import math

R = float(input())

print(2*math.pi*R)

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

print(2*r*math.pi)

Solution (Python):
import numpy as np


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

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

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

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

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

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

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

print(R*2*3.141)

Solution (Python):
from decimal import *
r = int(input())
print(Decimal(2*3.14*r))

Solution (Python):
import math

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

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

    
    
    
    
    
    
    
    
    
    
    
    
    
    
    


if __name__ == "__main__":
    main()

Solution (Python):
import sys

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

if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):
import sys
import math
stdin = sys.stdin
     
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))

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

Solution (Python):


r = int(input())


print(2*r*3.141592)

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

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

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

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

print(2 * math.pi * r)

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

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

Solution (Python):

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

Solution (Python):
import sys
import math

R=int(input())

print(2*math.pi*R)

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

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

print(2*r*3.14159)

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

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

Solution (Python):
import math

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

Solution (Python):
import math

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

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

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

Solution (Python):
import math

A = int(input())

print(A*2*math.pi)

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

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

Solution (Python):
pi = 3.14159265358979323846

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

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

Solution (Python):
import math
R=float(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 * R * 2.0)

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

p = np.pi

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

Solution (Python):
si = lambda: input().strip()
ii = lambda: int(input())
mii = lambda: map(int, input().split())
lmii = lambda: list(map(int, input().split()))
smii = lambda: sorted(map(int, input().split()))



from math import pi

R = ii()

print(R*2*pi)

Solution (Python):
R = float(input())
print(3.14159265*2*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):
n = int(input())
print(n*6.28318530717958623200)

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

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

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

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


ans = 2*3.14159*R
print(ans)

Solution (Python):
import math

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

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

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

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

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

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

Solution (Python):
import math

R = int(input())

circumference_length = 2 * math.pi * R

print(circumference_length)

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

print(2*3.141592*R)

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

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

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

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

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

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

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

print(2 * r * pi)

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

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

Solution (Python):
import math

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

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

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

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

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

Solution (Python):
import math
math.pi

a = int(input())

print(2 * math.pi * a)

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

Solution (Python):
n = float(input())
print(2.0*n*3.1415926)

Solution (Python):
import math

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

Solution (Python):
import sys
import itertools
if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
    
p=3.14159265
r=int(input())

print(2*p*r)

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

Solution (Python):


R = int(input())

print(R * 2 * 3.1415927535879)

Solution (Python):
import math

R = int(input())

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

Solution (Python):
import math







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

def resolve():

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

resolve()

Solution (Python):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
from pprint import pprint
from copy import deepcopy
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
from pprint import pprint


sys.setrecursionlimit(2147483647)
INF = 10 ** 15
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007

print(3.14 * I() * 2)

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

Solution (Python):
import numpy as np

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

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

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

import math

print(math.pi * 2 * r)

Solution (Python):
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

def main():
  r=I()
  return (r*2)*math.pi


print(main())

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

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

ans = 2*r*3.14159265

print(ans)

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

print(math.pi * a * 2)

Solution (Python):
import math

R = int(input())

print(math.pi * 2 * R)

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

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

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

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

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

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

Solution (Python):
import sys


sys.setrecursionlimit(10 ** 9)



r = int(input())

print(2*r*3.14159265)

Solution (Python):
import math

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

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

Solution (Python):
from collections import deque
from heapq import heapify,heappop,heappush,heappushpop
from copy import copy,deepcopy
from itertools import permutations,combinations
from collections import defaultdict,Counter
from math import gcd,ceil,floor,factorial,pi

from functools import reduce
from pprint import pprint

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

def mylistinput(n):
    return [ list(myinput()) for _ in range(n) ]

def mycol(data,col):
    return [ row[col] for row in data ]

def mysort(data,col):
    data.sort(key=lambda x:x[col],reverse=False)
    return data

def mymax(data):
    M = -1*float("inf")
    for i in range(len(data)):
        m = max(data[i])
        M = max(M,m)
    return M

def mymin(data):
    m = float("inf")
    for i in range(len(data)):
        M = min(data[i])
        m = min(m,M)
    return m

def myoutput(ls,space=True):
    if space:
        if len(ls)==0:
            print(" ")
        elif type(ls[0])==str:
            print(" ".join(ls))
        elif type(ls[0])==int:
            print(" ".join(map(str,ls)))
        else:
            print("Output Error")
    else:
        if len(ls)==0:
            print("")
        elif type(ls[0])==str:
            print("".join(ls))
        elif type(ls[0])==int:
            print("".join(map(str,ls)))
        else:
            print("Output Error")

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

Solution (Python):

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

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

import math

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

if __name__ == '__main__':
  main()

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

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

print(2*R*3.141592)

Solution (Python):
import math

r = int(input())

print(math.pi * r * 2)

Solution (Python):
import math

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

print(output)

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

Solution (Python):
import bisect
import cmath
import heapq
import itertools
import math
import operator
import os
import random
import re
import string
import sys
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from functools import lru_cache, reduce
from math import gcd
from operator import add, itemgetter, mul, xor

import numpy as np

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7



r = int(sys.stdin.buffer.readline())
a = r * 2 * math.pi
print(a)

Solution (Python):
import math

N = int(input())

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

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

Solution (Python):
import math

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

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

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

print(2*R*3.14)

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

Solution (Python):

import math

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

print(C)

Solution (Python):
import math

def main():
    n = int(input())
    print(math.tau*n)

if __name__ == "__main__":
    main()

Solution (Python):
import math

r = int(input())

print(2*r*math.pi)

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

from  math import pi

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

Solution (Python):
import sys

input_methods=['clipboard','file','key']
using_method=0
input_method=input_methods[using_method]

IN=lambda : map(int, input().split())
mod=1000000007



pi=3.14159265358979

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

isTest=False

def pa(v):
	if isTest:
		print(v)
		
def input_clipboard():
	import clipboard
	input_text=clipboard.get()
	input_l=input_text.splitlines()
	for l in input_l:
		yield l

if __name__ == "__main__":
	if sys.platform =='ios':
		if input_method==input_methods[0]:
			ic=input_clipboard()
			input = lambda : ic.__next__()
		elif input_method==input_methods[1]:
			sys.stdin=open('inputFile.txt')
		else:
			pass
		isTest=True
	else:
		pass
		
			
	ret = main()
	if ret is not None:
		print(ret)

Solution (Python):
import sys
from math import pi



Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
 
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 18
MOD = 998244353



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

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

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

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

Solution (Python):


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

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

Solution (Python):
import math

R = int(input())

print(R * 2 * math.pi)

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

round = R * 3.14159265359 * 2

print(round)

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

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

Solution (Python):
import math

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

Solution (Python):
from math import pi

def mawari(n):
    return 2*pi*n

n = int(input())

print(mawari(n))

Solution (Python):
import math

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

num = int(input('')) 

ans = circle_round(num)

print(ans)

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

    print(2.0*math.pi*r)


if __name__ == '__main__':
    main()

Solution (Python):
from math import pi

R = int(input())

print(2 * pi * R)

Solution (Python):
import math
R = int(input())
print(R*2*math.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):
import math, sys
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from copy import deepcopy
from functools import lru_cache
from heapq import heapify, heappop, heappush
from itertools import accumulate, combinations, permutations
input = sys.stdin.readline
p = 10**9 + 7
ns = lambda: input().strip()
ni = lambda: int(input().strip())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))

def main():
    r = ni()

    print(2 * math.pi * r)

if __name__ == '__main__':
    main()

Solution (Python):
import math

r = int(input())

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

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

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

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

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

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

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

Solution (Python):
import math

R = int(input())

ans = 2*R*math.pi

print(ans)

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

if __name__ == '__main__':
    main()

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

Solution (Python):
import math 

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

Solution (Python):
import sys
from collections import defaultdict, Counter, deque
from itertools import accumulate, permutations, combinations
from operator import itemgetter
from bisect import bisect_left, bisect_right, bisect
from heapq import heappop, heappush
from fractions import gcd
from math import ceil, floor, sqrt, cos, sin, pi
from copy import deepcopy




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

if __name__ == '__main__':
    main()

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

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

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

print(2*A*N)

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

Solution (Python):
from math import pi

r = int(input())
print("%.15lf"%(2 * pi * r))

Solution (Python):
import math

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

Solution (Python):
def main():
    R = int(input())
    print(R*2*3.141526)

if __name__ == "__main__":
    main()

Solution (Python):
import sys
import math
from collections import deque
input = lambda: sys.stdin.readline().rstrip()
Yes = lambda boolean: print('Yes') if boolean else print('No')
YES = lambda boolean: print('YES') if boolean else print('NO')
aint = lambda: int(input())
ints = lambda: list(map(int, input().split()))
is_even = lambda x: True if x%2==0 else False
zeros2d = lambda r,c: [[0 for col in range(c)] for row in range(r)]

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

Solution (Python):
import math

r=int(input())

L=2*math.pi*r

print(L)

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

Solution (Python):
import math

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

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

pi = 3.1415926535

print(2*r*pi)

Solution (Python):
pi = 3.1415926
 

def inp():
    return(int(input().rstrip()))
def inlt():
    return(list(map(int,input().rstrip().split())))
def insr():
    s = input().rstrip()
    return(s[:len(s) - 1])
def invr():
    return(map(int,input().rstrip().split()))

n = inp()
print(2*n*pi)

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

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

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

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

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

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

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('{}'.format(R*3.141592653589793*2))

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

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

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

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

Solution (Python):
import math

R = int(input())

ans = 2 * R * math.pi

print(ans)

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

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

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

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

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

def s_in():
    return input()

def n_in():
    return int(input())

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

def print_l(l):
    print(' '.join(map(str, l)))

class Interval():
    def __init__(self, li):
        self.li = li
        self.n = len(li)
        self.sum_li = [li[0]]
        for i in range(1, self.n):
            self.sum_li.append(self.sum_li[i-1] + li[i])

    def sum(self, a, b=None):
        if b is None:
            return self.sum(0, a)

        res = self.sum_li[min(self.n-1, b-1)]
        if a > 0:
            res -= self.sum_li[a-1]
        return res

import math
print(math.pi*2*n_in())

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

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

Solution (Python):
import math
def ii(): return int(input())
def mi(): return map(int, input().split())
def li(): return list(mi())
n = ii()

print(2*n*math.pi)

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

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

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

import math

print(2*R*math.pi)