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 sys 
import math
try:
	sys.stdin = open('input.txt', 'r') 
	sys.stdout = open('output.txt', 'w')
except:
	pass
input = sys.stdin.readline
for tt in range(1):
	r = int(input())
	
	
	print(2*math.pi*r)

Solution (Python):
import math

R = int(input())

print(2*R*math.pi)

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

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

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

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

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

Solution (Python):
import math

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

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

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

print(2 * R * math.pi)

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

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 sys
stdin = sys.stdin
sys.setrecursionlimit(10**6)
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

n = ni()

import math

print(2*n*math.pi)

Solution (Python):


import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

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

Solution (Python):
import math

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

if __name__ == '__main__':
    main()

Solution (Python):











import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,sqrt,factorial,hypot,log,pi 
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from fractions import gcd
from random import randint
def ceil(a,b): return (a+b-1)//b
inf=float('inf')
mod = 10**9+7
def pprint(*A): 
    for a in A:     print(*a,sep='\n')
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    R=I()
    print(pi*R*2)
if __name__ == '__main__':
    main()

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

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

    R = int(input())

    print(2 * pi * R)


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):


r = int(input())
pai = 3.14159265359
rounds = 2*r*pai
print(rounds)

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

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

import numpy as np

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

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




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

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

Solution (Python):

pi = 3.1415926235897932384626
n = int(input())
n*=2
print(n*pi)

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

Solution (Python):



debug=1
def pront(*n):
    if debug==1:
        print(n)
        


base=10**9+7

def add(a,b):
    return (a+b)%base

def sub(a,b):
    return (a-b)%base

def multi(a,b):
    return (a*b)%base

def exp(a,b):
    x=1
    c=a
    d=b
    while d!=0:
        if d%2==1:
            x=multi(x,c)
        c=(c**2)%base
        d=d//2
    return x

def div(a,b):
    return(multi(a,exp(b,base-2)))



R=int(input())



import math as m

print(m.pi*R*2)

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

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

print(2*r*3.1415926535897932384626)

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

Solution (Python):
import math

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

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

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

Solution (Python):
import math  
import bisect  
import queue  


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

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

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

if __name__ == '__main__':
    resolve()

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

Solution (Python):
import numpy as np

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

Solution (Python):
from collections import deque, Counter, defaultdict
from itertools import chain, combinations
import json

import bisect
import sys
import math
import bisect
from functools import lru_cache

sys.setrecursionlimit(10 ** 8)

M = 10 ** 9 + 7
INF = 10 ** 17


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

    
    
    
    
    
    
    
    
    
    
    
    
    
    
    


if __name__ == "__main__":
    main()

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

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

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

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

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from math import pi

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

Solution (Python):

import math

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

Solution (Python):

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

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

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

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

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

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

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

Solution (Python):
import math

r = input()

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

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

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

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*pi*R)

Solution (Python):
from math import pi


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


if __name__ == '__main__':
    main()

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

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

Solution (Python):
import math

r = int(input())

print(2 * math.pi * r)

Solution (Python):
import math


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

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

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

print(r * 6.28318530717958623200)

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

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

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

print(2*n*math.pi)

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

Solution (Python):
import math

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

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

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

Solution (Python):
import math


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


if __name__ == "__main__":
    solve()

Solution (Python):
import math

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

if __name__ == '__main__':
    R = int(input())
    print(main(R))

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

print(math.pi * 2.0 * float(r))

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

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

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

print(2*n*math.pi)

Solution (Python):

import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1

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

Solution (Python):
import numpy as np

def resolve():
    r = int(input())
    print('{:.10f}'.format(np.pi * 2 * r))

if __name__ == '__main__':
    resolve()

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

Solution (Python):
import math

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

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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]

def main():
    r=II()
    print(3.141592653589793*2*r)
main()

Solution (Python):
import math

R = int(input())

print(R * 2 * math.pi)

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

R = int(input())

print(2*math.pi*R)

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

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

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

print(r*2*3.14159)

Solution (Python):
LI = lambda: list(map(int,input().split()))
MI = lambda: map(int,input().split())
yes = lambda: print("YES")
no = lambda: print("NO")
I = lambda: list(input())
J = lambda x: "".join(x)
II = lambda: int(input())
SI = lambda: input()

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

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())
print(2*r*3.14)

Solution (Python):
import math

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

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

Solution (Python):
def resolve():
    '''
    code here
    '''
    import math
    r = int(input())
    print(2*r*math.pi)

if __name__ == "__main__":
    resolve()

Solution (Python):
import math
from sys import stdin


def get_result(data):
    N = int(data[0])
    return math.pi * 2 * N


if __name__ == '__main__':
    data = list(map(int, stdin.readline().rstrip().split(' ')))
    result = get_result(data)
    print(result)

Solution (Python):
import sys
import heapq
import re
from itertools import permutations
from bisect import bisect_left, bisect_right
from collections import Counter, deque
from math import factorial, sqrt, ceil, gcd
from functools import lru_cache, reduce
INF = 1 << 60
MOD = 1000000007
sys.setrecursionlimit(10 ** 7)


class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())


def dijkstra_heap(s, edge, n):
    
    d = [10**20] * n
    used = [True] * n 
    d[s] = 0
    used[s] = False
    edgelist = []
    for a,b in edge[s]:
        heapq.heappush(edgelist,a*(10**6)+b)
    while len(edgelist):
        minedge = heapq.heappop(edgelist)
        
        if not used[minedge%(10**6)]:
            continue
        v = minedge%(10**6)
        d[v] = minedge//(10**6)
        used[v] = False
        for e in edge[v]:
            if used[e[1]]:
                heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
    return d


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

    if temp!=1:
        arr.append([temp, 1])

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

    return arr


def lcm(x, y):
    return (x * y) // gcd(x, y)


def lcm_list(numbers):
    return reduce(lcm, numbers, 1)


def gcd_list(numbers):
    return reduce(gcd, numbers)


def is_prime(n):
    if n <= 1:
        return False
    p = 2
    while True:
        if p ** 2 > n:
            break
        if n % p == 0:
            return False
        p += 1
    return True



def eratosthenes(limit):
    A = [i for i in range(2, limit+1)]
    P = []

    while True:
        prime = min(A)
        
        if prime > sqrt(limit):
            break
            
        P.append(prime)
            
        i = 0
        while i < len(A):
            if A[i] % prime == 0:
                A.pop(i)
                continue
            i += 1
            
    for a in A:
        P.append(a)
            
    return P


def permutation_with_duplicates(L):

    if L == []:
        return [[]]

    else:
        ret = []

        
        S = sorted(set(L))

        for i in S:

            data = L[:]
            data.remove(i)

            for j in permutation_with_duplicates(data):
                ret.append([i] + j)

        return ret



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

Solution (Python):
t=1

for _ in range(t):
    n = int(input())
    print(2*3.1415926535897932*n)

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

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

print(2 * R * 3.141592653589)

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

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

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

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

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

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

Solution (Python):
import math

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

print(2*3.14*R)

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

import math

print(2*r*math.pi)

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

Solution (Python):
import math

r = int(input())

print(2*math.pi*r)

Solution (Python):
import  math

r=int(input())

print(2*r*math.pi)

Solution (Python):
import math

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

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

ans = math.pi * 2 * r

print(ans)

Solution (Python):
import math

N = int(input())

print(2*N*math.pi)

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

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

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

print(math.pi * 2 * r)

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

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

Solution (Python):
import math

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

Solution (Python):
from sys import stdin
from sys import setrecursionlimit
from collections import Counter, deque, defaultdict
from bisect import bisect_left
setrecursionlimit(1000000)

INF = int(1e10)
MOD = int(1e9 + 7)

def input():
    return stdin.readline()[:-1]


def main():
    from builtins import int, map
    from math import pi
    r = int(input())
    print("{:.10f}".format(2 * r * pi))
   
if __name__ == '__main__':
    main()

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

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

print(x*n*2)

Solution (Python):
import math

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

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

print(R*2.0*3.1415926535)

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

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

Solution (Python):
import math

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

Solution (Python):


P = int(input())

import math

print (P*2 * math.pi)

Solution (Python):
import math

r = int(input())

print(2 * r * math.pi)

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

p = np.pi

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

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

Solution (Python):
from sys import stdin
pi=3.14159265358979323846
r=list(map(float,(stdin.readline().strip().split())))[0]
print(2*pi*r)

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

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

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

Solution (Python):
INF = 10 ** 9
import sys
sys.setrecursionlimit(100000000)
dy = (-1,0,1,0)
dx = (0,1,0,-1)
from  collections import deque
import numpy as np
def main():
    r = int(input())
    print(2 * np.pi  *r)
if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
import sys, math
def input(): return sys.stdin.readline().strip()

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



if __name__ == "__main__":
    main()

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

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

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

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

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

















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

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

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

Solution (Python):
import sys
import math
input = sys.stdin.buffer.readline
def int_array():
	return list(map(int, input().strip().split()))
def str_array():
	return input().strip().split()
 


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

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

import math

p = math.pi

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

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

Solution (Python):
import math

r=int(input())

print(math.pi*2*r)

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

print(D)

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

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

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


print(2*pi*a)

Solution (Python):

import math

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

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

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

print(2 * 3.141592 * R)

Solution (Python):
import math

r=int(input())

print(math.pi*r*2)

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

def sRaw():
    return input().rstrip("\r")


def iRaw():
    return int(input())


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


def isRaw():
    return list(map(int, ssRaw()))

INF = 1 << 29

DIV = (10**9) + 7

def mod_inv_prime(a, mod=DIV):
    return pow(a, mod-2, mod)


def mod_inv(a, b):
    r = a
    w = b
    u = 1
    v = 0
    while w != 0:
        t = r//w
        r -= t*w
        r, w = w, r
        u -= t*v
        u, v = v, u
    return (u % b+b) % b


def CONV_TBL(max, mod=DIV):
    fac, finv, inv = [0]*max, [0]*max, [0]*max
    fac[0] = fac[1] = 1
    finv[0] = finv[1] = 1
    inv[1] = 1
    for i in range(2, max):
        fac[i] = fac[i-1]*i % mod
        inv[i] = mod - inv[mod % i] * (mod//i) % mod
        finv[i] = finv[i-1]*inv[i] % mod

    class CONV:
        def __init__(self):
            self.fac =fac
            self.finv = finv
            pass

        def ncr(self, n, k):
            if(n < k):
                return 0
            if(n < 0 or k < 0):
                return 0
            return fac[n]*(finv[k]*finv[n-k] % DIV) % DIV
        
    return CONV()



sys.setrecursionlimit(200005)


def main():
    R = iRaw()
    ans = R*2*math.pi         
    return ans

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

Solution (Python):
import math

r = int(input())

print(2*r*math.pi)

Solution (Python):
import sys
import os
import math
import string

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: x * y / math.gcd(x, y)

MOD = 10 ** 9 + 7


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

    N = ii()
    print(2*N*3.14159265)


if __name__ == '__main__':
    main()

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

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):
n = float(input())
print(2.0*n*3.1415926)

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

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

Solution (Python):
import math

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

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

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

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

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

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

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

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

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

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):
R=int(input())
print(R*6.28318530717958623200)

Solution (Python):
import math

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

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

Solution (Python):


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

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

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

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

Solution (Python):
import math

x = math.pi

r = int(input())

print(2*x*r)

Solution (Python):
import math

r = int(input())

print(2 * r * math.pi)

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

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

print(3.1415926535*2*n)

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

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

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

Solution (Python):
import numpy as np
import math
import itertools

N = int(input())


print(2*N*math.pi)

Solution (Python):
"""
import random
import functools
import copy
import bisect
import array
import re
import collections
import heapq
import fractions
import itertools
import string
import math
from operator import itemgetter as ig
from bisect import bisect_left, bisect_right, insort_left, insort_right
from itertools import permutations, combinations, product, accumulate, groupby
from heapq import heappush, heappop
from collections import deque, defaultdict, Counter
import sys
sys.setrecursionlimit(10 ** 7)


inf = 10 ** 20
INF = float("INF")
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = dd + [(-1, 1), (1, 1), (1, -1), (-1, -1)]
ddn9 = ddn + [(0, 0)]
'''for dx, dy in dd:
        nx = j + dx; ny = i + dy
            if 0 <= nx < w and 0 <= ny < h:'''
"""
from collections import Counter
import math
import sys
sys.setrecursionlimit(10 ** 7)


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



def wip(): return [int(x) - 1 for x in sys.stdin.readline().split()]


def ws(): return sys.stdin.readline().split()


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


def ss(): return input()


def hi(n): return [si() for _ in range(n)]


def hs(n): return [ss() for _ in range(n)]  


def s_list(): return list(input())


def mi(n): return [wi() for _ in range(n)]  


def mip(n): return [wip() for _ in range(n)]


def ms(n): return [ws() for _ in range(n)]


def num_grid(n): return [[int(i) for i in sys.stdin.readline().split()[
    0]] for _ in range(n)]  


def grid(n): return [s_list() for _ in range(n)]


def gcd(a, b):
    while b:
        a, b = b, a % b
    return a


def lcm(a, b):
    """a,bの最小公倍数"""
    return a * b // gcd(a, b)


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


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

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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
printV = lambda x: print(*x, sep="\n")
printH = lambda x: print(" ".join(map(str,x)))
def IS(): return sys.stdin.readline()[:-1]
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LII(rows_number): return [II() for _ in range(rows_number)]
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]
mo = 10**9+7

def main():
	r = II()
	print(2*r*3.14)

if __name__ == '__main__':
	main()

Solution (Python):
from math import pi

R = int(input())

print(2 * pi * R)

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

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

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

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

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

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

print(math.pi * r * 2)

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

Solution (Python):
import math

r = int(input())

print(2 * math.pi * r)