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

Solution (Python):
import math

if __name__ == '__main__':
    

    pi = 3.14159265358979323846
    n = int(input())
    

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

Solution (Python):
import math

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

Solution (Python):
def solve():
  r = int(input())
  print(2*r*3.1415926535)
  return 0
 
if __name__ == "__main__":
  solve()

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

import math

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

Solution (Python):
import sys
from math import ceil, floor
from collections import deque, Counter, defaultdict
from fractions import gcd
input = lambda: sys.stdin.readline().rstrip()

def eprint(s):
    sys.stderr.write('DEBUG: {}'.format(s))
    return

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

if __name__ == '__main__':
    main()

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

Solution (Python):
import math

R=int(input())

print(math.pi*2*R)

Solution (Python):
import math

N = int(input())

print(2 * N * math.pi)

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

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

print(2 * 3.14 * n)

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

Solution (Python):
import math


R = int(input())


print(R*2*math.pi)

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



if __name__ == "__main__":
    a()

Solution (Python):
import sys
sys.setrecursionlimit(10**6)
from math import floor,ceil,sqrt,factorial,log,pi
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from operator import itemgetter
from fractions import gcd
mod = 10 ** 9 + 7
inf = float('inf')
ninf = -float('inf')
 

def ii(): return int(sys.stdin.readline().rstrip()) 
def mii(): return map(int,sys.stdin.readline().rstrip().split())
def limii(): return list(mii()) 
def lin(n:int): return [ii() for _ in range(n)]
def llint(n: int): return [limii() for _ in range(n)]

def ss(): return sys.stdin.readline().rstrip() 
def mss(): return sys.stdin.readline().rstrip().split()
def limss(): return list(mss()) 
def lst(n:int): return [ss() for _ in range(n)]
def llstr(n: int): return [limss() for _ in range(n)]






n=ii()

print(2*pi*n)

Solution (Python):
import numpy as np
from collections import defaultdict
from math import gcd
import time
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines


start = time.time()

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

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

Solution (Python):
from math import pi

r = int(input())

print(2 * pi * r)

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

print(R * 2 * 3.14159)

Solution (Python):
import math

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

Solution (Python):

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

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

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

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

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

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

Solution (Python):
import math

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

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

Solution (Python):

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

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

Solution (Python):
def main():
    
    S = float(input())
    
    pi = 3.1415
    
    print(2 * pi * S)
    
main()

Solution (Python):
from math import pi

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

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

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

Solution (Python):


import math

R = int(input())

C = 2 * math.pi * R

print(C)

Solution (Python):
import math

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

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

Solution (Python):


import sys
import math


debug = False

def log(text):
    if debug:
        print(text)

def parse_input(lines_as_string = None):

    global debug
    lines = []
    if lines_as_string is None:
        debug = False
        
        
        lines.append(input())
    else:
        debug = True
        lines = [e for e in lines_as_string.split("\n")][1:-1]

    (r, ) = [int(e) for e in lines[0].split(' ')]

    return (r, )


def solve(r):

    
    return  2 * r * math.pi
    


def main():
    
    result = solve(*parse_input())
    if isinstance(result, list):
        for r in result:
            print("%s" % r, sep='')
    else:
        print("%s" % result, sep='')

if __name__ == '__main__':

    main()

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

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

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

Solution (Python):
from math import sqrt,ceil








x=3.141592653589793
n=int(input())
print(2*x*n)

Solution (Python):
import math

r = int(input())

print(2*math.pi*r)

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

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

Solution (Python):

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

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

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

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

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

Solution (Python):
import math

R = int(input())

print(R*2*math.pi)

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

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

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

Solution (Python):
import math

r = int(input())

print(math.pi * 2 * r)

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

Solution (Python):
import math

R=int(input())

print(2*R*math.pi)

Solution (Python):
import numpy as np


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


if __name__ == '__main__':
    main()

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

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

Solution (Python):


R = int(input())








print(2*R*3.14159265)

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

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

if __name__ == '__main__':
    main()

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

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

Solution (Python):
import sys, re
import math
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

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



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

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

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

R *= 2
R *= 3.14

print(R)

Solution (Python):
import math

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

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

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

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

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

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

Solution (Python):
import math

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


print(2*n*pi)

Solution (Python):

r = int(input())

ans = 2* r * 3.1415

print(ans)

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

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

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

Solution (Python):

import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue
from decimal import *


class Scanner():
    @staticmethod
    def int():
        return int(sys.stdin.readline().rstrip())

    @staticmethod
    def string():
        return sys.stdin.readline().rstrip()

    @staticmethod
    def map_int():
        return [int(x) for x in Scanner.string().split()]

    @staticmethod
    def string_list(n):
        return [Scanner.string() for i in range(n)]

    @staticmethod
    def int_list_list(n):
        return [Scanner.map_int() for i in range(n)]

    @staticmethod
    def int_cols_list(n):
        return [Scanner.int() for i in range(n)]


class Math():
    @staticmethod
    def gcd(a, b):
        if b == 0:
            return a
        return Math.gcd(b, a % b)

    @staticmethod
    def lcm(a, b):
        return (a * b) // Math.gcd(a, b)

    @staticmethod
    def divisor(n):
        res = []
        i = 1
        for i in range(1, int(n ** 0.5) + 1):
            if n % i == 0:
                res.append(i)
                if i != n // i:
                    res.append(n // i)
        return res

    @staticmethod
    def round_up(a, b):
        return -(-a // b)

    @staticmethod
    def is_prime(n):
        if n < 2:
            return False
        if n == 2:
            return True
        if n % 2 == 0:
            return False
        d = int(n ** 0.5) + 1
        for i in range(3, d + 1, 2):
            if n % i == 0:
                return False
        return True


def pop_count(x):
    x = x - ((x >> 1) & 0x5555555555555555)
    x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
    x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
    x = x + (x >> 8)
    x = x + (x >> 16)
    x = x + (x >> 32)
    return x & 0x0000007f


MOD = int(1e09) + 7
INF = int(1e15)


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


def main():
    
    solve()


if __name__ == "__main__":
    main()

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

print(2 * n * 3.1415)

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

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

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

print(float(2*3.1415926535*r))

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


ans = 2 * r * pi
print(ans)

Solution (Python):
def main():
    import sys
    input = sys.stdin.readline
    print(int(input())*3.141592653*2)

if __name__ == '__main__':
    main()

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

Solution (Python):
import math


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


if __name__ == '__main__':
    main()

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

Solution (Python):
import sys
sys.setrecursionlimit(1000000000)
import math
from math import gcd
def lcm(a, b): return a * b // gcd(a, b)
from itertools import count, permutations, chain
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7

def meg(f, ok, ng):
    while abs(ok-ng)>1:
        mid = (ok+ng)//2
        if f(mid):
            ok=mid
        else:
            ng=mid
    return ok

def get_inv(n, modp):
    return pow(n, modp-2, modp)

def factorials_list(n, modp):    
    fs = [1]
    for i in range(1, n+1):
        fs.append(fs[-1] * i % modp)
    return fs

def invs_list(n, fs, modp):     
    invs = [get_inv(fs[-1], modp)]
    for i in range(n, 1-1, -1):
        invs.append(invs[-1] * i % modp)
    invs.reverse()
    return invs

def comb(n, k, modp):
    num = 1
    for i in range(n, n-k, -1):
        num = num * i % modp
    den = 1
    for i in range(2, k+1):
        den = den * i % modp
    return num * get_inv(den, modp) % modp

def comb_from_list(n, k, modp, fs, invs):   
    return fs[n] * invs[n-k] * invs[k] % modp



class UnionFindEx:
    def __init__(self, size):
        
        self.roots = [-1] * size
    def getRootID(self, i):
        r = self.roots[i]
        if r < 0:   
            return i
        else:
            r = self.getRootID(r)
            self.roots[i] = r
            return r
    def getGroupSize(self, i):
        return -self.roots[self.getRootID(i)]
    def connect(self, i, j):
        r1, r2 = self.getRootID(i), self.getRootID(j)
        if r1 == r2:
            return False
        if self.getGroupSize(r1) < self.getGroupSize(r2):
            r1, r2 = r2, r1
        self.roots[r1] += self.roots[r2]    
        self.roots[r2] = r1
        return True

Yes = 'Yes'
No = 'No'


def main():
    print(ii()*2*3.1415926535)



main()

Solution (Python):

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

print(2*r*pi)

Solution (Python):
import sys
import math
input = sys.stdin.readline
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.141592*2)

Solution (Python):

R = int(input())


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

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

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

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

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

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

Solution (Python):

import sys
import math

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

R = ir()
answer = 2 * R * math.pi
print(answer)

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

    print(2.0 * r * 3.141592653589793238462643383)

if __name__ == '__main__':
    main()

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

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

Solution (Python):
import math

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

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

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

r = int(input())

import math

pi = math.pi

print(2 * pi * r)

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

s = 2 * r * math.pi

print(s)

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

Solution (Python):
import os
import math

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

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

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

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

Solution (Python):



import sys
import math

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

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

main()

Solution (Python):


def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    
    from itertools import combinations, permutations, accumulate, groupby, product
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    from math import floor, ceil
    import math
    

    
    

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

if __name__ == '__main__':
    main()

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

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

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

R = int(input())

print(R * 2 * math.pi)

Solution (Python):
def main():
  r = int(input())
  
  return (r+r) * 3.14
  
if __name__ == '__main__':
  print(main())

Solution (Python):
import numpy

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

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

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

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

print(2*R*pi)

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

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

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

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

from math import pi

print (2 * R * pi)

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

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

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

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

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

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

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

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

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

Solution (Python):
from sys import stdin
from sys import setrecursionlimit
from math import pi
setrecursionlimit(10 ** 7)

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

print(2*pi*n)

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

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

Solution (Python):

r = int(input())

print(2*r*3.14)

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

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

Solution (Python):
R = int(input())
import math
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.14)

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

print(2*r*pi)

Solution (Python):
import math

r= int(input())

print(2*r*math.pi)

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

Solution (Python):

import math
r = int(input())

print(2 * r * math.pi)

Solution (Python):

import math

MOD = 10**9
def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)
    return divisors

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

Solution (Python):
from math import pi

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

Solution (Python):

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

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*3.14159265*2)

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

Solution (Python):
from math import pi

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

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

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

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

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

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



print(math.pi*2*r)

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

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

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

Solution (Python):
import math

r = int(input())

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

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

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

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())
p = math.pi
print('{}'.format(2*p*r))

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

Solution (Python):
import math

r = int(input())

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

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


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

Solution (Python):
import math

r = int(input())

print(math.pi * r * 2)

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

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

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

print(2*R*p)

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

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

Solution (Python):
def s3(n):return [[input().split()] for _ in range(n)]
def n0():return int(input())
def n1():return [int(x) for x in input().split()]
def n2(n):return [int(input()) for _ in range(n)]
def n3(n):return [[int(x) for x in input().split()] for _ in range(n)]

r=n0()

print(2*r*3.141592)

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

print(res)

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

print(2*R*3.1415)

Solution (Python):
from sys import stdin


def main():
    input = lambda: stdin.readline()[:-1]
    R = int(input())
    print(2 * R * 3.141592)


main()

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

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

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

Solution (Python):
import math

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

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

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

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

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

T = N * 2 * math.pi

print(T)

Solution (Python):
import math

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

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

print(r * 2 * 3.14)

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

print(2*R*3.14159265)

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


R = int(readline())

print(2 * math.pi * R)

Solution (Python):
import sys
from collections import *
import heapq
import math
from math import gcd
import bisect
import copy
from itertools import permutations,accumulate,combinations,product
def input():
    return sys.stdin.readline()[:-1]
def ruiseki(lst):
    return [0]+list(accumulate(lst))
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]
direction=[[1,0],[0,1],[-1,0],[0,-1]]

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

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

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

Solution (Python):
import math

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

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

Solution (Python):
import math

r = int(input())

ans = 2*r*math.pi

print(ans)

Solution (Python):
import math

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

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

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

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

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

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





print(2*r*3.14159265)

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

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

Solution (Python):
import math

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

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

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

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

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

Answer = R*2*3.14159265359

print(Answer)

Solution (Python):

''':'
docker run --rm -it -v $(cd $(dirname $0) && pwd):/vo:ro pypy:3-2.4.0 \
   /bin/bash -c "pypy3 /vo/$(basename $0) < /vo/input.txt"
exit $?
'''
import sys
import math


def _i(): return int(sys.stdin.readline().strip())


def main():
    return 2 * _i() * math.pi


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

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

Solution (Python):
import math

r = int(input())

print(2 * math.pi * r)

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





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

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

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

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

print(math.pi * 2 * r)

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

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

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

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

Solution (Python):
from math import pi

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

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

Solution (Python):
import math

r = int(input())

print(2*r*math.pi)