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

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

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

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

Solution (Python):
n  = int(input())
radius = float(2*3.141592653589793*n)
print(radius)

Solution (Python):
n  = int(input())
radius = float(2*3.141592653589793*n)
print(radius)

Solution (Python):
import math

R = int(input())

ans = 2 * math.pi * R

print(ans)

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

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

Solution (Python):
import math

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

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

Solution (Python):
import math

R = int(input())

print(2 * math.pi * R)

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

print(r*2*3.141592)

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

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

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

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

import math

print(R*2*math.pi)

Solution (Python):
import math
print("{:.10f}".format(float(input()) * 2 * math.pi))

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

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

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

Solution (Python):
import math

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

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

Solution (Python):

r = int(input())

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

Solution (Python):
import math

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

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

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

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

Solution (Python):
import numpy as np

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

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

Solution (Python):
import math

R = int(input())

print(2*R*math.pi)

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

Solution (Python):
def abc(R):
    
    pi = 3.141592
    
    
    ans = R * 2 * pi
    
    
    return(ans)



if __name__ == "__main__":
    
    
    R = int(input())
    
    
    f = abc(R)
    
    
    print(f)

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

Solution (Python):
import math

R = int(input())

print(math.pi*R*2)

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

Solution (Python):
import numpy as np
def solve(r):
    return 2 * np.pi * r

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

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

Solution (Python):

n = int(input())
c = (2*22*(n))/7
print(c)

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

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

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

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

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

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

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

Solution (Python):
import sys
from random import choice,randint
inp=sys.stdin.readline
out=sys.stdout.write
flsh=sys.stdout.flush
 
sys.setrecursionlimit(10**9)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
 
def MI(): return map(int, inp().strip().split())
def LI(): return list(map(int, inp().strip().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines().strip()]
def LI_(): return [int(x)-1 for x in inp().strip().split()]
def LF(): return [float(x) for x in inp().strip().split()]
def LS(): return inp().strip().split()
def I(): return int(inp().strip())
def F(): return float(inp().strip())
def S(): return inp().strip()
def pf(s): return out(s+'\n')
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)

def main():
    r = I()
    ans = 2*r*(22/7)
    print(ans)

if __name__ == "__main__":
    main()

Solution (Python):


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

"""
cd "/Users/magolor/Desktop/AtCoder/Python/abc163/a/"  && oj t -c "python main.py"
acc submit main.py
"""

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

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

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

Solution (Python):
n  = int(input())
radius = float(2*3.141592653589793*n)
print(radius)

Solution (Python):
n  = int(input())
radius = float(2*3.141592653589793*n)
print(radius)

Solution (Python):
import sys
import math


try:
    sys.stdin = open(sys.path[0] + '\\input.txt', 'r')
    sys.stdout = open(sys.path[0] + '\\output.txt', 'w')
except FileNotFoundError:
    pass


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

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

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

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

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

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

print(3.14159*2*t)

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

Solution (Python):
import math


R = int(input())

area = 2*math.pi*R

print(area)

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

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

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

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

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

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

Solution (Python):
from math import pi
inp = int(input())
ans = (inp+inp) * pi
print(ans)

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

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

Solution (Python):
def input_int_list():
    return [int(thing) for thing in input().split(" ")]

def int_input():
    return int(input())


R=int_input()
pi=3.141592

print(2*pi*R)

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

Solution (Python):

from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def S(): return input().rstrip()
def LS(): return S().split()
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float("INF")


def solve():
    r = II()
    print(r * 2 * math.pi)
    return



if __name__ == '__main__':
    solve()

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

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

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

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

Solution (Python):
import math

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

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

Solution (Python):

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

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

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

Solution (Python):
円周率=3.14
整数型の=int
入力値=input
出力する=print

半径=整数型の(入力値())
出力する(2*半径*円周率)

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

print(math.pi*2*r)

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

Solution (Python):
import numpy as np
import math
import scipy as sp
import queue
import collections

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

def main(kwargs):
    r = kwargs["r"]
    res = 2 * r * math.pi
    return res

if __name__ == "__main__":
    kwargs = {}

    cin = input().split()
    
    
    kwargs["r"] = [int(i) for i in cin][0]
    

    cout = main(kwargs)
    print(cout)

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

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

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

Solution (Python):


from sys import stdin, stderr
import math

def main():
   R = int(stdin.readline())
   print('%.010f' % (2*math.pi*R))
   return 0

if __name__ == '__main__': main()

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

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

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

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

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

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

ans = r * 2 * 3.141592

print(ans)

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




ans=2*r*3.14159
print('{:.5f}'.format(ans))

Solution (Python):
import math

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

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

if __name__ == "__main__":
    main()

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

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

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

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

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

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

print(2*math.pi*r)

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

Solution (Python):
import math
math.pi

N = int(input())

print(2*N*math.pi)

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

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

Solution (Python):
import math

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

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

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

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

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

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 math

if __name__ == "__main__":
    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())
import math
print(math.pi*2*r)

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

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

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

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

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

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

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

a = 2*3.1426*R

print(a)

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

Solution (Python):
from math import pi

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

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

Solution (Python):
import math

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

Solution (Python):
from math import pi

r = int(input())
print('%.15lf'%(2 * pi * r))

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

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

Solution (Python):
import math

r = int(input())

print(2 * math.pi * r)

Solution (Python):
x = input('')
Pi = 3.141592653589793
y = 2.0*Pi*float(x)
print(y)

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

Solution (Python):
import math

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

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

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

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

Solution (Python):
import math

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

Solution (Python):
import sys
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
 
ni      = lambda: int(ns())
nin     = lambda y: [ni() for _ in range(y)]
na      = lambda: list(map(int, stdin.readline().split()))
nan     = lambda y: [na() for _ in range(y)]
nf      = lambda: float(ns())
nfn     = lambda y: [nf() for _ in range(y)]
nfa     = lambda: list(map(float, stdin.readline().split()))
nfan    = lambda y: [nfa() for _ in range(y)]
ns      = lambda: stdin.readline().rstrip()
nsn     = lambda y: [ns() for _ in range(y)]
ncl     = lambda y: [list(ns()) for _ in range(y)]
nas     = lambda: stdin.readline().split()

import math

r = ni()

print(2 * r * math.pi)

Solution (Python):
import math

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

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

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

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

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)



def in_int():
    return (int(input()))


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


def in_str():
    s = input()
    return (list(s[:len(s) - 1]))


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

mod = 7 + 10**9

n = in_int()

print(6.28*n)

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

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

Solution (Python):
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7 
input=lambda:sys.stdin.readline().rstrip()
from math import pi
def resolve():
    print(int(input()) * pi * 2)
resolve()

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

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

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

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

Solution (Python):
from sys import stdin, stdout
r = int(stdin.readline())
import math
c = 2*math.pi*r
stdout.write("{}\n".format(c))

Solution (Python):
import heapq
import math
import random
import sys
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque, namedtuple, UserDict
from functools import cmp_to_key, lru_cache, reduce
from itertools import (chain, combinations, combinations_with_replacement,
                       permutations, product)

sys.setrecursionlimit(10**6+1)
write = sys.stdout.write


MOD = 10**9 + 7


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

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

Solution (Python):

"""
Created on Sun Apr 19 21:50:40 2020

@author: Kashem Pagla
"""


from math import pi
r=int(input())
print(round(2*r*pi,11))

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

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

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

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

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

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

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

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

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

Solution (Python):
import math


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


if __name__ == '__main__':
    solve()

Solution (Python):
import numpy as np

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

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

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

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

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

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

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

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

print (3.14159265 * 2 * a)

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


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

Solution (Python):
from math import pi

r = int(input())

print(2*pi*r)

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

Solution (Python):

from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.buffer.readline().split()]
def I(): return int(sys.stdin.buffer.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007

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


if __name__ == "__main__":
    solve()

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

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

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

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

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

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

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

Solution (Python):
a=input()
print(eval(a)*6.28318530717958623200)

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

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

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

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

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

print(2*R*math.pi)

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

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

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

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

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


print(R*2*3.1415)

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


print(R*2*3.1415)

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

print(2*radius*3.141592653589793)

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


print(2*r*3.141592)

Solution (Python):
from math import pi

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

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

Solution (Python):
import math
def resolve():
    N = int(input())
    print(2*N*math.pi)
if __name__ == "__main__":
    resolve()

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

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

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

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

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

print(2*R * math.pi)

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

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

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

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

Solution (Python):
import math

def Next(): return input()
def NextInt(): return int(Next())
def NextInts(): return map(int,input().split())
def Nexts(): return map(str,input().split())
def NextIntList(): return list(map(int,input().split()))
def RowInts(n): return [input() for i in range(n)]

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

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

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

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

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

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

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

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

Solution (Python):

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

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

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

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

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

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

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

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

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

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

Solution (Python):
import math
import sys

sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline


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


if __name__ == '__main__':
    solve()

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

Solution (Python):
n = float(input())
pi = 3.1415926535
rlen = round(2.0 * pi * n, 3)
print(rlen)

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

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

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

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

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

ans = 2 * R * math.pi

print(ans)

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

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

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

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

x = 2.0*r*math.pi
print(x)

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

print(a*2*math.pi)

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

Solution (Python):
from sys import stdin, setrecursionlimit, stdout

from collections import deque
from math import sqrt, floor, ceil, log, log2, log10, pi, gcd, sin, cos, asin
def ii(): return int(stdin.readline())
def fi(): return float(stdin.readline())
def mi(): return map(int, stdin.readline().split())
def fmi(): return map(float, stdin.readline().split())
def li(): return list(mi())
def lsi():
    x=list(stdin.readline())
    x.pop()
    return x
def si(): return stdin.readline()
mod=1000000007
res=['YES', 'NO']

print(2*pi*ii())

Solution (Python):
import math 

R = float(input())

print(R *  2 * math.pi)

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

ans = math.pi * 2 * r

print(ans)

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

print(2*radius*3.141592653589793)

Solution (Python):
import math

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

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

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

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

Solution (Python):
import math

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

    ans = 2 * math.pi * R

    print('{}'.format(ans))


if __name__ == '__main__':
    main()

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

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

Solution (Python):
import math

N = int(input())

print(2*N*math.pi)

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

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

Solution (Python):

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


if __name__ == '__main__':
    main()

Solution (Python):
import math

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

print(s * 2 * x)

Solution (Python):
import math
R = int(input())
L = str(2*math.pi*R)
P = [i for i in L]
A = []
B = [0] * (len(P)-5)
for i in range(len(P)):
  i *= -1
  i -= 1
  if i < -5:
    A.append(P[i])
for i in range((len(P)-5)):
  j = -i-1
  B[j] = A[i]
[int(i) for i in B if i != "."]
print(*B, sep="")

Solution (Python):

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

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

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

Solution (Python):
import sys
import math

N = int(sys.stdin.readline())
print(2 * N * math.pi)

Solution (Python):
import sys
import math
from collections import defaultdict
from bisect import bisect_left, bisect_right

sys.setrecursionlimit(10**7)
def input():
    return sys.stdin.readline()[:-1]

mod = 10**9 + 7

def I(): return int(input())
def LI(): return list(map(int, input().split()))
def LIR(row,col):
    if row <= 0:
        return [[] for _ in range(col)]
    elif col == 1:
        return [I() for _ in range(row)]
    else:
        read_all = [LI() for _ in range(row)]
        return map(list, zip(*read_all))



R = I()

print(2*math.pi*R)

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

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

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

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

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

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

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

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

Solution (Python):
import math

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

Solution (Python):
import math

R=int(input())

L=2*R*math.pi

print(L)

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

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

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

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

r = int(input())

print(2*r*3.1415926535)

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

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

from math import pi

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

Solution (Python):
I=lambda:list(map(int,input().split()))
n,=I()
import math as mt
print(2*mt.pi*n)

Solution (Python):
import math


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

x=(int)(input())
print(circle_round(x))

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

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

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

Solution (Python):
import math

r = int(input())

R = 2*r*math.pi

print(R)

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

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

Solution (Python):

"""
Created on Sun Apr 19 20:57:08 2020

@author: black
"""


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

print(2*pi*R)

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

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

Solution (Python):
import math

r=float(input())

print(2*r*math.pi)

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

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

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

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

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

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

m = r * 2 * 3.1415
print(m)

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

Solution (Python):
pi = 3.141593

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

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

Solution (Python):
n = int(input())
a = n/0.1591549431
print(a)

Solution (Python):
import math

def solve(r):
    c = 2 *math.pi * r
    print('%.7f'%c)

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

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

Solution (Python):
def circumference(r):
  import numpy as np
  return 2 * np.pi * r

r = int(input())
print(circumference(r))

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

Solution (Python):
from math import pi

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

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

Solution (Python):
import math as m

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

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

Solution (Python):


r = int(input())

print(2 * r * 3.14159265)

Solution (Python):
import math

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

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

Solution (Python):
import math
r=float(input())
pi=float(math.asin(1)*2)
s=float(2*r*pi)
print(format(s,'.20f'))

Solution (Python):

import math

R = int(input())

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())
    
    pi = 3.141592
    ans = pi * r * 2.0
    print(ans)