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

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

Solution (Python):
import math

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

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

Solution (Python):


import math

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

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

print(r*2*x)

Solution (Python):


import math



R = int(input())


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


if __name__ == "__main__":
    main()

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

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

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

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

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

Solution (Python):
PI = 3.1415


def circumference(r): 
	return (2 * PI * r) 



k=int(input(" "))
print ('%.3f' % circumference(k))

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

print(length)

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

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

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):
import time
startTimeProblem=time.time()

import fileinput, sys, itertools
from math import *
from bisect import *
from heapq import *
from collections import *

def lcm(a, b):  
    return (a*b)/gcd(a, b)

class InputHelper:
    def __init__(self):
        self.myinput = fileinput.input()

    def isLocal(self):
        return not fileinput.isstdin()

    def int(self):
        return int(self.myinput.readline().rstrip())

    def ints(self):
        return [int(_) for _ in self.myinput.readline().rstrip().split()]

    def str(self):
        return self.myinput.readline().rstrip()

    def strs(self):
        return [_ for _ in self.myinput.readline().rstrip().split()]

class OutputHelper:
    def int(self, a):
        print(a)    

    def ints(self, a):  
        print(" ".join([str(_) for _ in a]))
    
    def intsNL(self, a):
        for _ in a:
            print(_)
    
    def str(self, s):
        print(s)

    def strs(self, s):
        print(" ".join([_ for _ in s]))

    def strsNL(self, s):
        for st in s:
            print(st)

class ListNode:
    def __init__(self, val):
        self.val = val
        self.next = None
        self.prev = None

In = InputHelper()
Out = OutputHelper()



r = In.int()





print(2*pi*r)




if len(sys.argv)>2 and sys.argv[2]=="TIMEIT":
    fin = (time.time()-startTimeProblem)*1000
    print("{:.2f}".format(fin) + "ms")

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

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

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

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

    print(2*r*pi)

Solution (Python):
import math

r = int(input())

print(2*math.pi*r)

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

pi = 3.14159264358

en = 2 * r * pi

print(en)

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

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

print(2*A*3.1415)

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


R = int(readline())

print(2 * math.pi * R)

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


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


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


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


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


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


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


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

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

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):
import numpy as np
R = int(input())
S = 2 *  R * np.pi 
print(S)

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

length = 2 * 3.141592653589 * r
print(length)

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

Solution (Python):
pi = 3.1415

r = int(input())

ans = 2 * r * pi
print(ans)

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

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

print(2*3.141592*r)

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

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

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

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

ans = 2*r*3.141592653589793

print(ans)

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

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

Solution (Python):
import math

f = float(input())

print(2 * math.pi * f)

Solution (Python):
import math

r = int(input())

print(r * 2 * math.pi)

Solution (Python):
import numpy as np

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

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

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

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

Solution (Python):

import math
r = int(input())


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

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

print(math.pi*r*2)

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

Solution (Python):


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

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

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.14159265358)

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

print(2*a*r)

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

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

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

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

Solution (Python):


iim = lambda: map(int, input().rstrip().split())

from math import pi
def resolve():

    R = int(input())

    print(2*pi*R)


if __name__ == "__main__":
    resolve()

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

print(inp*2*math.pi)

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

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

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

Solution (Python):
import math
math.pi

a = int(input())

print(2 * math.pi * a)

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

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

Solution (Python):
from __future__ import print_function

import sys

import re
import array
import copy
import functools
import operator

import math
import string
import fractions
from fractions import Fraction
from fractions import gcd

import collections
import itertools
import bisect

import random
import time

import heapq
from heapq import heappush
from heapq import heappop
from heapq import heappushpop
from heapq import heapify
from heapq import heapreplace
from queue import PriorityQueue as pq
from queue import Queue

from itertools import accumulate

from collections import deque
from collections import Counter

from operator import mul
from functools import reduce

input = sys.stdin.readline


def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)
    return


def lcm(n, m):
    return int(n * m / gcd(n, m))


def coprimize(p, q):
    common = fractions.gcd(p, q)
    return (p // common, q // common)


def combinations_count(n, r):
    r = min(r, n - r)
    numer = reduce(mul, range(n, n - r, -1), 1)
    denom = reduce(mul, range(1, r + 1), 1)
    return numer // denom


def find_gcd(list_l):
    x = reduce(gcd, list_l)
    return x


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


if __name__ == '__main__':
    main()

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

Solution (Python):
import math

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

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

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

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

print(2*r*3.141592)

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

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

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

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

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

Solution (Python):
import math

R = int(input())

print(2*math.pi*R)

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

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


print(r* 6.28318530717958623200)

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

Solution (Python):
import sys, bisect, math, itertools, string, queue, copy


from collections import Counter,defaultdict,deque
from itertools import permutations, combinations
from heapq import heappop, heappush
from fractions import gcd

sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

def main():
    r = inp()
    print(r*2*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())
print(r*2*math.pi)

Solution (Python):
import math

r = int(input())

print(math.pi*r*2.0)

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

Solution (Python):


import math
R=float(input())

print(R*2*math.pi)

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

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

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

print(2*3.14159*R)

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

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

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

Solution (Python):


import math

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

Solution (Python):
import sys,math
import numpy as np

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




print(2*math.pi*r)

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

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

Solution (Python):
import math

r = int(input())

print(2 * math.pi * r)

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

print(Ans)

Solution (Python):
pi4 = 0
for i in range(1000000):
    pi4 += (1 / (i * 4 + 1) - 1 / (i * 4 + 3))
pi = pi4 * 4    

R = int(input())

print(2*pi*R)

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

Solution (Python):


import math


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


if __name__ == '__main__':
  main()

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

print(2 * 3.14 * n)

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

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

Solution (Python):
import math

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

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

print(2*R*3.14159)

Solution (Python):
import math

R = int(input())

print(R * 2 * math.pi)

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

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

print(2 * x * pi)

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

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

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

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

Solution (Python):
import numpy as np

def circle_round(R):
  return 2 * np.pi * R

R = int(input())

print(circle_round(R))

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

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

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


if __name__ == '__main__':
    resolve()

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

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

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

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

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

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

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

Solution (Python):
import math

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


if __name__ == "__main__":
    main()

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

print(2*pi*R)

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

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

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

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

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

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

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

print(6.28318530717958623200*R)

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

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

Solution (Python):

import math
r = int(input())


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

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

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

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

Solution (Python):

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

Solution (Python):
import math

r = input()
r = int(r)

length = 2*r*math.pi

print(length)

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

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

print(2*3.14159*R)

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

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

Solution (Python):

R = int(input())

print(R * 2 * 3.141592653589793)

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

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

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

x = 2*3.141592653589*r

print(x)

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

Solution (Python):
import math

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

print(ans)

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

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

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

A()

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

Solution (Python):
import numpy

r = int(input())

print(r*2*numpy.pi)

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

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

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

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

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

Solution (Python):


import sys
import math


sys.setrecursionlimit(10 ** 6)

input_line = input()
inputs = input_line.split(' ')
R, = list(map(int, inputs))

print(2*R*math.pi)

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

print(r*2*math.pi)

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

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

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

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

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

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

Solution (Python):
import math

R = int(input())

print(2*R*math.pi)

Solution (Python):
import math

R = int(input())

ans = round(2 * R * math.pi,3)

print(ans)

Solution (Python):
import numpy as np

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

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

r = int(input())

print((r + r)*math.pi)

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

import math

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

Solution (Python):
import sys
import math
int1 = lambda x: int(x) - 1
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)

R = int(read())

print(2 * R * math.pi)

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

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

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

print(2*math.pi*r)

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

Solution (Python):
import math

r = int(input())

print(r*2*math.pi)

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

Solution (Python):
from math import pi

r = int(input())

print(r * 2 * pi)

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

Solution (Python):
import math

a=int(input())

print(math.pi*2*a)

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

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

Solution (Python):

import re
import math
from collections import defaultdict
import itertools
from copy import deepcopy
import random
from heapq import heappop,heappush
import time
import os
import queue
import sys
import datetime
from functools import lru_cache
readline=sys.stdin.readline
sys.setrecursionlimit(2000)

alphabet="abcdefghijklmnopqrstuvwxyz"
mod=int(10**9+7)
inf=int(10**20)
def yn(b):
    if b:
        print("yes")
    else:
        print("no")
def Yn(b):
    if b:
        print("Yes")
    else:
        print("No")
def YN(b):
    if b:
        print("YES")
    else:
        print("NO")
class union_find():
    def __init__(self,n):
        self.n=n
        self.P=[a for a in range(N)]
        self.rank=[0]*n
 
    def find(self,x):
        if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
        return self.P[x]
 
    def same(self,x,y):
        return self.find(x)==self.find(y)
 
    def link(self,x,y):
        if self.rank[x]<self.rank[y]:
            self.P[x]=y
        elif self.rank[y]<self.rank[x]:
            self.P[y]=x
        else:
            self.P[x]=y
            self.rank[y]+=1
 
    def unite(self,x,y):
        self.link(self.find(x),self.find(y))
 
    def size(self):
        S=set()
        for a in range(self.n):
            S.add(self.find(a))
        return len(S)
def is_power(a,b):
    now=b
    while now<a:
        now*=b
    if now==a:return True
    else:return False
def bin_(num,size):
    A=[0]*size
    for a in range(size):
        if (num>>(size-a-1))&1==1:
            A[a]=1
        else:
            A[a]=0
    return A
def get_facs(n,mod_=0):
    A=[1]*(n+1)
    for a in range(2,len(A)):
        A[a]=A[a-1]*a
        if(mod>0):A[a]%=mod_
    return A
def comb(n,r,mod,fac):
    if(n-r<0):return 0
    return (fac[n]*pow(fac[n-r],mod-2,mod)*pow(fac[r],mod-2,mod))%mod
def next_comb(num,size):
    x=num&(-num)
    y=num+x
    z=num&(~y)
    z//=x
    z=z>>1
    num=(y|z)
    if(num>=(1<<size)):return False
    else:
        return num
def get_primes(n,type="int"):
    A=[True]*(n+1)
    A[0]=False
    A[1]=False
    for a in range(2,n+1):
        if A[a]:
            for b in range(a*2,n+1,a):
                A[b]=False
    if(type=="bool"):return A
    B=[]
    for a in range(n+1):
        if(A[a]):B.append(a)
    return B
def is_prime(num):
    if(num<=2):return False
    i=2
    while i*i<=num:
       if(num%i==0):return False
       i+=1
    return True
def ifelse(a,b,c):
    if a:return b
    else:return  c
def join(A,c=" "):
    n=len(A)
    A=list(map(str,A))
    s=""
    for a in range(n):
        s+=A[a]
        if(a<n-1):s+=c
    return s
def factorize(n,type_="dict"):
    b = 2
    list_ = []
    while b * b <= n:
        while n % b == 0:
            n //= b
            list_.append(b)
        b+=1
    if n > 1:list_.append(n)
    if type_=="dict":
        dic={}
        for a in list_:
            if a in dic:
                dic[a]+=1
            else:
                dic[a]=1
        return dic
    elif type_=="list":
        return list_
    else:
        return None
def floor_(n,x=1):
    return x*(n//x)
def ceil_(n,x=1):
    return x*((n+x-1)//x)

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

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

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

Solution (Python):


import sys
import math

DEBUG = False

def read(t):
    return t(sys.stdin.readline().rstrip())


def read_list(t, sep = " "):
    return [t(s) for s in sys.stdin.readline().rstrip().split(sep)]


def dprint(*args, **kwargs):
    if DEBUG:
        print(*args, **kwargs)
    return


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


if __name__ == "__main__":
    main()

Solution (Python):
import math

r = int(input())

print(2*math.pi*r)

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

Solution (Python):

"""
Created on Sun Apr 19 20:58:55 2020

@author: liang
"""

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

Solution (Python):
import math

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

Solution (Python):
import math

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


solution()

Solution (Python):
def main():

    r = int(input())
    return 2 * r * 3.14159265359

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

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

Solution (Python):

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

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

ans = math.pi * 2 * r

print(ans)

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

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

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

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

print(data * 3.1415926535 *2)

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

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


if __name__ == '__main__':
    main()

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

Solution (Python):

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

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

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

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

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

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

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

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

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

ans = float(N*2*math.pi)


print(ans)

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

Solution (Python):



import sys
import math

s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [i2s() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))

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

main()

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

print(float(2*3.1415926535*R))

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

Solution (Python):
import math

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

Solution (Python):

import math


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

    return str(2*math.pi*r)


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

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

Solution (Python):
import math
math.pi

r = int(input())

radius = 2 * math.pi * r

print(radius)

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

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

import math

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


if __name__ == '__main__':
    main()

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

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

Solution (Python):

import sys
input = sys.stdin.readline





def main():
    n = int(input())
    print(2*n*3.14)
    


    
if __name__ == '__main__':
    main()

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

Solution (Python):
import math

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

print(ans)

Solution (Python):
from sys import stdin
import sys
import math
 




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

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline
from itertools import permutations,  combinations, accumulate
from functools import *
from collections import deque, defaultdict, Counter
from heapq import heapify, heappop, heappush, heappushpop

INF = float('inf')
NIL = - 1

""" Input
S = input().rstrip()
N, A, B = map(int, input().split())
A = list(map(int, input().split()))
A = np.array(input().split(), dtype=np.float64)
D = [int(input()) for _ in range(N)]
AB = [[int(x) for x in input().split()] for _ in range(N)]
PX = [[int(x) for x in input().split()] for _ in range(Q)]
"""
import numpy as np


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

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

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

Solution (Python):
import math

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

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


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

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

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

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

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

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



print(R * 2 * 3.14159265358979323846)

Solution (Python):
import math

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

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

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

print(2*r*3.141592)

Solution (Python):
import math

r = int(input())

print(2*r*math.pi)

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

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

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

R = int(input())

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

print(circle_round(R))

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

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

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