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

def main():
    for _ in inputt(1):
        n, = inputi()
        print(pi * n * 2)








from math import *
from heapq import *
from itertools import *
from functools import reduce, lru_cache, partial
from collections import Counter, defaultdict
import re, copy, operator, cmath
import sys, io, os, builtins
sys.setrecursionlimit(1000)






BUFSIZE = 8192
class FastIO(io.IOBase):
    newlines = 0
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = io.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(io.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):
    sys.stdout.write(kwargs.pop("split", " ").join(map(str, args)))
    sys.stdout.write(kwargs.pop("end", "\n"))
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip()
inputt = lambda t = 0: range(t) if t else range(int(input()))
inputs = lambda: input().split()
inputi = lambda: map(int, inputs())
inputl = lambda t = 0, k = inputi: map(list, (k() for _ in range(t))) if t else list(k())






def len(a):
    if isinstance(a, range):
        return -((a.start - a.stop) // a.step)
    return builtins.len(a)
def bisect_left(a, x, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    if key == None: key = do_nothing
    while lo < hi:
        mid = (lo + hi) // 2
        if key(a[mid]) < x: lo = mid + 1
        else: hi = mid
    return lo
def bisect_right(a, x, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    if key == None: key = do_nothing
    while lo < hi:
        mid = (lo + hi) // 2
        if x < key(a[mid]): hi = mid
        else: lo = mid + 1
    return lo
def insort_left(a, x, key = None, lo = 0, hi = None):
    lo = bisect_left(a, x, key, lo, hi)
    a.insert(lo, x)
def insort_right(a, x, key = None, lo = 0, hi = None):
    lo = bisect_right(a, x, key, lo, hi)
    a.insert(lo, x)
do_nothing = lambda x: x
bisect = bisect_right
insort = insort_right
def index(a, x, default = None, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    if key == None: key = do_nothing
    i = bisect_left(a, x, key, lo, hi)
    if lo <= i < hi and key(a[i]) == x: return a[i]
    if default != None: return default
    raise ValueError
def find_lt(a, x, default = None, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    i = bisect_left(a, x, key, lo, hi)
    if lo < i <= hi: return a[i - 1]
    if default != None: return default
    raise ValueError
def find_le(a, x, default = None, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    i = bisect_right(a, x, key, lo, hi)
    if lo < i <= hi: return a[i - 1]
    if default != None: return default
    raise ValueError
def find_gt(a, x, default = None, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    i = bisect_right(a, x, key, lo, hi)
    if lo <= i < hi: return a[i]
    if default != None: return default
    raise ValueError
def find_ge(a, x, default = None, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    i = bisect_left(a, x, key, lo, hi)
    if lo <= i < hi: return a[i]
    if default != None: return default
    raise ValueError





class Tree:
    def __init__(n):
        self._n = n
        self._conn = [[] for _ in range(n)]
        self._list = [0] * n
    def connect(a, b):
        pass





class Sieve:
    def __init__(self):
        self._n = 6
        self._list = [2, 3, 5, 7, 11, 13]
    def extend(self, n):
        pass


sieve = Sieve()
def isprime(n):
    pass
def prime(n):
    pass
def factorint(n):
    factordict = defaultdict(int)
    for i in sieve:
        if n <= i * i:
            break
        while not n % i:
            factordict[i] += 1
            n //= i
    if n != 1:
        factordict[n] += 1
    return factordict





if __name__ == "__main__":
    main()

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

Solution (Python):
import math

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

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

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

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

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

R *= 2
R *= 3.14

print(R)

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

print(2*r*math.pi)

Solution (Python):


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

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

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


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


if __name__ == '__main__':
    solve()

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

Solution (Python):
import math

r = int(input())

length = 2*r*math.pi

print(length)

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

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

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

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

Solution (Python):
import math


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

    print(R * 2 * math.pi)


resolve()

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

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

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

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

R = INT()
print(2*3.1415926535*R)

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

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

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

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

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

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


if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):
from math import pi

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

  print(2*R*pi)

if __name__ == "__main__":
  main()

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

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

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

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

Solution (Python):
import sys
import socket


hostname = socket.gethostname()

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


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


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


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


def read_str():
    return input()


def main():
    R = read_int()
    res = 2 * 3.1415926 * R
    print(res)


main()

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

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

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

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

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

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

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

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

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


print(ans)

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

resolve()

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

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

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

Solution (Python):
import math

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

Solution (Python):
import math
a = int(input())
temp = 3.14
val = float(2*temp*a)
print(val)

Solution (Python):
import math

r = int(input())

print(math.pi*2*r)

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

Solution (Python):
R = input()
R = int(R)
R = R * 2 * 3.141592653589793238

print(R)

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

print(2*r*3.1415)

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

print(R*2*math.pi)

Solution (Python):
import sys


from math import pi

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

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

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

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

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

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

p = 3.141592653589

print(2*R*p)

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

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

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

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

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

Solution (Python):
import math

radius = int(input())

print(2*radius*math.pi)

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

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

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

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

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

print(2*r*3.14159)

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

print(2*a*r)

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

Solution (Python):
import math

r = int(input())

print(2*r*math.pi)

Solution (Python):
import math

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

Solution (Python):






"""Module docstring
"""

import math
import sys


def solve(values, nb, max_jump_size):
    max_jump_size = min(nb, max_jump_size)
    cost_to = [0]
    for i in range(1, nb):
        j = max(0, i - max_jump_size)
        value_i = values[i]
        new_cost = min(
            prev_cost + abs(value_i - prev_value)
            for prev_cost, prev_value in zip(cost_to[j:i], values[j:i])
        )
        cost_to.append(new_cost)
    return new_cost


def do_job():
    "Do the work"
    
    R = int(input().strip())
    result = 2 * math.pi * R
    print(result)


def print_output(testcase, result) -> None:
    "Formats and print result"
    if result is None:
        result = "IMPOSSIBLE"
    print("Case 


def main(argv=None):
    "Program wrapper."
    if argv is None:
        argv = sys.argv[1:]
    do_job()
    return 0


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    sys.exit(main())

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,operator,string
def I(): return int(input())
def S(): return input()
def LI(): return list(map(int,input().split()))
def LS(): return list(input().split())

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

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

Solution (Python):
import math

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

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

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

Solution (Python):



r = int(input())

print(2 * (3.14) * r)

Solution (Python):
import sys
from io import StringIO
import unittest
import math

def resolve():
    r = int(input())
    ans = math.pi * r * 2
    print('{:.20f}'.format(ans))

class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)
    def test_入力例_1(self):
        input = """1"""
        output = """6.28318530717958623200"""
        self.assertIO(input, output)
    def test_入力例_2(self):
        input = """73"""
        output = """458.67252742410977361942"""
        self.assertIO(input, output)

if __name__ == "__main__":
    
    resolve()

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

Solution (Python):
import math

R = int(input().split()[0])
ans = (R * 2) * math.pi

print(ans)

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

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

Solution (Python):
from math import pi
x=int(input())
p=1
print(2*pi*x)

Solution (Python):
x = float(input())
print(x * 3.1415 * 2.0)

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

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

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

print(2*R*3.14)

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

Solution (Python):
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate


def read_ints():
    return list(map(int, read().split()))


def read_a_int():
    return int(read())


def read_tuple(H):
    '''
    H is number of rows
    '''
    ret = []
    for _ in range(H):
        ret.append(tuple(map(int, read().split())))
    return ret


def read_col(H):
    '''
    H is number of rows
    A列、B列が与えられるようなとき
    ex1)A,B=read_col(H)    ex2) A,=read_col(H) 
    '''
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return tuple(map(list, zip(*ret)))


def read_matrix(H):
    '''
    H is number of rows
    '''
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return ret
    


MOD = 10**9 + 7
INF = 2**31  

from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right  

R = read_a_int()
print(R * 2 * 3.14159265359)

Solution (Python):
import math

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

Solution (Python):
import math

r = int(input())

e = 2 * r * math.pi

print(e)

Solution (Python):
import math

b=int(input())

print(math.pi*b*2)

Solution (Python):
if __name__ == '__main__':
    a = int(input())

    print(2 * a * 3.1415)

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

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

Solution (Python):
import math

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

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

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

print(round(math.pi * 2.0 * float(r),4))

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

print(2*r*math.pi)

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

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

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

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

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

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

print(2*R*math.pi)

Solution (Python):
import math

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

Solution (Python):
import math
import sys
readline = sys.stdin.buffer.readline
s =int(readline().rstrip().decode())
print(s *2 * math.pi)

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

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

if __name__ == '__main__':
    main()

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

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

print((a*2) * 3.1415926)

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

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

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

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

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

print (2*R*pi)

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

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

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

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

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

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

Solution (Python):
import math

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

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

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

Solution (Python):
from math import pi

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

Solution (Python):
import math

r = int(input())

print(2*r*math.pi)

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

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

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

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

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

Solution (Python):
import math

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

Solution (Python):
import math

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

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

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

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

ans = 2*r*3.14159265

print(ans)

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

Solution (Python):
import math

r = int(input())

print(r*2*math.pi)

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

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

if 1 <= r and r <= 100:
  c = (2*r)*math.pi
  print(c)

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

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

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

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

Solution (Python):
pi = 3.14159

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

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

Solution (Python):
import numpy as np
a,=map(int,input().split())
print(2*np.pi*a)

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

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

import math

print(2.0*math.pi*r)

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

print( 2 * r * math.pi)

Solution (Python):


import math








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

    print(2 * math.pi * R)

if __name__ == "__main__":
    main()

Solution (Python):
from math import pi

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

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

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


print(r*2*math.pi)

Solution (Python):
import math

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

Solution (Python):
import math

n=float(input())


print(n*2*math.pi)

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

Solution (Python):
import math

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

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

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

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

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

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

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

Solution (Python):
import math
n = int(input())
print("{0:.20f}".format(2*n*math.pi))

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

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

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

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

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

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

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

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

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

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

import math
PI = math.pi

print(2 * PI * R)

Solution (Python):
import math


R=int(input())

N=2*math.pi*R

print(float(N))

Solution (Python):
import math

r = int(input())

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

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

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

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

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

print(n*3.14159265358979*2)

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

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

print(2*N*pi)

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

Solution (Python):
import math

r = int(input())

print(math.pi * r * 2)

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

Solution (Python):
import math
if __name__ == "__main__":
  r = int(input())
  pi = math.pi

  print(2*pi*r)

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

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

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

print(2*A*N)

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

Solution (Python):
from math import pi

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

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

Solution (Python):
import math

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

Solution (Python):
import math

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

    print(2*r*math.pi)

if __name__ == '__main__':
    main()

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

Solution (Python):
import math

r=input()
r=int(r)

ans=2*r*math.pi

print(ans)

Solution (Python):
if __name__ == "__main__":
    r = float(input())
    pi = 3.14159
    print((r*pi*2.0))

Solution (Python):
PI = 3.14
R =int(input())
diameter = 2 * R
circumference = 2 * PI * R
print(float( PI * 2 * R))

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

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

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

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

Solution (Python):

R = int(input())
print(R*6.283185307179)

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

import math

print(math.pi * 2 * r)

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

Solution (Python):
user = int(input(""))
print(user * 6.28)

Solution (Python):
import math

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

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

Solution (Python):

N = int(input())

print(2 *3.141592*N)

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):
import math

R = int(input())

print(R * 2 * math.pi)

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

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

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

def r(n):
    return n * 2 * 3.141952

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

    
if __name__ == '__main__':
    main()

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

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

Solution (Python):

r = float(input())

print(r*6.28318530717958623200)

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
import math

n = int(input())

print(2*n*math.pi)

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

Solution (Python):

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

print(2*r*3.14159265)

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

Solution (Python):
import math

r = int(input())
x = math.pi

print(2*r*x)

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

Solution (Python):
import numpy as np


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



r = int(input())
print(solve())

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

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

ans=3.14*(2*R)

print(ans)

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

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

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

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

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

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

Solution (Python):
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
def resolve():
    R = ir()
    print(2*R*3.1415926535897)
resolve()

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

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

Solution (Python):
import math

R = int(input())

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

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

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

Solution (Python):
import math

r = int(input())

print(2*r*math.pi)

Solution (Python):

import math
def main():
    R = int(input())
    print(R*2*math.pi)
if __name__ == '__main__':
    main()

Solution (Python):
import math

r=int(input())

print(math.pi*2*r)

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

Solution (Python):
import math
m = float(input())

R = float(m * math.pi * 2.0)

print(R)

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

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

Solution (Python):
import math

x = int(input())

print(x * 2 * math.pi)

Solution (Python):













R = int(input())

ans = 2*R*3.14159265359

print(ans)

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

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

Solution (Python):
diameter = input()
print(float(diameter)*2*3.14159265)

Solution (Python):
import math

n = int(input())

print(2*n*math.pi)

Solution (Python):
import math

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

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

Solution (Python):
import numpy as np

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

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

import math

print(2.0*math.pi*r)

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

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

ans = 2*R*3.1415926535

print(ans)

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