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):
"""
// Author : snape_here - Susanta Mukherjee
     
 """
 
from __future__ import division, print_function
 
import os,sys
from io import BytesIO, IOBase
 
if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
 
 
def ii(): return int(input())
def si(): return input()
def mi(): return map(int,input().split())
def li(): return list(mi())
 
 
def read():
    sys.stdin = open('input.txt', 'r')  
    sys.stdout = open('output.txt', 'w') 
 
def gcd(x, y):
    while y:
        x, y = y, x % y
    return x

mod=1000000007

import math

import bisect

abc="abcdefghijklmnopqrstuvwxyz"

def main():

    r=ii()
    ans=3.141592653589793238*r*2 
    print(ans)

        


 
BUFSIZE = 8192
 
 
class FastIO(IOBase):
    newlines = 0
 
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
 
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
 
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
 
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
 
 
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
 
 
def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()
 
 
if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
 
input = lambda: sys.stdin.readline().rstrip("\r\n")
 

 
 
if __name__ == "__main__":
    
    main()

Solution (Python):
import math


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

Solution (Python):
import math


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

N = int(input())
print(circle_round(N))

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

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

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

print(N * 2.0 * 3.1415926535897932)

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

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

Solution (Python):
import sys
import math

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

print(2 * math.pi * r)

Solution (Python):
import math

r = int(input())

print(2*r*math.pi)

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

print(R*2*3.1415926535897)

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

Solution (Python):
from math import gcd
from functools import reduce
from itertools import product

def resolve():
  R = int(input())
  print(R*2*3.141592)


if __name__ == "__main__":
    resolve()

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

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

Solution (Python):

import sys

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


if __name__ == '__main__':
    main()

Solution (Python):


from sys import stdin
import numpy as np


def main():
    N = int(stdin.readline())
    print(f'{str(2 * np.pi * N):.6}')


if __name__ == "__main__":
    main()

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

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

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

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

r=int(input())


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

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

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

print(2*math.pi*r)

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

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

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

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

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):
mod = 1000000007
eps = 10**-9


def main():
    import sys
    import math
    input = sys.stdin.readline

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


if __name__ == '__main__':
    main()

Solution (Python):
from math import pi

r = int(input());

print(2*pi*r)

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

Solution (Python):
from math import pi

r = float(input())
print(2.0 * pi * r)

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

Solution (Python):
import math

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

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

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

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

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

print(2 * math.pi * R)

Solution (Python):
import math

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

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

Solution (Python):
import math

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

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

Solution (Python):
import math

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

Solution (Python):


import sys
import math
import bisect
from fractions import gcd
from itertools import count, permutations
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint

INF = float('inf')

ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
lmtx = lambda h: [list(map(int, lmis())) for _ in range(h)]
sys.setrecursionlimit(1000000000)


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



r = ii()

print(2 * math.pi * r)

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

Solution (Python):

import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from decimal import *
from collections import deque
from math import gcd
sys.setrecursionlimit(10**7)
MOD = 10**9+7
INF = float('inf') 
def lcm(a,b):return (a*b) // gcd(a,b) 
def iin(): return int(sys.stdin.readline()) 
def ifn(): return float(sys.stdin.readline()) 
def isn(): return sys.stdin.readline().split() 
def imn(): return map(int, sys.stdin.readline().split()) 
def imnn(): return map(lambda x:int(x)-1, sys.stdin.readline().split()) 
def fmn(): return map(float, sys.stdin.readline().split()) 
def iln(): return list(map(int, sys.stdin.readline().split())) 
def iln_s(): return sorted(iln()) 
def iln_r(): return sorted(iln(), reverse=True) 
def fln(): return list(map(float, sys.stdin.readline().split())) 
def join(l, s=''): return s.join(l) 
def perm(l, n): return itertools.permutations(l, n) 
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) 
def comb(l, n): return itertools.combinations(l, n) 
def comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) 
def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 
def m_add(a,b): return (a+b) % MOD
def lprint(l): print(*l, sep='\n')
def sieves_of_e(n):
    is_prime = [True] * (n+1)
    is_prime[0] = False
    is_prime[1] = False
    for i in range(2, int(n**0.5)+1):
        if not is_prime[i]: continue
        for j in range(i * 2, n+1, i): is_prime[j] = False
    return is_prime

R = iin()

print(2*R*math.pi)

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

Solution (Python):
import math

r = int(input())

print(2 * r * math.pi)

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

ans = 2*R*math.pi

print(ans)

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

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

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

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

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

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

print(main())

Solution (Python):
import sys
import re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
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()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

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

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

Solution (Python):
from sys import stdin

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

pi = 3.141592

print(pi*R*2)

Solution (Python):
import math

r = int(input())

print(2*r*math.pi)

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

def RD(): return sys.stdin.read()
def II(): return int(input())
def MI(): return map(int,input().split())
def LI(): return list(map(int,input().split()))
def TI(): return tuple(map(int,input().split()))


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

    
    print(2*math.pi*r)


if __name__ == "__main__":
	main()

Solution (Python):
import math
print(2*math.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):
H = int(input())
S = 3.14
print(H*2*S)

Solution (Python):
import math

def circle(r):
    print(2*r*math.pi)

r = int(input())
circle(r)

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

print(2*R*3.14)

Solution (Python):
import math

R=int(input())

print(2*math.pi*R)

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

PI = 3.141592
print(2 * PI * r)

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

print((r + r) * 3.1415926535)

Solution (Python):


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

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

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

print(6.28318530717958623200*r)

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

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

Solution (Python):
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,copy,time
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp():
    '''
    一つの整数
    '''
    return int(input())
def inpl():
    '''
    一行に複数の整数
    '''
    return list(map(int, input().split()))
def inpl_str():
    '''
    一行に複数の文字
    '''
    return list(input().split())

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

Solution (Python):
import math 

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

Solution (Python):
import math

r = int(input())

print(2 * r * math.pi)

Solution (Python):
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do(): 
    r=INT()
    print(r*3.1415*2)
if __name__ == '__main__':
    do()

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

import math

print(2*math.pi*r)

Solution (Python):
import sys, math

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

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

Solution (Python):
from math import pi

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

Solution (Python):
from math import pi

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

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

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

r = int(input())

import math

print(2 * r * math.pi)

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

print(2 * math.pi * r)

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

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

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

print(2*R*math.pi)

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

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

print(pi*2*N)

Solution (Python):
import math

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

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

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

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

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

print(2 *math.pi*N)

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

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

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

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

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

Solution (Python):
import math


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


if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):
from math import gcd

from math import factorial as f

from math import ceil,floor,sqrt


import bisect
import re
import heapq


from copy import deepcopy
import itertools

from sys import exit

ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

yes = "Yes"
no = "No"

def main():
    r = ii()
    print(6.28318530717958623200*r)


main()

Solution (Python):
import math

n = int(input())

print(2*math.pi*n)

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

Solution (Python):
from math import pi

r = int(input().strip())

print(2*pi*r)

Solution (Python):

import numpy as np
r = float(input())

print(2*r*3.14159265)

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

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

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

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

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

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

if __name__ == '__main__':
    main()

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

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

print(2*r*math.pi)

Solution (Python):
import math

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

Solution (Python):
from collections import defaultdict, Counter
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):



import sys
import math

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


def resolve():
    r = int(input())
    print(2.0*math.pi*r)




if __name__ == "__main__":
    resolve()

Solution (Python):
import math
import sys
def getN():
    return int(input())


def main():
    
    R = getN()

    print(2 * R * math.pi)


    return

if __name__ == "__main__":
    main()

Solution (Python):
import math

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

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

Solution (Python):
import math
 
radius = float(input(""))
 
circumference = 2 * math.pi * radius
 
print("%f" % circumference)

Solution (Python):
import math

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

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

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

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

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

Solution (Python):
import math

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

Solution (Python):

import sys
import numpy as np

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

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

Solution (Python):
r = int(input())
print('{:.2f}'.format(2*3.141*r))

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

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

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

Solution (Python):
import math

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

Solution (Python):
from math import pi

r = int(input())

print(2*r*pi)

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

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

Solution (Python):
def input_int():
    return map(int, input().split())

def one_int():
    return int(input())

def one_str():
    return input()

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

import math

R=one_int()

print(R*2*math.pi)

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

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

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

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

print(r*2*3.14159)

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

Solution (Python):
import math

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

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

import math


print (2*math.pi*n)

Solution (Python):
from math import pi

n = int(input())

print(2 * n * pi)

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

Solution (Python):
import numpy as np

R = int(input())

r = 0

r = 2 * R * np.pi

print(r)

Solution (Python):
import math

f = float(input())

print(2 * math.pi * f)

Solution (Python):
import math

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

Solution (Python):
import math


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


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

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

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

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

Solution (Python):
import math


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


if __name__ == '__main__':
    resolve()

Solution (Python):
import math

R = int(input())

print(R * 2 * math.pi)

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

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

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

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

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

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin, log, log10, gcd
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits

def debug(*args):
    if debugmode:
        print(*args)
def input(): return sys.stdin.readline().strip()
def STR(): return input()
def INT(): return int(input())
def FLOAT(): return float(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7
dx = [0, 0, 1, -1, 1, -1, -1, 1]
dy = [1, -1, 0, 0, 1, -1, 1, -1]
debugmode = True

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

Solution (Python):

r = float(input())

print(r*6.28318530717958623200)

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

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

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

print(math.pi* 2 * r)

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

Solution (Python):
import math

n = int(input())

print(2*n*math.pi)

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

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

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

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

Solution (Python):
from math import pi

r = int(input())

print(2 * pi * r)

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

print(2 * r * 3.141592653589793238462643383279)

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

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

print(2*math.pi*K)

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

print(math.pi * R *2)

Solution (Python):
pi =3.141592653589793

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

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

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

Solution (Python):
import math

s=int(input())

print(2*s*math.pi)

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

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

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

Solution (Python):
import numpy as np

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

Solution (Python):
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
def resolve():
    R = ir()
    print(2*R*3.1415926535897)
resolve()

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

Solution (Python):
import math

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

if __name__ == '__main__':
    main()

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

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

print(2*R*3.14159265358979)

Solution (Python):
import sys
input = lambda: sys.stdin.readline().rstrip()
inp = sys.stdin.buffer.readline                                
def I(): return list(map(int,inp().split()))
from math import pi
r,=I()
print(2*pi*r)

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

Solution (Python):
import math

r = int(input())

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

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

Solution (Python):
import sys
import math

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


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


if __name__ == '__main__':
    resolve()

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

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

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

print(R*2*math.pi)

Solution (Python):
import math

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

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

print(6.283*r)

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

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

Solution (Python):

import math

R = int(input())

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

Solution (Python):
import sys
import math
sys.setrecursionlimit(10**9)

INF = 110110110
_INFL = -INF * INF

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

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

print(2*R*math.pi)

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

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

print(2*r*3.141592)

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

Solution (Python):
import math

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

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

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

Solution (Python):


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

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

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

Solution (Python):
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial
from bisect import bisect_left 
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
def pri(x): print('\n'.join(map(str, x)))

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

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

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

Solution (Python):
import math

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


if __name__ == "__main__":
    main()

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

Solution (Python):
import math

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

print(2 * R * pi)

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

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

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

Solution (Python):


R=float(input())
import math


print(R*2*math.pi)

Solution (Python):
from math import pi

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

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

Solution (Python):
import math

r = int(input())

rst = 2 * math.pi * r

print(rst)

Solution (Python):
import math

x = int(input())

print(x * 2 * math.pi)

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

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 sys
sys.setrecursionlimit(100000)

def ins(): return input().split()
def ii(): return int(input())
def iil(): return list(map(int, ins()))
def lin(): return list(input())
def iin(): return map(int, ins())

import decimal

r = ii()
pi = decimal.Decimal('3.141592653589793238462643383279')
print(pi*r*2)

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

Solution (Python):

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

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

print(str(2*r*3.14159265))

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

import math

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

Solution (Python):
import math

R = int(input())


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

Solution (Python):

import sys
input = sys.stdin.buffer.readline


from collections import defaultdict
import math

con = 10 ** 9 + 7

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


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



if __name__ == '__main__':
	main()

Solution (Python):
def main():
    import sys
    import math
    sys.setrecursionlimit(10 ** 6)
    input = sys.stdin.readline
    r = int(input())
    print(2*r*math.pi)

if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
from math import pi

r = int(input())

print(2 * r * pi)

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

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

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

Solution (Python):






import sys
input = sys.stdin.readline

import math
from collections import deque
from fractions import gcd
from functools import lru_cache






MOD = 10**9+7
INF = float('inf')






def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]


def inv(n): return pow(n, MOD-2, MOD)


kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret


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

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


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





R = inputI()

print(R*3.1415926535*2)