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

radius = int(input())

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

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

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

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

Solution (Python):
import math

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

Solution (Python):
def solution():
    return 1

def main():
    r = int(input())
    print(2*3.14128*r)
        
   
if __name__ == "__main__":
    main()

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

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

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

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

pi = 3.14159265

print(2 * pi * R)

Solution (Python):
import numpy as np

r = int(input())

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

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

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

print(inp*2*math.pi)

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

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

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

print(2*r*math.pi)

Solution (Python):
import math

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

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

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

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

Solution (Python):
import math

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

Solution (Python):
import math
def main():
    r = int(input())
    print(2 * r * math.pi)
if __name__ == '__main__':
    main()

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

Solution (Python):
import sys
import math

from collections import defaultdict
from collections import deque
def load(vtype=int):
    return vtype(input().strip())
def load_list(seplator=" ", vtype=int):
    return [vtype(v) for v in input().strip().split(seplator)]
def exit():
    import sys
    sys.exit(0)
def perm_sub(li, used):
    if len(li) == len(used):
        return [deque()]
    k = []
    for i in range(len(li)):
        if i in used:
            continue
        used.add(i)
        sub_list = perm_sub(li, used)
        for sub in sub_list:
            sub.appendleft(li[i])
        k.extend(sub_list)
        used.discard(i)
    return k
def perm_li(li):
    return perm_sub(li, set())
def perm_n(n):
    return perm_sub(list(range(n)), set())
def join_i(li, sep=""):
    return sep.join([str(e) for e in li])
def li2n(li):
    n, base = 0, 1
    for i in range(len(li)-1, -1, -1):
        n += li[i] * base
        base *= 10
    return n
def sli2ili(li):
    return [int(s) for s in li] 
def prime_list(n):
    li = [i for i in range(2, n+1)]
    for i in range(len(li)):
        if li[i] >= int(math.sqrt(n)):
            break
        if li[i] == -1:
            continue
        for j in range(i+1, len(li)):
            if li[j] % li[i] == 0:
                li[j] = -1
    return [n for n in li if n != -1]
def gcd(a, b):
    a, b = max(a, b), min(a, b)
    while True:
        r = a % b
        if r == 0: return b
        a, b = b, r
def lcm(a, b):
    return int(a * b / gcd(a,b))
def all_subset(li):
    s = []
    n = len(li)
    for bit in range(0, (1<<(n+1))):
        ss = set()
        for i in range(0, n):
            if (bit & (1 << i)):
                ss.add(li[i])
        s.append(ss)
    return s
def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n-1)
def mCn(m, n):
    def factorial_ntimes(m, n):
        r = 1
        while n:
            r *= m
            m -= 1
            n -= 1
        return r
    return int(factorial_ntimes(m, n) / factorial(n))

r = load()

print(2 * r * math.pi)

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

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

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

Solution (Python):
import collections
import sys
import numpy as np
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
MOD = 10**9+7
import itertools
import math

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

Solution (Python):
from math import 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())
print(2*R*3.1415926535)

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
import math

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

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

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

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

Solution (Python):
import sys
import heapq, math
from itertools import zip_longest, permutations, combinations, combinations_with_replacement
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache
from copy import deepcopy

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

Solution (Python):
import sys

stdin = sys.stdin

ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))

r = ni()
pi = 3.141592
print(2*r*pi)

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

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

Solution (Python):



import math


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


if __name__ == '__main__':
    main()

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


if __name__ == '__main__':
    main()

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

print(r * 2 * math.pi)

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

print(n)

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

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

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

Solution (Python):

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

@author: black
"""


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

print(2*pi*R)

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

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

Solution (Python):

import sys
from collections import Counter
from itertools import permutations, combinations
from fractions import gcd
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
r = int(input())

print(2*r*math.pi)

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

import math

print(2*math.pi*r)

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

Solution (Python):
import math

R = int(input())

print(math.pi * R * 2)

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 *
from copy import *
from heapq import *
from string import *				
from random import *				
from bisect import *				
from sys import stdin				
from sys import maxsize
from operator import *				
from itertools import *
from collections import Counter		
from collections import defaultdict 

'''

'''

def solve(l):
	n = len(l)
	

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

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

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

Solution (Python):
import math

r = int(input())

print(2*r*math.pi)

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

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

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

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

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

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

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

    print(2.0 * r * 3.141592653589793238462643383)

if __name__ == '__main__':
    main()

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

print(r*2*3.14)

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 bisect,collections,copy,heapq,itertools,math,operator,string
def I(): return int(input())
def S(): return input()
def LI(): return list(map(int,input().split()))
def LS(): return list(input().split())

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

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

Solution (Python):
import math

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

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

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

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

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

Solution (Python):
import math

R = int(input())

print(R * math.pi * 2)

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):
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*3.14159*R)

Solution (Python):
import sys,os
from collections import defaultdict, deque
from math import ceil, floor
if sys.version_info[1] >= 5:
    from math import gcd
else:
    from fractions import gcd
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = (lambda *something: print(*something)) if 'TERM_PROGRAM' in os.environ else lambda *x: 0
def main(given=sys.stdin.readline):
    input = lambda: given().rstrip()
    LMIIS = lambda: list(map(int,input().split()))
    II = lambda: int(input())
    MOD = 10**9+7

    R = II()
    from math import pi
    print(R*2*pi)

if __name__ == '__main__':
    main()

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

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

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

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

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

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

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

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

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

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

print(ans)

Solution (Python):
import sys

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip() 

def main():
    r = ni()
    print(r*2*3.1415926535897932384626433832795028)
    
    return


if __name__ == '__main__':
    main()

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

print(n*3.14159265358979*2)

Solution (Python):

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

Solution (Python):
from math import pi

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

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

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

Solution (Python):
import math

r=float(input())

L=2*math.pi*r

print(L)

Solution (Python):

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

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

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

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

Solution (Python):
import math

r = int(input())

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

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

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

c = 2 * pi * r
print(c)

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

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

Solution (Python):

from __future__ import division, print_function

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




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

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

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

Solution (Python):


from queue import Queue
from queue import LifoQueue as Stack
from math import sqrt, floor, ceil, log2, pi
from fractions import gcd
from itertools import permutations, combinations
from operator import itemgetter
from functools import cmp_to_key


INF=1001001001
__MOD__=(10**9)+7
yn = 'YNeos'
judge = False
cnt = 0
ans = None


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

def intinput():
    return int(input())

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

def lineinputs(func=intinput):
    datas = []
    while True:
        try:
            datas.append(func())
        except EOFError:
            break
    return datas

class ModInt():
    def __init__(self, x):
        self.__x = (x % __MOD__)
    def __add__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x + other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x + other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __sub__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x - other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x - other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __mul__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x * other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x * other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __truediv__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x * other.__modinv())%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x * other.__modinv())%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __pow__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__(pow(self.__x, other.__x, __MOD__)))
        elif type(other) == ModInt:
            return self.__class__(pow(self.__x, other.__x, __MOD__))
        else:
            raise Exception("Not Int or Not ModInt")
    def __modinv(self, m=__MOD__):
        a = self.__x
        if a == 0:
            raise ZeroDivisionError()
        if gcd(a, m) != 1:
            raise Exception("%sの逆数は求まりません。" % a)
        b, u, v = m, 1, 0
        while b != 0:
            t = a//b;
            a -= t*b
            a, b = b, a
            u -= t * v
            u, v = v, u
        u %= m
        if u < 0:
            u += m
        return u
    def __int__(self):
        return self.__x



if __name__ == '__main__':
    N = intinput()

    
    print(2*N*pi)

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

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

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

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

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

Solution (Python):
import numpy as np

r = int(input())

print(r * 2 * np.pi)

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

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

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

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

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

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

Solution (Python):



def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**6)
    

    def dump(*args):
        sys.stderr.write(str(args))

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


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 math

R = int(input())

ans = 2 * R * math.pi

print(ans)

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

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

import math

print(2*R*math.pi)

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

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

if __name__ == '__main__':
    main()

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

Solution (Python):
import math

r = int(input())

print(2 * math.pi * r)

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

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

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

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

Solution (Python):
INT_MAX=10**18+7
MOD=10**9+7
def INPUT():return list(int(i) for i in input().split())
def LIST_1D_ARRAY(n):return [0 for _ in range(n)]
def LIST_2D_ARRAY(m,n):return [[0 for _ in range(n)]for _ in range(m)]

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

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

if __name__ == "__main__":
    main()

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

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

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

print(decimal.Decimal(2) * decimal.Decimal(n) * decimal.Decimal(math.pi))

Solution (Python):
import math

r = int(input())

print(math.pi * 2 * r)

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

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

Solution (Python):
def Int():
    return int(input())
def Ints():
    return map(int,input().split())
def IntList():
    return list(Ints())
def IntMat(N):
    return [IntList() for i in range(N)]

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

Solution (Python):



import math

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

    print(2*R*math.pi)


if __name__ == '__main__':
    main()

Solution (Python):
import math


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

print(R * 2 * 3.141592653589793238462643383279)

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

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

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

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

import math

print(2*n*math.pi)

Solution (Python):

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

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

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

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

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

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

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

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

Solution (Python):
import math

R = int(input())

print(2*R*math.pi)

Solution (Python):

N=int(input())



print(2*N*3.141)

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

print(2*R*3.14)

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

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


if __name__ == '__main__':
    main()

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

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

Solution (Python):
from math import 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())
print(r*2*3.141592653)

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


print(2*r*pi)

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

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



a=int(input())

print(a*2*3.1415926535)

Solution (Python):
import sys,math,copy,queue,itertools,bisect
sys.setrecursionlimit(10**7)
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
_LI = lambda : [int(x)-1 for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())

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

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

Solution (Python):
import sys
import math

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

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

Solution (Python):
import math

pi = math.pi

R = int(input())

print(2*R*pi)

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

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

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

print(2*math.pi*R)

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

import collections
from collections import deque
from collections import Counter
import queue
import copy
import bisect
import heapq
import itertools










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

print(ans)

Solution (Python):

import sys
sys.setrecursionlimit(10**8)
INF = float("inf")
import math

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

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