# Arup Guha
# 4/10/2025
# Solution to Farmer John's Forest
# Using converted Convex Hull Code from Java to Python for COP 4516

import math

''' Convex Hull Code Below '''

class pt:

    # Static variables for class.
    refX = 0
    refY = 0

    # Basic constructor.
    def __init__(self, myx, myy):
        self.x = myx
        self.y = myy

    # Returns a vector from self to other as a pt.
    def getVect(self, other):
        return pt(other.x-self.x, other.y-self.y)

    # Gets the distance from self to other.
    def dist(self, other):
        return ((other.x-self.x)*(other.x-self.x) + (other.y-self.y)*(other.y-self.y))**.5

    # Returns the cross product magnitude of the vectors self and other.
    def crossProductMag(self, other):
        return self.x*other.y - other.x*self.y

    # Returns if [self, midP, nextP] is a right turn or not (true if it is, false if not)
    def isRightTurn(self, midP, nextP):
        v1 = self.getVect(midP)
        v2 = self.getVect(nextP)
        return v1.crossProductMag(v2) >= 0

    # Returns true if this point is 0.
    def isZero(self):
        return self.x == 0 and self.y == 0

    # For comparison from references point.
    def __lt__(self, other):

        # Set reference point and get vectors to both.
        myRef = pt(pt.refX, pt.refY)
        v1 = myRef.getVect(self)
        v2 = myRef.getVect(other)

        # Get this out of the way.
        if v1.isZero():
            return True
        if v2.isZero():
            return False

        # We just care about this magnitude.
        if v1.crossProductMag(v2) != 0:
            return v1.crossProductMag(v2) > 0

        # For tie cases.
        if myRef.dist(v1) < myRef.dist(v2):
            return False
        return True

# Returns the perimeter of the convex hull of points stored in pts.
def grahamScan(pts):

    # Sort by reference point and start algorithm.
    pts.sort()

    # First 2 pts in stack.
    mys = []
    mys.append(pts[0])
    mys.append(pts[1])

    # Go through rest.
    for i in range(2, len(pts)):

        # Set up last turn ending at pts[i].
        cur = pts[i]
        mid = mys.pop()
        prev = mys.pop()

        # While this is a left turn, get rid of mid and replace from stack.
        while not prev.isRightTurn(mid, cur):
            mid = prev
            prev = mys.pop()

        # Push back last right turn in convex hull.
        mys.append(prev)
        mys.append(mid)
        mys.append(cur)

    # Form the polygon that is the convex hull.
    poly = [pts[0]]
    while len(mys) > 0:
        poly.append(mys.pop())

    # Ta da!
    return poly

''' End of Convex Hull Code '''

# Returns the area of the polygon stored in poly, assumes pts in order.
def getArea(poly):
    res = 0
    for i in range(len(poly)):
        j = (i+1)%len(poly)
        res += (poly[i].x*poly[j].y-poly[j].x*poly[i].y)
    return abs(res)/2

# Returns the distance between pt1 and pt2, assumes both are in the same
# number of dimensions.
def dist(pt1, pt2):
    return ((pt1.x-pt2.x)*(pt1.x-pt2.x) + (pt1.y-pt2.y)*(pt1.y-pt2.y))**.5

# Returns the perimeter of the polygon stored in poly, assumes pts in order.
def getPerimeter(poly):
    res = 0
    for i in range(len(poly)):
        j = (i+1)%len(poly)
        res += dist(poly[i], poly[j])
    return res

def main():

    # Get # of pts and what is really the radius of a circle.
    toks = input().split()
    n = int(toks[0])
    r = int(toks[1])

    # Get pts.
    pts = []
    for i in range(n):
        tmp = [int(x) for x in input().split()]
        pts.append(pt(tmp[0], tmp[1]))

    # Just inlining this instead of making a separate function.
    minI = 0
    for i in range(1, n):

        # Get min y and of those min x.
        if pts[i].y < pts[minI].y or (pts[i].y == pts[minI].y and pts[i].x < pts[minI].x):
            minI = i

    # Set up reference point and call the Graham Scan!
    pt.refX = pts[minI].x
    pt.refY = pts[minI].y

    # Get the polygon.
    poly = grahamScan(pts)

    # The added perimeter is one full circle of radius r.
    pPoly = getPerimeter(poly)

    # The area is made of three parts, the original polygon, rectangles with width r
    # and sum of lengths equal to the perimeter of the polygon and the curved parts which
    # turn out to have the area of one circle of radius r.
    area = getArea(poly) + pPoly*r +  math.pi*r*r

    # Here we add the polygon perimeter to the perimeter of one circle with radius r.
    perimeter = pPoly + 2*math.pi*r

    # Ta da!
    print("{:.2f}".format(perimeter), end=" ")
    print("{:.2f}".format(area), end=" ")

# Run it.
main()