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

Solution (Python):










import math
import numpy as np
import statistics
import string
import sys
from array import array
from collections import deque
from functools import wraps
import time

def intinput():
    return int(input())
def listintinput():
    return list(map(int, input().split()))
def splitintinput():
    return map(int, input().split())
def factorialsurplus(x, y, z):  
    ret = 1
    for i in range(x, y + 1):
        ret = (ret * i) % z
    return (ret)
def isprime(x):
    if x == 1:
        return False
    if x == 2:
        return True
    sq = int(math.sqrt(x))
    for i in range(2,sq+1):
        if x % i == 0:
            return False
    return True
def hcfnaive(a,b):
    if(b==0):
        return a
    else:
        return hcfnaive(b,a%b)

R = intinput()
print(2*R*3.1415)

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

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

Solution (Python):

R = int(input())


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

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

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

Solution (Python):


import math


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


if __name__ == '__main__':
  main()

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










print(2 * N * 3.1415)

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

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

import math

print(2*n*math.pi)

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

Solution (Python):

import math

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

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

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

Solution (Python):


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

if __name__ == "__main__":
    main()

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

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

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

Solution (Python):
N = int(input())
print(N*6.283185307179586232)

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

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

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

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

Solution (Python):

r = int(input())

print(2*r*3.14)

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**8)
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 li2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]



import math
N = ii()

print(math.pi*2*N)

Solution (Python):
import math

inp = int(input())

print(math.pi * 2 * inp)

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

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

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

    print(2 * pi * R)


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

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

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

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

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

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

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

print(2 * r * math.pi)

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

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 sys

pi = 3.1415
def main():
    R =int(input())
    print(2 * R * pi)
    return


if __name__ == '__main__':
    main()

Solution (Python):

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

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

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

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

Solution (Python):
import math

r = int(input())

print(2 * math.pi * r)

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 numpy as np
if __name__ == "__main__":
    R = int(input())

    print(np.pi*R*2)

Solution (Python):
import math
import copy
import sys
import fractions


import decimal
import heapq
import collections
import itertools
import bisect
 

 
sys.setrecursionlimit(100001)
 
 


 

 
def getInputIntList():
    outputDataList = []
    inputData = input().split()
    outputDataList = [int(n) for n in inputData]
 
    return outputDataList
 
 
def getSomeInputInt(n):
    outputDataList = []
    for i in range(n):
        inputData = int(input())
        outputDataList.append(inputData)
 
    return outputDataList
 
 
def getSomeInputListInt(n):
    inputDataList = []
    outputDataList = []
    for i in range(n):
        inputData = input().split()
        inputDataList = [int(n) for n in inputData]
        outputDataList.append(inputDataList)
 
    return outputDataList
 
 

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

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

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

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

Solution (Python):
from math import *
test = 1

for __ in range(test):
	r = int(input())
	print(3.1415926*2*r)

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

print(2*s*3.14159265358979)

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

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 sys
import math
INT_MAX = sys.maxsize
INT_MIN = -(sys.maxsize)
sys.setrecursionlimit(10**7)
mod = 1000000007


def IOE():
    sys.stdin = open("input.txt", "r")
    sys.stdout = open("output.txt", "w")


def main():
    n = int(sys.stdin.readline())
    print(2*math.pi*n)


if __name__ == "__main__":
    try:
        IOE()
    except:
        pass
    main()

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()
import numpy as np
def main():
    r=int(input())
    print(2*np.pi*r)

if __name__=='__main__':
    main()

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

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

Solution (Python):
import math

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

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

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

Solution (Python):
import sys

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

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

if __name__ == '__main__':
	main()

Solution (Python):

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

Solution (Python):

R=int(input())



print(R*2*3.141592653589793238)

Solution (Python):

import math

R = int(input())

print(2*R*math.pi)

Solution (Python):
import os

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

if __name__ == "__main__":
        main()

Solution (Python):
import math

R=int(input()) 
L=2.0*math.pi*R 

print(L)

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

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

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

print(R*2*3.1415926535)

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

Solution (Python):
from math import pi

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

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

Solution (Python):



import math
R=float(input())

print(R*2*math.pi)

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

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

Solution (Python):
import math

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

Solution (Python):

import sys
from collections import Counter
from itertools import permutations, combinations
from math import ceil, floor, pi
import bisect
sys.setrecursionlimit(10 ** 6)

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

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

if __name__ == '__main__':
    main()

Solution (Python):


import math

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

    print(2*r*math.pi)

if __name__ == '__main__':
    main()

Solution (Python):

from collections import deque
from operator import itemgetter
from bisect import bisect_left, bisect
import itertools
import sys
import math
sys.setrecursionlimit(10**6)
input = sys.stdin.readline



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


if __name__ == '__main__':
    main()

Solution (Python):
import math

r = float(input())

print(r * 2 * math.pi)

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

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

Solution (Python):
import math

r=input()
r=int(r)

ans=2*r*math.pi

print(ans)

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

print (3.14 * val * 2)

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):

r = int(input())
a = 3.141592653
print(2*r * a)

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

Solution (Python):
import math

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

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

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

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

Solution (Python):


''' 
------------------------
author : iiou16
------------------------
'''
import math

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


if __name__ == '__main__':
    main()

Solution (Python):
import math

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

print(le)

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

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

print(2*R*math.pi)

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


main()

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

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

Solution (Python):
import math

p=math.pi

R=int(input())

print(2*p*R)

Solution (Python):
printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
ins = lambda : input().strip()
DBG = True 
BIG = 10**18
R = 10**9 + 7

def ddprint(x):
  if DBG:
    print(x)

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

Solution (Python):
import sys,math
def input():
    return sys.stdin.readline()[:-1]
N = int(input())

p = math.pi
print(2*N*p)

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

i_i = lambda: int(i_s())
i_l = lambda: list(map(int, stdin.readline().split()))
i_s = lambda: stdin.readline().rstrip()

R = i_i()

print(2*R * math.pi)

Solution (Python):


import math

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

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

if __name__ == "__main__":
    main()

Solution (Python):
import math

r = int(input())

print(2*r*math.pi)

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

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

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

Solution (Python):
import math

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

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

print(2*r*3.141592)

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

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

Solution (Python):
pi = 3.1415926535

R = int(input())

print(2*pi*R)

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

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

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

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

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

print(2*3.141592*R)

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

Solution (Python):

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

Solution (Python):
import math
r = float(input())
print("{:.25}".format(2.0 * math.pi * r))

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

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


from math import pi

def solve():
    return str(2*int(input())*pi)

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

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

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

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

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

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

Solution (Python):
import math


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

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

if __name__ == "__main__":
    main()

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

pi = 3.14159265358979
print(2*pi*R)

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

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

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

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

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

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

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

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

Solution (Python):

import math


import sys
input = sys.stdin.readline



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

    res = 2 * R * math.pi

    print(res)



main()

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

Solution (Python):

import math

R = int(input())

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

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

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

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

Solution (Python):
import math

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

    print(2*r*math.pi)

if __name__ == '__main__':
    main()

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

R = int(input())

print(2 * R * pi)

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

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

Solution (Python):

I=int(input())

A=3.14*2*I
print(A)

Solution (Python):
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate, product
import sys
import bisect
import string
import math
import time


def I(): return int(input())


def S(): return input()


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


def MS(): return map(str, input().split())


def LI(): return [int(i) for i in input().split()]


def LI_(): return [int(i)-1 for i in input().split()]


def StoI(): return [ord(i)-97 for i in input()]


def ItoS(nn): return chr(nn+97)


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


def debug(table, *args):
    ret = []
    for name, val in table.items():
        if val in args:
            ret.append('{}: {}'.format(name, val))
    print(' | '.join(ret), file=sys.stderr)


yn = {False: 'No', True: 'Yes'}
YN = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']

show_flg = False



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


if __name__ == '__main__':
    main()

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

Solution (Python):
from math import pi

r = int(input())

ans = 2 * r * pi
print(ans)

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

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

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

Solution (Python):
import math

R = int(input())

S = 2 * R * math.pi

print(S)

Solution (Python):
import numpy as np
radius = int(input())

print(np.pi * 2 * radius)

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

print(math.pi*2*R)

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

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

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

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

Solution (Python):

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

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

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

Solution (Python):
import math

def main():
    args = input().rstrip().split(' ')
    R = int(args[0])
    print(2*R*math.pi)
    
    
if __name__ == "__main__":
    main()

Solution (Python):
import math

x = float(input())

print(2 * x * math.pi)

Solution (Python):
import math
import sys
import collections

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





if __name__ == '__main__':
    main()

Solution (Python):
import numpy  as np

n = int(input())
print(n*2*np.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):
def main():
  a = int(input())
  print(a * 2 * 3.14)

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

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

Solution (Python):
import math


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

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

Solution (Python):
from math import pi

r = int(input())

ans = r * 2 * pi
print(ans)

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

Solution (Python):

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

Solution (Python):
import math


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

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

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

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

Solution (Python):


import math

R = int(input())

print(2 * R * math.pi)

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

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

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

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

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

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

print(2*pi*r)

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

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

import math

print(2*R*math.pi)

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

print(inp*2*math.pi)

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

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

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

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

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

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

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

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

print(x * 2 * 3.141592653589793)

Solution (Python):
import math

R = int(input())

print(2*math.pi*R)

Solution (Python):
import sys

import math
input = sys.stdin.readline

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

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

Solution (Python):
import sys
import math

X = int(sys.stdin.readline().rstrip())

print(2 * X * math.pi)

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

print(2*r*math.pi)

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

print(2*r*pi)

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

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

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

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

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

Solution (Python):


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

r = I()
print(2*3.141592*r)

Solution (Python):
import math

R = int(input())

print(math.pi * R * 2)

Solution (Python):
def pi():
    A=100
    pi=0
    for L in range(1,A):
        if L%2==0:
            B=-1
        else:
            B=1
        pi+=(4/(2*L-1))*B
    return pi
 
R = int(input())
print(pi()*2*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):
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 copy
import math
a = int(input())
print(a*2*3.1415926)

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

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

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

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


if __name__ == '__main__':
    main()

Solution (Python):
import math

R=int(input())

print(2 * R * math.pi)

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

Solution (Python):
import sys

lines = sys.stdin.readlines()

R = int(lines[0])

pi = 3.1415926535

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*p*r)

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

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

print(r * 2 * 3.14)

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

print(ans)

Solution (Python):
from sys import stdin
import math


if __name__ == "__main__":
    _in = [_.rstrip() for _ in stdin.readlines()]
    R = int(_in[0])  
    
    cnt = 2*math.pi*R
    
    print(cnt)

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

if __name__ == '__main__':
    main()

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

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

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

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

print(R)

Solution (Python):
import math

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

print(ans)

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

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

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

print(R*2*math.pi)

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

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

print(N*2*3.141592)

Solution (Python):
import math

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

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

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

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


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


main()