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

N = int(input())

a  =N *2 *math.pi

print(a)

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

Solution (Python):
import math

n=int(input())
p=math.pi
p=round(p, 3)

e=2*n*p

print(2*n*p)

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

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

def resolve():
    R = int(input())

    print(2*math.pi*R)

if __name__ == '__main__':
    resolve()

Solution (Python):
rad = float(input())
a= 3.141592653
print(2 * rad * a)

Solution (Python):

import math

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

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

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

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

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

Solution (Python):
import math

a = int(input())

print(2*a*math.pi)

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

ans = math.pi*n*2

print(ans)

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

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

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

Pi = math.pi

print(2*Pi*R)

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

print(str(2*r*3.14159265))

Solution (Python):

import math


def main():

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

    
    
    

    
    

    R = first_input[0]

    print(R*2*math.pi)

if __name__ == '__main__':
    main()

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

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

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

print(2 * R * math.pi)

Solution (Python):
import sys


from math import pi

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

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

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

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

print(2 * n * math.pi)

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

Solution (Python):
r=int(input())
ans=2*r*355/113
print("{:0.10f}".format(ans))

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

Solution (Python):
import math

R = int(input())

p = math.pi

print(2*R*p)

Solution (Python):
R = input()
pi = 6.28318530717958623200 / 2
a = float(2)*pi*float(R)
print(a)

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 sys

IS = lambda: sys.stdin.readline().rstrip()
II = lambda: int(IS())
MII = lambda: list(map(int, IS().split()))
MIIZ = lambda: list(map(lambda x: x-1, MII()))

INIT_VAL = 0
DP2 = lambda d1, d2: [[INIT_VAL]*d2 for _ in range(d1)]
DP3 = lambda d1, d2, d3: [[[INIT_VAL]*d3 for _ in range(d2)] for _ in range(d1)]
import math

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

if __name__ == '__main__':
    main()

Solution (Python):
if __name__ == '__main__':
    a = int(input())
 
    print(2*a*3.141592)

Solution (Python):
import math

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

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

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

Solution (Python):
import numpy as np

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

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

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

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

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

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

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

def main():
    import math
    R = int(read())
    print(math.pi * (R * 2))
    return

if __name__ == '__main__':
    main()

Solution (Python):
import copy
import math
a = int(input())
print(a*2*3.1415926)

Solution (Python):
from collections import Counter
import sys

sys.setrecursionlimit(10 ** 6)

mod = 1000000007
inf = int(1e18)

dx = [0, 1, 0, -1]
dy = [1, 0, -1, 0]


def inverse(a):
    return pow(a, mod - 2, mod)


def usearch(x, a):
    lft = 0
    rgt = len(a) + 1
    while rgt - lft > 1:
        mid = (rgt + lft) // 2
        if a[mid] <= x:
            lft = mid
        else:
            rgt = mid
    return lft

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

main()

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

print(2 * R * 3.14)

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

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

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

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

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

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

pi = 3.1415926535

print(2*r*pi)

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

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

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

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

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

Solution (Python):
P = 3.14

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

Solution (Python):
import math

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

print(res)

Solution (Python):
import sys
import math

X = int(sys.stdin.readline().rstrip())

print(2 * X * math.pi)

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):
print(3.141592 * 2 * float(input()))

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

Solution (Python):
import math
r = float(input())
print("{:.25}".format(2.0 * math.pi * r))

Solution (Python):
import math

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

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

print(2*3.141592*R)

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

print(R * 2 * 3.1415926535)

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

Solution (Python):
from sys import stdin
import math

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

Solution (Python):




import sys
from io import StringIO
import unittest
import math

def yn(b):
    print("Yes" if b==1 else "No")
    return

def resolve():
    readline=sys.stdin.readline

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

    return

if 'doTest' not in globals():
    resolve()
    sys.exit()

Solution (Python):
import math

r = int(input())

ans = 2 * math.pi * r

print(ans)

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

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

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

print(2 * x * math.pi)

Solution (Python):
from sys import stdin

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

pi = 3.141592

print(pi*R*2)

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

print(np.pi * 2 * radius)

Solution (Python):
import numpy as np

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

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

Solution (Python):


import math

R=int(input()) 
L=2.0*math.pi*R 

print(L)

Solution (Python):
import math

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

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

Solution (Python):
import math

r = int(input())

print(math.pi * 2 * r)

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

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

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

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

Solution (Python):
import math as mt

radius = int(input())
print (2 * radius * mt.pi)

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

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

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

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

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

Solution (Python):
import math


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


if __name__ == '__main__':
    main()

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

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

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

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

import math


def solve(*args: str) -> str:
    r = int(args[0])

    return str(2*math.pi*r)


if __name__ == "__main__":
    print(solve(*(open(0).read().splitlines())))

Solution (Python):



import sys

import math

sys.setrecursionlimit(10 ** 6)


r = int(input())

print(2 * math.pi * r)

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

Solution (Python):

N = int(input())

ans = N*2*3.1415926535


print(ans)

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

Solution (Python):
import math

r = int(input())

print(2 * r * math.pi)

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

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

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

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

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

print(2*r*3.14)

Solution (Python):
import math

N = int(input())

print(N*math.pi*2)

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

ans = math.pi * R * 2

print(ans)

Solution (Python):
import math

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

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

Solution (Python):
from sys import stdin


def main():

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

    print(2*R*3.14)


if __name__ == "__main__":
    main()

Solution (Python):
n=int(input()) 
ans=n*6.28
print(ans)

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

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

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

R = input_one_number()

print(R*2*3.1415926535897932384626433)

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


print(r* 6.28318530717958623200)

Solution (Python):


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

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

b = (a * float(2.0)) * float(3.1415)

print(b)

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

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

Solution (Python):
import math

if __name__ == '__main__':
    r = int(input())

    c = 2 * (math.pi * r)
    print(round(c, 2))

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

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

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

    print(2 * 3.141592 * R)


if __name__ == '__main__':
    main()

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

Npi = N*3.14*2

print(Npi)

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

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

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

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

Solution (Python):
import math

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

print(en)

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

Solution (Python):
import math

n = int(input())
p = math.pi
ans = int(2 * p * n * 10000) / 10000
print(ans)

Solution (Python):
import math

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

    print(2*r*math.pi)

if __name__ == '__main__':
    main()

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

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

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

Solution (Python):



import math

R = int(input())

print(R * 2 * math.pi)

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

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

print(2*R*3.14159265358979323)

Solution (Python):
import math
r = int(input())
print(math.acos(-1)*r*2)

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

Solution (Python):
import numpy

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

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

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

print(2 * R * math.pi)

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

Solution (Python):

import math

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

if __name__ == "__main__":
    solve()

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

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

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

Solution (Python):
"""
// Author : snape_here - Susanta Mukherjee
     
 """
 
from __future__ import division, print_function
 
import os,sys
from io import BytesIO, IOBase
 
if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
 
 
def ii(): return int(input())
def si(): return input()
def mi(): return map(int,input().split())
def li(): return list(mi())
 
 
def read():
    sys.stdin = open('input.txt', 'r')  
    sys.stdout = open('output.txt', 'w') 
 
def gcd(x, y):
    while y:
        x, y = y, x % y
    return x

mod=1000000007

import math

import bisect

abc="abcdefghijklmnopqrstuvwxyz"

def main():

    r=ii()
    ans=3.141592653589793238*r*2 
    print(ans)

        


 
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")
 
 
def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()
 
 
if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
 
input = lambda: sys.stdin.readline().rstrip("\r\n")
 

 
 
if __name__ == "__main__":
    
    main()

Solution (Python):
import math

r = int(input())

length = 2*r*math.pi

print(length)

Solution (Python):

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

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

print(2*R*3.14)

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

Solution (Python):
import sys
from operator import itemgetter
import collections
import math

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

def main():
    input = sys.stdin.readline
    n = int(input())
    print(r(n))

    
if __name__ == '__main__':
    main()

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

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

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

Solution (Python):

R = int(input())


print(2*R*3.14159265)

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

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

Solution (Python):
from sys import stdin

def main():

    input = stdin.readline

    r = int(input())

    ans = r * 6.28

    print(ans)
    
if __name__ == "__main__":
    main()

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

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

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

print (2.0*R*np.pi)

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

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

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

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

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

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

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

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

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

print(r * 2 * 3.141592653589793238462643383279)

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

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

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

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

print(2*r*3.1415926535897932384626)

Solution (Python):
pi = 3.141592

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

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

print(r * 6.283)

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

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


import math

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

Solution (Python):


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

Solution (Python):
import math
math.pi

r=float(input())

R=2*r*math.pi

print(R)

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

Solution (Python):


import math


R = int(input())

print(R * 2 * math.pi)

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

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

print(2*r*math.pi)

Solution (Python):
PI = 3.141592

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

Solution (Python):
def main():
    import sys
    import math
    pi = 3.141592653589793
    sys.setrecursionlimit(10 ** 6)
    input = sys.stdin.readline
    r = int(input())
    print(2*r*pi)

if __name__ == '__main__':
    main()

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

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

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

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

if __name__ == "__main__":
    main()

Solution (Python):

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

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

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

Solution (Python):
import math

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

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

Solution (Python):
import math

n = int(input())

print(2*n*math.pi)

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

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

Solution (Python):
mod = 1000000007
eps = 10**-9


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

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


if __name__ == '__main__':
    main()

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

Solution (Python):
import math


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


if __name__ == '__main__':
    main()

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

Solution (Python):

import math


def main():

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

    
    
    

    
    

    R = first_input[0]

    print(R*2*math.pi)

if __name__ == '__main__':
    main()

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

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

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

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

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

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

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

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

print(r*2*3.14)

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

Solution (Python):
if __name__ == '__main__':
    N = int(input())
    import math
    print(2*N*(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):
import math

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

print(ans)

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

ans = 3.14*(r*2)
print(ans)

Solution (Python):
import math


R = int(input())


print(math.pi * R * 2.0)

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

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

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

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

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

print(2*n*math.pi)

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

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

print(2 * R * math.pi)

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

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

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

Solution (Python):
import sys, math
 
r = int(sys.stdin.readline().strip())
print( r * math.pi * 2)

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

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

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

Solution (Python):
r = int(input())
print('{:.3f}'.format(2*3.141*r))

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

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

Solution (Python):

import numpy as np
r = float(input())

print(2*r*3.14159265)

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

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

Solution (Python):
from math import pi

R = int(input())

print(2 * R * 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
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

r = int(input())

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

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

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

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

Solution (Python):

r = int(input())

print(2*r*3.14)

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

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

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

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

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

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

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

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

Solution (Python):
import math

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

Solution (Python):
import math

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

print(ans)

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

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

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

Solution (Python):
import sys
from math import factorial
from collections import Counter
from fractions import Fraction
import heapq, bisect, fractions
import math
import itertools
sys.setrecursionlimit(10 ** 5 + 10)
INF = 10**15 +5
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
MOD = 10**9 + 7

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

Solution (Python):
import math

R = int(input())

print(2*R*math.pi)

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

import math

print(2 * math.pi * R)

Solution (Python):
import math

N = int(input())
circle = 2*N*math.pi
print(circle)

Solution (Python):



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

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

Solution (Python):
import math

I = int(input())






a = 0
a = 2*I*3.14
print(a)

Solution (Python):
import numpy as np

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

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

print(2*a*r)

Solution (Python):
import math


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

Solution (Python):
from math import *
test = 1

for __ in range(test):
	r = int(input())
	print(3.1415926*2*r)

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

ans=3.14*(2*R)

print(ans)

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

Solution (Python):

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

Solution (Python):


a = int(input())

print(a*2*3.14)

Solution (Python):
import math
r = input()
R = int(r)
if 1 <= R and R <= 100:
  print(2*math.pi*R)

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

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

Solution (Python):
import math

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

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

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

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


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


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


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


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


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


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


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

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



print(R * 2 * 3.14)

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

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

Solution (Python):
from heapq import heappush, heappop
from itertools import permutations, accumulate, combinations
import math
import bisect
import numpy as np
from collections import defaultdict, deque
from operator import itemgetter
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 6)




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


if __name__ == '__main__':
    main()

Solution (Python):
import math 

R = float(input())

print(R *  2 * math.pi)

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

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

Solution (Python):



 
import sys
import math



 

fileoperation=0
if(fileoperation):
    orig_stdout = sys.stdout
    orig_stdin = sys.stdin
    inputfile = open('W:/Competitive Programming/input.txt', 'r')
    outputfile = open('W:/Competitive Programming/output.txt', 'w')
    sys.stdin = inputfile
    sys.stdout = outputfile


mod=1000000007
 

def nospace(l):
    ans=''.join(str(i) for i in l)
    return ans
 
 
 

t=1
for tt in range(t):
    n=int(input())
    print(2*math.pi * n)
    
    
    
    

if(fileoperation):
    sys.stdout = orig_stdout
    sys.stdin = orig_stdin
    inputfile.close()
    outputfile.close()

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

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

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

Solution (Python):
import numpy

r = int(input())

print(r*2*numpy.pi)

Solution (Python):
import math

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

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

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

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
N=float(input())


print(2.*N*math.pi)

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

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

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


if __name__ == "__main__":
    main()

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