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

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

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

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

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

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

Solution (Python):



import math

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


if __name__ == '__main__':
    main()

Solution (Python):


R = float(input())
print(R * 6.28)

Solution (Python):
import math
import queue
 
def readInt():
	return int(input())
 
def readInts():
	return list(map(int, input().split()))
 
def readChars():
	return input().split()
 
 
r = readInt()
 
print(r*2*3.14159265)

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

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

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

Solution (Python):
pi = 3.14159265358979

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

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

Solution (Python):

import math

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

print(ans)

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

print(2 * np.pi * r)

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

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

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

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

print(r*2*3.14)

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

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

Solution (Python):

import sys

pi = 3.1415


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


if __name__ == '__main__':
    main()

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

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

print(ans)

Solution (Python):
import math

r = int(input())

ans = 2 * math.pi * r

print(ans)

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

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

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

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

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

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

Solution (Python):
import math

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

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

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

Solution (Python):
import math
radius = float(input())
circumference = 2 * math.pi * radius
print("%.2f" % (circumference))

Solution (Python):
import math

r = int(input())

print(2 * math.pi * r)

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

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

Solution (Python):
import math
print("%.5f"%(2*math.pi*int(input())))

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

Solution (Python):
import math

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


main()

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

Solution (Python):
from math import pi
if __name__ == '__main__':
    N = int(input())
    print(2*pi*N)

Solution (Python):
import math

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

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

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

Solution (Python):
import math

s=float(input())

l=float(2*s)*math.pi
print(l)

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

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

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

if __name__ == '__main__':
    main()

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

'''デック'''

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

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

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




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


if __name__ == '__main__':
    main()

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

import math

print(2*r*math.pi)

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

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

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

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

Solution (Python):
from numpy import *
x= int(input())
print(pi*x*2)

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

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

Solution (Python):
import math

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

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

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

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

L = 2*N*3.1415926535
print(L)

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

Solution (Python):
import numpy as np
from collections import defaultdict
from math import gcd
import time
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
 
 
start = time.time()

N = int(input())
rad=N*2*3.14
print(rad)

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

Solution (Python):
import math

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

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

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

print(2*n*math.pi)

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

Solution (Python):


import math
 

r = int(input())
 

ans = r * 2 * math.pi
 

print(ans)

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

Solution (Python):

import sys
import math


def solve(N: int):
    print(N * 2 * math.pi)
    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(2*n*math.pi)

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

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

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

Solution (Python):
import math

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

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

Solution (Python):


import math

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

    print(2*r*math.pi)

if __name__ == '__main__':
    main()

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

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

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

R=float(input())

print(2.0*pi*R)

Solution (Python):



def main():
    R = int(input())
    
    return R * 2 * 3.1415


print(main())

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

Solution (Python):
import math


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

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

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

Solution (Python):
import math

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

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

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

Solution (Python):






import sys
input = sys.stdin.readline

import math
from collections import deque
from fractions import gcd
from functools import lru_cache






MOD = 10**9+7
INF = float('inf')






def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]


def inv(n): return pow(n, MOD-2, MOD)


kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret


def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])
    return arr


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





R = inputI()

print(R*3.1415926535*2)

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

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

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

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

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

import math

print(2 * R * math.pi)

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

Solution (Python):
import math

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

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

print(2*3.1415*R)

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

Solution (Python):
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

import numpy as np

n = ii()
print(n*2*np.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):
r = int(input())
pi = 3.14159265358979323846
print(2*r*pi)

Solution (Python):
import sys
import os
from io import BytesIO, IOBase






'''def sieve(n):
    if n < 2: return list()
    prime = [True for _ in range(n + 1)]
    p = 3
    while p * p <= n:
        if prime[p]:
            for i in range(p * p, n + 1, p):
                prime[i] = False
        p += 2
    r = [2]
    for p in range(3, n + 1, 2):
        if prime[p]:
            r.append(p)
    return r'''


'''def divs(n, start=1):
    divisors = []
    for i in range(start, int(n**.5) + 1):
        if n % i == 0:
            if n / i == i:
                divisors.append(i)
            else:
                divisors.extend([i, n // i])
    return len(divisors)'''


'''def divn(n, primes):
    divs_number = 1
    for i in primes:
        if n == 1:
            return divs_number
        t = 1
        while n % i == 0:
            t += 1
            n //= i
        divs_number *= t
    return divs_number'''


'''def flin(d, x, default=-1):
    left = right = -1
    for i in range(len(d)):
        if d[i] == x:
            if left == -1: left = i
            right = i
    if left == -1:
        return (default, default)
    else:
        return (left, right)'''


'''def xor1_n(n):
    d={0:n,1:1,2:n+1,3:0}
    return d[n&3]'''

def cel(n, k): return n // k + (n % k != 0)
def ii(): return int(input())
def mi(): return map(int, input().split())
def li(): return list(map(int, input().split()))
def lcm(a, b): return abs(a * b) // math.gcd(a, b)
def prr(a, sep=' '): print(sep.join(map(str, a)))
def dd(): return defaultdict(int)
def ddl(): return defaultdict(list)
def ddd(): return defaultdict(defaultdict(int))



BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
            while True:
                    b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
                    if not b:
                            break
                    ptr = self.buffer.tell()
                    self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
            self.newlines = 0
            return self.buffer.read()

    def readline(self):
            while self.newlines == 0:
                    b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
                    self.newlines = b.count(b"\n") + (not b)
                    ptr = self.buffer.tell()
                    self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
            self.newlines -= 1
            return self.buffer.readline()

    def flush(self):
            if self.writable:
                    os.write(self._fd, self.buffer.getvalue())
                    self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
            self.buffer = FastIO(file)
            self.flush = self.buffer.flush
            self.writable = self.buffer.writable
            self.write = lambda s: self.buffer.write(s.encode("ascii"))
            self.read = lambda: self.buffer.read().decode("ascii")
            self.readline = lambda: self.buffer.readline().decode("ascii")


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

from collections import defaultdict 


from math import gcd,pi















r=ii()
p=3.141592653589793
print(2*p*r)

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

Solution (Python):

R = int(input())


print(2*R*3.141592)

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

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

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

print(2*R*math.pi)

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

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

Solution (Python):
import math

r = input()

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

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

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

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

print(2 * r * 3.141592653589793)

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

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

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

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

if __name__ == "__main__":
    main()

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

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

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

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

pi = 3.14159265;

c = 2*pi*r;

print(c)

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

Solution (Python):
import math

import math

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

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

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

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

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

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

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

Solution (Python):
import math

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

Solution (Python):
def solve():
    R = float(input())
    print(R*2*3.14159276358929323846264)
 
 
 
if __name__ == '__main__':
    solve()

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

Solution (Python):

import math 

r = int(input())

print(r*2*math.pi)

Solution (Python):
import math

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

Solution (Python):


import math

R = int(input())

print(2*math.pi*R)

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

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

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

Solution (Python):
from sys import stdin
import math


if __name__ == "__main__":
    _in = [_.rstrip() for _ in stdin.readlines()]
    R = int(_in[0])  
    
    cnt = 2*math.pi*R
    
    print(cnt)

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

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

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

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

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

ans=3.14*(2*R)

print(ans)

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

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

Solution (Python):





from math import pi






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

Solution (Python):
r = eval(input())
pi = 3.14159265359
print(2*pi*r)

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

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

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

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

print(np.pi * 2 * radius)

Solution (Python):
PI = 3.1415926535


def main():
    r = int(input())
    return 2 * r * PI


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

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

ans = R * 3.1415 *2
print(ans)

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

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

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

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

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

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

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

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

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

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

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

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

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

print(2*R*3.1415926536)

Solution (Python):
import math

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

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

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

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

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

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

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

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

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

Solution (Python):
import math
print("%.2f"%(2.00000*math.pi*int(input())))

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

print(2*3.1416*R)

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

Solution (Python):

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

Solution (Python):

import math

def main():

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

if __name__ == '__main__':
    main()

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

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

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

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

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

Solution (Python):
import math

r = float(input())

print(r * 2 * math.pi)

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

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

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

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

Solution (Python):
from sys import stdin
import math

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

print(2*3.1415*r)

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

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


circum = (R * 2) * 3.1415926535

print(circum)

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

Solution (Python):


import sys
stdin = sys.stdin
import math

def ns(): return stdin.readline().rstrip()
def ni(): return int(ns())
def na(): return list(map(int, stdin.readline().split()))

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

if __name__ == "__main__":
    main()

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

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

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

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

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

l = 2 * r * 3.14159265358979

print(l)

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

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

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

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

Solution (Python):

s = input().split()
s = int(s[0])
print(s*2*3.1415)

Solution (Python):



r = int(input())

print(2 * (3.14) * r)

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

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

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

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

Solution (Python):
import math

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

print(output)

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

Solution (Python):
import math

r = float(input())

ans = 2*r*math.pi

print(ans)

Solution (Python):
def resolve():
	r = int(input())
	print(2 * r * 3.14159265358)
resolve()