Problem:
 Score : 100 points    Problem Statement Print the circumference of a circle of radius R .      Constraints  1 \leq R \leq 100  All values in input are integers.         Input Input is given from Standard Input in the following format:  R       Output Print the circumference of the circle.
Your output is considered correct if and only if its absolute or relative error from our answer is at most 10^{-2} .        Sample Input 1 1      Sample Output 1 6.28318530717958623200  Since we accept an absolute or relative error of at most 10^{-2} , 6.28 is also an acceptable output, but 6 is not.       Sample Input 2 73      Sample Output 2 458.67252742410977361942

Solution (Python):
import math

r = int(input())

print(2*r*math.pi)

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

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

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 sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians

from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from functools import reduce
from bisect import bisect_left, insort_left
from heapq import heapify, heappush, heappop

INPUT = lambda: sys.stdin.readline().rstrip()
INT = lambda: int(INPUT())
MAP = lambda: map(int, INPUT().split())
S_MAP = lambda: map(str, INPUT().split())
LIST = lambda: list(map(int, INPUT().split()))
S_LIST = lambda: list(map(str, INPUT().split()))

sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7


def main():
    R = INT()
    print(2*pi*R)


if __name__ == '__main__':
    main()

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

Solution (Python):
import numpy as np


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


if __name__ == '__main__':
    main()

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

Solution (Python):
import math

R = int(input())

ans = 2 * R * math.pi

print(ans)

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


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

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

Solution (Python):
import math







import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()

def resolve():

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

resolve()

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

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

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

print((r + r) * 3.1415926535)

Solution (Python):
import math

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

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

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

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

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

print(2*pi*r)

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

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

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

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

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

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

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

Solution (Python):


import math


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


if __name__ == "__main__":
    main()

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

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):
import numpy as np

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

Solution (Python):
import collections
import math
import operator as op
from functools import reduce
from collections import Counter
import numpy as np
import math
import bisect
import heapq


def get_inputs(cast_func=None):
    if cast_func is None:
        return input().split()
    else:
        return list(map(cast_func, input().split()))


def get_input(cast_func=None):
    if cast_func is None:
        return input()
    else:
        return cast_func(input())


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




if __name__ == '__main__':
    main()

Solution (Python):
import math

r = int(input())

ans = r * 2 * math.pi

print(ans)

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

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

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

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

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

print(n*2*math.pi)

Solution (Python):
import numpy as np

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

Solution (Python):


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

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

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

Solution (Python):
import math

R = int(input())

print(math.pi * 2 *R)

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

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

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

Solution (Python):
import math

radius = float(input(""))

circumference = 2 * math.pi * radius

print("%.2f" % circumference)

Solution (Python):
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


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

    print(2 * 3.141592653589 * r)


if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):
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(2*r*3.14159265)

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

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 sys
import math


def input():
    return sys.stdin.readline().strip()


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


if __name__ == "__main__":
    main()

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

print (3.14 * val * 2)

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

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

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

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

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

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

print(R * 2 * 3.14159265)

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

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

Solution (Python):
import math

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

Solution (Python):

R  = int(input())


print(R * 2 * 3.1415)

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

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




print(3.141592653589*2*n)

Solution (Python):
from math import pi


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


if __name__ == '__main__':
    main()

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

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

Solution (Python):
import math

R = int(input())

print(2*R*math.pi)

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

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

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

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

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

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

Solution (Python):
import math


R = int(input())


print(R*2*math.pi)

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

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

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

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


if __name__ == '__main__':
    main()

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(str(3.1415*2*R))

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

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

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

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

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

Solution (Python):
import sys,collections as cl,bisect as bs,math
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): 
    return list(map(int,input().split()))
def m(): 
    return map(int,input().split())
def onem(): 
    return int(input())
def s(x): 
    a = []
    if len(x) == 0:
        return []
    aa = x[0]
    su = 1
    for i in range(len(x)-1):
        if aa != x[i+1]:
            a.append([aa,su])
            aa = x[i+1]
            su = 1
        else:
            su += 1
    a.append([aa,su])
    return a
def jo(x): 
    return " ".join(map(str,x))
def max2(x): 
    return max(map(max,x))
def In(x,a): 
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False

def pow_k(x, n):
    ans = 1
    while n:
        if n % 2:
            ans *= x
        x *= x
        n >>= 1
    return ans

"""
def nibu(x,n,r):
    ll = 0
    rr = r
    while True:
        mid = (ll+rr)//2

    if rr == mid:
        return ll
    if (ここに評価入れる):
        rr = mid
    else:
        ll = mid+1
"""

n = onem()

print(2*n*math.pi)

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

print(2*r*3.14159)

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

ans = 2 * R * math.pi

print(ans)

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

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

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

Solution (Python):


import sys
import math
import collections
import itertools
INF = 10 ** 13
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def lcm(x, y) : return (x * y) // math.gcd(x, y)
def I() : return int(input())
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(input()) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]
def LS() : return input().split()
def RS(N) : return [input() for _ in range(N)]
def LRS(N) : return [input().split() for _ in range(N)]
def PL(L) : print(*L, sep="\n")
def YesNo(B) : print("Yes" if B else "No")
def YESNO(B) : print("YES" if B else "NO")

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

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

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

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

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

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

Solution (Python):
import math

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

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

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

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

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

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

Solution (Python):
import math, sys
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from copy import deepcopy
from functools import lru_cache
from heapq import heapify, heappop, heappush
from itertools import accumulate, combinations, permutations
input = sys.stdin.readline
p = 10**9 + 7
ns = lambda: input().strip()
ni = lambda: int(input().strip())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))

def main():
    r = ni()

    print(2 * math.pi * r)

if __name__ == '__main__':
    main()

Solution (Python):
from math import pi

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

    print(2*r*pi)

Solution (Python):
import math

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

if __name__ == "__main__":
    main()

Solution (Python):
import sys
from math import pi

def solve():
    input = sys.stdin.readline
    R = int(input())
    print(2 * pi * R)

    return 0

if __name__ == "__main__":
    solve()

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

Solution (Python):
import sys
import itertools
if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
    
p=3.14159265
r=int(input())

print(2*p*r)

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

Solution (Python):
import math

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

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

print(2 * math.pi * R)

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

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

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

Solution (Python):

from sys import stdin
from operator import itemgetter
from collections import deque
import math
import pprint
from functools import reduce


def keta(kazu):
    kazu_str = str(kazu)
    kazu_list = [int(kazu_str[i]) for i in range(0, len(kazu_str))]
    return kazu_list

def gcd(*numbers):
    return reduce(math.gcd, numbers)

pi = math.pi

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

print(2*pi*R)

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

Solution (Python):
import math

r = int(input())

x = math.pi

print(r*2*x)

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

result = 3.1415926535*2*R
print(result)

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

Solution (Python):
import math

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

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

Solution (Python):
r=input()
l=2*float(r)*3.1415926535897932384626433832795028
print(l)

Solution (Python):
import sys
import math

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


def input():
    return sys.stdin.readline().strip()


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


if __name__ == "__main__":
    main()

Solution (Python):
inf = 10**15
mod = 10**9+7

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

Solution (Python):
import math

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

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

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

	print(s*2*3.14159)
	

if __name__ == '__main__':
	main()

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

print(2 * x * math.pi)

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

Solution (Python):
import math

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

if __name__ == "__main__":
    main()

Solution (Python):
import math

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

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

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

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

ans = 2* r * math.pi

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

a = 3.14159265
print(r*2*a)

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

Solution (Python):
import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)

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

r = II()
import math
print(math.pi*r*2)

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

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

Solution (Python):

import math
import sys
input = sys.stdin.readline


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


if __name__ == '__main__':
    main()

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

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

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

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

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

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

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

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())
import math
print(R*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):

import math 

r = int(input())

print(r*2*math.pi)

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

Solution (Python):
import math

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

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

syu = R * 2 * 3.1415
print(syu)

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):
import sys,math
import numpy as np

r=int(sys.stdin.readline())




print(2*math.pi*r)

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

print(math.pi*2*n)

Solution (Python):


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

if __name__ == "__main__":
    main()

Solution (Python):
from math import pi

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

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

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

Solution (Python):
from collections import  deque
import sys
import bisect
import math
import itertools
from queue import deque
from math import gcd

INF = float('inf')
mod = 10**9+7
eps = 10**-7

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

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

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

Solution (Python):

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

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

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

ans = R*2*3.1415





print(ans)

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

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

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

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

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

Solution (Python):
from math import pi

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

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

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

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

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

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

Solution (Python):
a = 6.28318530717958623200
N = int(input())
print(a*N)

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

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

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

Solution (Python):
import math
import operator as op
from functools import reduce

def ncr(n, r):
    r = min(r, n-r)
    numer = reduce(op.mul, range(n, n-r, -1), 1)
    denom = reduce(op.mul, range(1, r+1), 1)
    return numer / denom
"""
int(input())
map(int,input().split())
list(map(int,input().split()))
"""


            
       

t=1
for term in range(1,t+1):
    r=int(input())
    print(2*math.pi*r)

Solution (Python):
import math
import fractions
import sys
import itertools
import numpy as np
from collections import Counter
import datetime

def input1():
	return int(input())


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


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

def keta(N):
	return len(str(N))


def input_daytime(input_time):
	time,distance=input_time.split()
	t=time.split(":")
	se=str(t[-1]).split(".")
	dt1 = datetime.timedelta(hours=int(t[0]),minutes=int(t[1]),seconds=int(se[0]),milliseconds=int(se[1]))
	return dt1

def combinations(n,r):
	return list(itertools.combinations(n,r))

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

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

Solution (Python):
import math

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

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

Solution (Python):
import math 

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

resolve()

Solution (Python):

import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1

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

if __name__ == '__main__':
    main()

Solution (Python):
from collections import  deque
import sys
import bisect
import math
import itertools
from queue import deque
from math import gcd

INF = float('inf')
mod = 10**9+7
eps = 10**-7

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

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

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

Solution (Python):
import math

R = int(input())

print(2*R*math.pi)

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

Solution (Python):
import sys
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mod = 10**9 + 7

import math

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

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

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

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

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

Solution (Python):
import math







import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()

def resolve():

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

resolve()

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

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

    print(2*pi*R)

if __name__ == '__main__':
    main()

Solution (Python):
from math import pi

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

  print(2*R*pi)

if __name__ == "__main__":
  main()

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

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

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

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

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

print(ans)

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

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

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

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

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

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

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

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

Solution (Python):
import collections
import math
import operator as op
from functools import reduce
from collections import Counter
import numpy as np
import math
import bisect
import heapq


def get_inputs(cast_func=None):
    if cast_func is None:
        return input().split()
    else:
        return list(map(cast_func, input().split()))


def get_input(cast_func=None):
    if cast_func is None:
        return input()
    else:
        return cast_func(input())


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




if __name__ == '__main__':
    main()

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
import numpy as np
n = int(input())
print(2*n*np.pi)

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

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

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

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

Solution (Python):

R = int(input())
from numpy import pi

print(2*R*pi)

Solution (Python):
import math

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

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

main()

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

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

Solution (Python):

















mod = 10**9 + 7

def readInts():
  return list(map(int,input().split()))
def main():
    r = int(input())
    import math
    pi_ = math.pi
    print(2*pi_*r)
if __name__ == '__main__':
  main()

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

print(2*3.141592*R)

Solution (Python):


import math

R = int(input())

print(2*math.pi*R)

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

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

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

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

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

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

R=int(input())

print(2*R*pi)

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

Solution (Python):
import math

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

if __name__ == '__main__':
    main()

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

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

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

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

print(math.pi*2*R)

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

print(r * 2 * math.pi)

Solution (Python):

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

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

print(2*r*math.pi)

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

Solution (Python):


def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    
    from itertools import combinations, permutations, accumulate, groupby, product
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    from math import floor, ceil
    import math
    

    
    

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

if __name__ == '__main__':
    main()

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

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

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

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

print(2*R*3.1415926535897)

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

print(2*r*math.pi)

Solution (Python):
import numpy as np


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



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

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

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


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):

import math 












mod = int(1e9+7)
INF = 1<<29
lINF = 1<<35

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

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

if __name__=='__main__':
    main()

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


print(2 * R * math.pi)

Solution (Python):
import math

k = int(input())

print(2 * k * math.pi)

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

print(2 * r * math.pi)

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