#pragma GCC optimize("Ofast,unroll-loops")

#include <map>
#include <set>
#include <array>
#include <cmath>
#include <deque>
#include <bitset>
#include <random>
#include <string>
#include <vector>
#include <cassert>
#include <complex>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

using namespace std;

struct Point{
    long long x, y;
    Point(long long x, long long y): x(x), y(y) {}
    Point(): x(0), y(0) {}
};

Point operator+(const Point& a, const Point& b) {
    return Point(a.x + b.x, a.y + b.y);
}

Point operator-(const Point& a, const Point& b) {
    return Point(a.x - b.x, a.y - b.y);
}

long long cross(const Point& a, const Point& b) {
    return a.x * b.y - a.y * b.x;
}

long long square_len(const Point& P) {
    return P.x * P.x + P.y * P.y;
}

const double EPS = 1e-8;

const int MAXN = 200200;

vector<int> G[MAXN];

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    
    int n, k;
    cin >> n >> k;
    vector<Point> A(n);
    for (int i = 0; i < n; ++i)
        cin >> A[i].x >> A[i].y;
    random_shuffle(A.begin(), A.end());

    auto get_triangle_sz = [](const Point& A, const Point& B, const Point& C) {
        return max(square_len(A - B), max(square_len(B - C), square_len(C - A)));
    };

    long long min_d = get_triangle_sz(A[0], A[1], A[2]);
    int total = 0;
    double sz = sqrt(min_d) + EPS;
    vector<int> near;
    map<pair<int, int>, vector<int>> points;
    for (int i = 0; i < n; ++i) {
        int cur_x = floor(A[i].x / sz), cur_y = floor(A[i].y / sz);
        for (int dx = -1; dx <= 1; ++dx) {
            for (int dy = -1; dy <= 1; ++dy) {
                auto tmp = points.find(make_pair(cur_x + dx, cur_y + dy));
                if (tmp != points.end()) {
                    for (int j : tmp->second)
                        near.emplace_back(j);
                }
            }
        }
        long long bbest = min_d;
        int best_cnt = 0;
        for (int j = 0; j < near.size(); ++j) {
            for (int k = j + 1; k < near.size(); ++k) {
                long long cur = get_triangle_sz(A[i], A[near[j]], A[near[k]]);
                if (cur == bbest) {
                    ++best_cnt;
                } else if (cur < bbest) {
                    bbest = cur;
                    best_cnt = 1;
                }
            }
        }
        near.clear();
        if (bbest < min_d) {
            min_d = bbest;
            total = best_cnt;
            sz = sqrt(min_d) + EPS;
            points.clear();
            for (int j = 0; j <= i; ++j) {
                int cur_x = floor(A[j].x / sz), cur_y = floor(A[j].y / sz);
                points[make_pair(cur_x, cur_y)].emplace_back(j);
            }
        } else {
            total += best_cnt;
            points[make_pair(cur_x, cur_y)].emplace_back(i);
        }
    }
    vector<pair<int, int>> edges;
    for (int i = 0; i < n; ++i) {
        int cur_x = floor(A[i].x / sz), cur_y = floor(A[i].y / sz);
        for (int dx = -1; dx <= 1; ++dx) {
            for (int dy = -1; dy <= 1; ++dy) {
                auto tmp = points.find(make_pair(cur_x + dx, cur_y + dy));
                if (tmp != points.end()) {
                    for (int j : tmp->second) {
                        if (j < i && square_len(A[i] - A[j]) < min_d)
                            edges.emplace_back(j, i);
                    }
                }
            }
        }
    }

    long long ans_d = min_d;
    int ans_len = 3;
    long long ans_cnt = total;

    sort(edges.begin(), edges.end(), [&A](const pair<int, int>& a, const pair<int, int>& b) {
        return square_len(A[a.first] - A[a.second]) < square_len(A[b.first] - A[b.second]);
    });
    int m = edges.size();

    vector<vector<pair<int, int>>> all_edges(n);
    for (int i = 0; i < m; ++i) {
        all_edges[edges[i].first].emplace_back(edges[i].second, i);
        all_edges[edges[i].second].emplace_back(edges[i].first, i);   
    }

    int max_tier = k;

    vector<pair<int, int>> dps(m);
    // len, cnt
    // (0, 0) - NONE
    vector<int> dist1(n);
    vector<int> path_cnt1(n);
    vector<int> timer_used1(n, -1);
    vector<int> dist2(n);
    vector<int> path_cnt2(n);
    vector<int> timer_used2(n, -1);
    deque<int> Q;
    vector<int> interesting;
    long long mx_len = ans_d;
    for (int i = 0; i < m; ++i) {
        auto [u, v] = edges[i];
        long long cur_len = square_len(A[u] - A[v]);
        if (cur_len > mx_len)
            break;
        if (dps[i].second) {
            mx_len = cur_len;
            if (cur_len < ans_d) {
                ans_d = cur_len;
                ans_len = dps[i].first;
                max_tier = dps[i].first;
                ans_cnt = dps[i].second;
            } else if (cur_len == ans_d) {
                if (ans_len > dps[i].first) {
                    ans_len = dps[i].first;
                    max_tier = dps[i].first;
                    ans_cnt = dps[i].second;
                } else if (ans_len == dps[i].first) {
                    ans_cnt += dps[i].second;
                }
            }
        }
        G[u].emplace_back(v);
        G[v].emplace_back(u);

        timer_used1[u] = i;
        Q.emplace_back(u);
        dist1[u] = 0;
        path_cnt1[u] = 1;
        while (!Q.empty()) {
            int cur = Q.front();
            interesting.emplace_back(cur);
            Q.pop_front();
            if (dist1[cur] == max_tier - 2)
                continue;
            for (int x : G[cur]) {
                if (timer_used1[x] != i) {
                    timer_used1[x] = i;
                    dist1[x] = dist1[cur] + 1;
                    path_cnt1[x] = path_cnt1[cur];
                    Q.emplace_back(x);
                } else if (dist1[x] == dist1[cur] + 1) {
                    path_cnt1[x] += path_cnt1[cur];
                }
            }
        }

        timer_used2[v] = i;
        Q.emplace_back(v);
        dist2[v] = 0;
        path_cnt2[v] = 1;
        while (!Q.empty()) {
            int cur = Q.front();
            Q.pop_front();
            if (dist2[cur] == max_tier - 2)
                continue;
            for (int x : G[cur]) {
                if (timer_used2[x] != i) {
                    timer_used2[x] = i;
                    dist2[x] = dist2[cur] + 1;
                    path_cnt2[x] = path_cnt2[cur];
                    Q.emplace_back(x);
                } else if (dist2[x] == dist2[cur] + 1) {
                    path_cnt2[x] += path_cnt2[cur];
                }
            }
        }

        sort(interesting.begin(), interesting.end());
        interesting.resize(unique(interesting.begin(), interesting.end()) - interesting.begin());
        for (int a : interesting) {
            for (auto [b, j] : all_edges[a]) {
                if (j <= i)
                    continue;
                if (timer_used2[b] == i) {
                    if (dist1[a] + dist2[b] <= k - 1) {
                        pair<int, int> cur(dist1[a] + dist2[b] + 2, path_cnt1[a] * path_cnt2[b]);
                        //cout << "trying " << a << ' ' << b << ' ' << cur.first << ' ' << cur.second << '\n';
                        if (dps[j].first == 0) {
                            dps[j] = cur;
                        } else if (dps[j].first > cur.first) {
                            dps[j] = cur;
                        } else if (dps[j].first == cur.first)
                            dps[j].second += cur.second;
                    }
                }
            }
        }
        interesting.clear();
    }

    cout << ans_d << '\n' << ans_len << '\n' << ans_cnt * 2 * ans_len << '\n';
    return 0;
}