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

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

Solution (Python):
import math

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

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

Solution (Python):



def main():
    from math import pi
    import sys
    input = sys.stdin.readline

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


if __name__ == '__main__':
    main()

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

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

Solution (Python):
import math

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

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 6)

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 LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]

INF = float('inf')

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


if __name__ == '__main__':
    solve()

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

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

answer = 2 * r * 3.14159
print(answer)

Solution (Python):
import math

R = float(input())

print (2 * R * math.pi)

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

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

Solution (Python):

import sys
import math


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

r = int(input())

print(r * 2.0 * math.pi)

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):

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

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


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

if __name__ == '__main__':
  print(circle_round(int(x)))

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

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

Solution (Python):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop
from itertools import permutations, accumulate
from math import sqrt, ceil, floor
from bisect import bisect_left, bisect_right
from copy import deepcopy
from operator import itemgetter
from fractions import gcd
import sys
def I(): return int(input())  
def Is(): return map(int, input().split())  
def LI(): return list(map(int, input().split()))  
def TI(): return tuple(map(int, input().split()))  
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def TIR(n): return [TI() for _ in range(n)]
def S(): return input()
def Ss(): return input().split()  
def LS(): return list(input())  
def SR(n): return [S() for _ in range(n)]
def SsR(n): return [Ss() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
sys.setrecursionlimit(1000000)
MOD = 1000000007
INF = float('inf')

r = I()
print(r*6.28318530717958623200)

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

Solution (Python):
import math
math.pi

r = int(input())

print(2*r*math.pi)

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

print(a*2*3.14)

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

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

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

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

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

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

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

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

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

Solution (Python):
import sys
import math
def i():return int(sys.stdin.readline().replace("\n",""))
def i2():return map(int,sys.stdin.readline().replace("\n","").split())
def s():return str(sys.stdin.readline().replace("\n",""))
def l():return list(sys.stdin.readline().replace("\n",""))
def intl():return [int(k) for k in sys.stdin.readline().replace("\n","").split()]
def lx():return list(map(lambda x:int(x)*-1,sys.stdin.readline().replace("\n","").split()))
def t():return tuple(map(int,sys.stdin.readline().replace("\n","").split()))

def main():
    r = i()
    print(2*math.pi*r)
if __name__ == "__main__":
    main()

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

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

Solution (Python):
import math

R = int(input())

print(2*R*math.pi)

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

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

result = 2 * R * 3.14

print (result)

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

print(2*R*py)

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

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

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

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

a=628*i
print(a/100)

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

print(3.14159*2*i)

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

print(i*2*3.14159)

Solution (Python):
import math

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

Solution (Python):
import math

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

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

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

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

Solution (Python):
import math

r = int(input())

print(r * 2 * math.pi)

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

Solution (Python):
from math import pi

R = int(input())

print(2 * R * pi)

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

Solution (Python):

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

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

print(h)

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

print(2 * r * np.pi)

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

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

Solution (Python):
import sys
rs = lambda: sys.stdin.readline().rstrip()
ri = lambda: int(rs())
rs_ = lambda: [_ for _ in rs().split()]
ri_ = lambda: [int(_) for _ in rs().split()]

R = float(rs())
print(2 * 3.1415 * R)

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

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

Solution (Python):
from math import pi

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

Solution (Python):
import math

R = int(input())

print(2 * math.pi * R)

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

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

Solution (Python):
import math

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

Solution (Python):
import math

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


    return 0

if __name__ == '__main__':
    main()

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

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

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

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

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):
print(int(input())*6.3)

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

print(2 * 3.141592 * R)

Solution (Python):
import sys
import math

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

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

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

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

print(R * 2 * 3.14159)

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

Solution (Python):

print(int(input())*2*3.141421356)

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

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

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

Solution (Python):

import math

a=int(input())
b=math.pi

c=2*a*b

print(c)

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

print( r*2*3.141592653589793238462643383279 )

Solution (Python):
import math

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

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

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

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

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

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

Solution (Python):

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

Solution (Python):
import math

r = int(input())

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

Solution (Python):
import math

r=int(input())

ans=2*math.pi*r

print(ans)

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

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

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

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

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

Solution (Python):
from math import pi

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

print(len)

Solution (Python):
import math

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

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

Solution (Python):

import math

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

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

Solution (Python):

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

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

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

Solution (Python):

import math

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

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

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

print(2 * np.pi * R)

Solution (Python):
import numpy as np

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

Solution (Python):
import math

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

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

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

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

Solution (Python):
X = input()
pi = 6.28318530717958623200/2

Y = 2 * float(X) * pi
print(Y)

Solution (Python):
import math

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

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

print(2*3.14*a)

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

print(2 * pi * R)

Solution (Python):
import numpy as np

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

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

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

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

Solution (Python):
import math

r = int(input())
s = 2.0 * r * math.pi

print(s)

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

main()

Solution (Python):
import math

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


def read_ints():
    return list(map(int, input().strip().split(' ')))


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


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

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):
ennshuuritsu = 3.1415
nyuuryoku = int(input())

print(nyuuryoku*2*ennshuuritsu)

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

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

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

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

print(2 * r * math.pi)

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

if __name__=="__main__":
    main()

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

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

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

Solution (Python):
import math

R = int(input())


print(2*math.pi*R)

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

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

pi = 3.14159265359 

s = 2 * pi * R

print(s)

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

import math

circle = 2 * R * math.pi

print(circle)

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

Solution (Python):


import sys
readline = sys.stdin.readline
read = sys.stdin.read
 
 
r = int(input())

print(r*2*3.14159265358979)

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

print(2*R*3.14159265)

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

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

print(R*2*3.141592)

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

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

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

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

print(2*R*3.1415)

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

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

Solution (Python):
import math

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

print(2*R*pi)

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

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

Solution (Python):
import sys
import math

str = input()
cp = float(str) * 2 * math.pi
print(cp)

Solution (Python):
import numpy as np

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

Solution (Python):
import math

r =int(input())

print(2*math.pi * r)

Solution (Python):
import numpy as np

r=int(input())

print(2*r*np.pi)

Solution (Python):
from collections import defaultdict, deque
import sys
import heapq
import bisect
import itertools
import queue
import copy
import time
import math
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7

def inp(): return int(sys.stdin.readline())

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

def inpl_str(): return list(sys.stdin.readline().split())

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

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

Solution (Python):





import sys,os
from io import BytesIO, IOBase
import collections,itertools,bisect,heapq,math,string


BUFSIZE = 8192

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

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

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())
ensyuu = R * 2 *3.14
print(ensyuu)

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

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

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

Solution (Python):
import math

r = input()
p = int(r)
pi_ = round(math.pi,4)
print(2*p*pi_)

Solution (Python):
import math

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

print(z)

Solution (Python):
import math

R = int(input())

print(2*R*math.pi)

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

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):
R = int(input())
pi = float('3.141592')
print(R * 2 * pi)

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

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

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

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

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

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

print(2*r*3.1415)

Solution (Python):
import math

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

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

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

l = 2 * R * 3.141592

print(l)

Solution (Python):
from sys import stdin
import math

r = int(stdin.readline().rstrip())
print(2 * r * math.pi)

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

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

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

c=2*R*3.14

print(c)

Solution (Python):
from math import pi

r = int(input())

print(2*r*pi)

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

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

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

print(2 * R * 3.14)

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

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

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

Solution (Python):


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

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

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

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

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

Solution (Python):
import math


r = int(input())

print(2 * r * math.pi)

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

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

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

Solution (Python):
import math

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

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

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

print(2 * r * np.pi)

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

Solution (Python):
import math

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

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

Solution (Python):
import math as ma

R = int(input())
syutyo = 2 * R * ma.pi 
print(syutyo)

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

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

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

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

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

radius = float(input())
print (2*pi*radius)

Solution (Python):
from math import pi

radius = float(input())
print (2*pi*radius)

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

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

Solution (Python):
import math

a = int(input())

print(a * 2 * math.pi)

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

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

Solution (Python):
from math import pi

R = int(input())

print(2*pi*R)

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

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):
def main():
    from builtins import int, map, list, print
    import sys, math
    sys.setrecursionlimit(10 ** 6)

    input = sys.stdin.readline
    input_list = (lambda: input().rstrip().split())
    input_number = (lambda: int(input()))
    input_number_list = (lambda: list(map(int, input_list())))

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


if __name__ == '__main__':
    main()

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

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

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

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

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

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

Enshu = 2 * 3.1415 * R
print(Enshu)

Solution (Python):


a = int(input())





print(2*3.1415926535*a)

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

Solution (Python):
from collections import deque
import math; floor,ceil = math.floor,math.ceil
import sys; input = lambda: sys.stdin.readline().rstrip()
aint = lambda: int(input()); ints = lambda: list(map(int, input().split()))
Yes = lambda boolean: print('Yes') if boolean else print('No')
YES = lambda boolean: print('YES') if boolean else print('NO')
is_even = lambda x: True if x%2==0 else False

def main():
  r = aint()
  print(2*3.1416*r)

if __name__ == '__main__':
  main()

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

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

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

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

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

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

Solution (Python):
import math
from sys import *
inp=stdin.readline

zip=zip 
def linp(x):
    return list(map(int,x.split()))
def minp(x):
    return map(int,x.split())

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

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

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

print(2*math.pi*r)

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

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

Solution (Python):

import math
import sys


def main():
    R = int(input())
    print(2 * math.pi * R)
    sys.stderr.write("debug")


if __name__ == "__main__":
    main()

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

r=3.14*2*R
print(r)

Solution (Python):
import math

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

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

Solution (Python):

import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from decimal import *
from collections import deque
from math import gcd
sys.setrecursionlimit(10**7)
MOD = 10**9+7
INF = float('inf') 
def lcm(a,b):return (a*b) // gcd(a,b) 
def iin(): return int(sys.stdin.readline()) 
def ifn(): return float(sys.stdin.readline()) 
def isn(): return sys.stdin.readline().split() 
def imn(): return map(int, sys.stdin.readline().split()) 
def imnn(): return map(lambda x:int(x)-1, sys.stdin.readline().split()) 
def fmn(): return map(float, sys.stdin.readline().split()) 
def iln(): return list(map(int, sys.stdin.readline().split())) 
def iln_s(): return sorted(iln()) 
def iln_r(): return sorted(iln(), reverse=True) 
def fln(): return list(map(float, sys.stdin.readline().split())) 
def join(l, s=''): return s.join(l) 
def perm(l, n): return itertools.permutations(l, n) 
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) 
def comb(l, n): return itertools.combinations(l, n) 
def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 
def m_add(a,b): return (a+b) % MOD
def lprint(l): print(*l, sep='\n')

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

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

r = int(input())

import math

print(2*math.pi*r)

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

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

Solution (Python):
def circum(radius):
  return 2*22*radius/7

r = int(input())
print(circum(r))

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

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

Solution (Python):
import math

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

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

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

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

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

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

print(pi * R * 2)

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

main()

Solution (Python):
from sys import stdin

n = int(stdin.readline().rstrip())

print(n*2.0*3.14159265)

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

Solution (Python):
import sys
from collections import deque
import math

input = sys.stdin.readline


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


if __name__ == '__main__':
    answer = solve()
    print(answer)

Solution (Python):
import math

if __name__ == "__main__":
    R=input()
    print(2*float(R)*math.pi)

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

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

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

Solution (Python):

import sys
import math
import numpy as np

a = int(input())
p = np.pi

print(2*a*p)

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

Solution (Python):
import math
def main():

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

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

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

Solution (Python):


R = int(input())
"""
1 
"1" 
"""


L = 2*R*3.141592



print(L)

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

print(round(2*r*math.pi,6))

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

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

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

print(2*PI*R)

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

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

Solution (Python):
import math

r = int(input())

print("%f"%(2*r*math.pi))

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

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

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

Solution (Python):

import math
 
inp = float(input())
 
print(inp*2*math.pi)

Solution (Python):

import math

inp = float(input())

print(inp*2*math.pi)

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

import math

print(2*R*math.pi)

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

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

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

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

Solution (Python):
from math import pi
R = input()
print("{0:.2f}".format(pi*float(R)*2))

Solution (Python):
import math
a=int(input())
def s(a):
    return math.pi*2*a

print(s(a))

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

Solution (Python):
import math

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

circle_pond = diameter * pi

print(circle_pond)

Solution (Python):


DATA = """
1
""".split("\n")

def get_debug_line():
	for i in DATA:
		yield i

if 1:
	get_line = input
else:
	get_line = get_debug_line().__next__
	get_line()

R = int(get_line().strip())
print (2 * R * 3.1415926535)

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

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

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

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

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

Solution (Python):
import math

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

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

print(R*3.14*2)

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

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

print(R*2*3.14)

Solution (Python):
import math

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

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

Solution (Python):
x=int(input())
a=float(x)
print(round(2*x*3.14159,2))