#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int weight;
    int trust;
} Traveler;

typedef struct {
    Traveler *arr;
    int size;
    int capacity;
} MinHeap;

// Comparison: lower trust first, if tie → heavier weight first
int compare(Traveler a, Traveler b) {
    if (a.trust == b.trust)
        return b.weight - a.weight;
    return a.trust - b.trust;
}

// Swap function
void swap(Traveler *a, Traveler *b) {
    Traveler temp = *a;
    *a = *b;
    *b = temp;
}

// Heap functions
MinHeap* createHeap(int capacity) {
    MinHeap heap = (MinHeap)malloc(sizeof(MinHeap*));
    heap->arr = (Traveler*)malloc(sizeof(Traveler) * (capacity + 1));
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

void heapifyUp(MinHeap *heap, int idx) {
    while (idx > 1 && compare(heap->arr[idx], heap->arr[idx/2]) < 0) {
        swap(&heap->arr[idx], &heap->arr[idx/2]);
        idx /= 2;
    }
}

void heapifyDown(MinHeap *heap, int idx) {
    int smallest = idx;
    int left = 2*idx, right = 2*idx+1;

    if (left <= heap->size && compare(heap->arr[left], heap->arr[smallest]) < 0)
        smallest = left;
    if (right <= heap->size && compare(heap->arr[right], heap->arr[smallest]) < 0)
        smallest = right;

    if (smallest != idx) {
        swap(&heap->arr[idx], &heap->arr[smallest]);
        heapifyDown(heap, smallest);
    }
}

void push(MinHeap *heap, Traveler t) {
    if (heap->size < heap->capacity) {
        heap->arr[++heap->size] = t;
        heapifyUp(heap, heap->size);
    } else {
        // Replace root if new traveler is better
        if (compare(t, heap->arr[1]) > 0) {
            heap->arr[1] = t;
            heapifyDown(heap, 1);
        }
    }
}

// Peek lowest-trust traveler
Traveler peek(MinHeap *heap) {
    return heap->arr[1];
}

int main() {
    int N, M;
    if (scanf("%d %d", &N, &M) != 2) {
        printf("Invalid input\n");
        return 0;
    }

    if (N <= 0 || M <= 0 || M > N) {
        printf("Invalid input\n");
        return 0;
    }

    MinHeap *heap = createHeap(M);

    for (int i = 0; i < N; i++) {
        Traveler t;
        if (scanf("%d %d", &t.weight, &t.trust) != 2 || t.weight <= 0 || t.trust <= 0) {
            printf("Invalid input\n");
            return 0;
        }

        push(heap, t);

        // Print only after bridge is full
        if (heap->size == M) {
            Traveler lowest = peek(heap);
            printf("%d %d\n", lowest.weight, lowest.trust);
        }
    }

    return 0;
}