#include<bits/stdc++.h>

using namespace std;

vector<vector<double>> graph;
vector<pair<int, int>> mapp;

double way(pair<int, int> a, pair<int, int> b) {
    int x1 = a.first;
    int y1 = a.second;
    int x2 = b.first;
    int y2 = b.second;
    double w = sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
    return w;
}

double Prim() {
    vector<double> min_e(graph.size());
    vector<int> visited(graph.size());
    vector<int> parent(graph.size());
    int n = graph.size();
    for (int i = 0; i != n; ++i) {min_e[i] = 100000000;}
    for (int i = 0; i != n; ++i) {parent[i] = -1;}
    for (int i = 0; i != n; ++i) {visited[i] = 0;}
    min_e[0] = 0;
    double sum = 0;
    for (size_t i = 0; i != graph.size(); ++i) {
        int v = -1;
        for (size_t j = 0; j != graph.size(); ++j) {
            if (visited[j] == 0 && (v == -1 || min_e[j] < min_e[v])) {
                v = j;
            }
        }
        visited[v] = 1;
        if (parent[v] != -1) {
            int p = parent[v];
            sum = sum + graph[v][p];
        }
        for (size_t k = 0; k != graph.size(); ++k) {
            if (graph[v][k] < min_e[k]) {
                min_e[k] = graph[v][k];
                parent[k] = v;
            }
        }
    }
    return sum;
}

void add_gr(pair<int, int> a) {
    for (size_t i = 0; i != graph.size(); ++i) {
        graph[i].push_back(way(a, mapp[i]));
    }
    vector<double> meow;
    for (size_t j = 0; j != graph[0].size(); ++j) {
        meow.push_back(way(mapp[j], a));
    }
    graph.push_back(meow);
    mapp.push_back(a);
}

void delete_gr(pair<int, int> a) {
    for (size_t i = 0; i != graph.size(); ++i) {
        graph[i].pop_back();
    }
    graph.pop_back();
    mapp.pop_back();
}

int main() {
    int n;
    cin >> n;
    int K;
    cin >> K; //  роутеры
    ::graph.resize(n);
    for (size_t i = 0; i != n; ++i) {
        for (size_t j = 0; j != n; ++j) {
            graph[i].push_back(0);
        }
    }

    vector<pair<int, int>> conn;
    int max_x=0, min_x=0, max_y=0, min_y=0;
    for (size_t i = 0; i != n; ++i) {
        int x, y;
        cin >> x >> y;
        pair<int, int> a(x, y);
        if (x < min_x) {min_x=x;}
        if (x > max_x) {max_x=x;}
        if (y < min_y) {min_y=y;}
        if (y > max_y) {max_y=y;}
        mapp.push_back(a);
    }
    for (size_t i = 0; i != n; ++i) {
        for (size_t j = 0; j != n; ++j) {
            graph[i][j] = way(mapp[i], mapp[j]);
        }
    }
    double min_connection = Prim();
    int step_x = 1;
    int step_y = 1;
    int side_x = max_x - min_x;
    int side_y = max_y - min_y;

    if (side_x >= 500 && side_x < 1000) {
        step_x = 15;
    } else if (side_x >= 1000 && side_x < 5000) {
        step_x = 20;
    } else if (side_x >= 5000 && side_x < 7500) {
        step_x = 50;
    } else if (side_x >= 7500) {
        step_x = 70;}

    if (side_y >= 500 && side_y < 1000) {
        step_x = 15;
    } else if (side_y >= 1000 && side_y < 5000) {
        step_x = 20;
    } else if (side_y >= 5000 && side_y < 7500) {
        step_x = 50;
    } else if (side_y >= 7500) {
        step_x = 70;}

    for (size_t k = 0; k != K; ++k) {
        int new_x=-1, new_y=-1;
        for (size_t x = 0; x != max_x; x = step_x + x) {
            for (size_t y = 0; y != max_y; y = step_y + y) {
                pair<int, int> p(x, y);
                add_gr(p);
                double new_connection = Prim();

                if (min_connection > new_connection) {
                    min_connection = new_connection;
                    new_x = x;
                    new_y = y;
                }
                delete_gr(p);
            }
        }
        if (new_x != -1) {
            pair<int, int> p = make_pair(new_x, new_y);
            conn.push_back(p);
            add_gr(p);
        }
    }
    cout << conn.size() << '\n';
    for (size_t i = 0; i != conn.size(); ++i) {
        cout << conn[i].first << ' ' << conn[i].second << '\n';
    }
}