import java.util.Arrays;

public class MaxPointHeap {

	private int capacity = 10;
	int size = 0;

	private Point[] items = new Point[capacity];

	public Point[] getHeapElement() {
		return Arrays.copyOf(items, size);
	}

	private int getLeftChildIndex(int parentIndex) {
		return 2 * parentIndex + 1;
	}

	private int getRightChildIndex(int parentIndex) {
		return 2 * parentIndex + 2;
	}

	private int getParentIndex(int childIndex) {
		return (childIndex - 1) / 2;
	}

	private boolean hasLeftChild(int index) {
		return getLeftChildIndex(index) < size;
	}

	private boolean hasRightChild(int index) {
		return getRightChildIndex(index) < size;
	}

	private boolean hasParent(int index) {
		return getParentIndex(index) < size;
	}

	private Point leftChild(int index) {
		return items[getLeftChildIndex(index)];
	}

	private Point rightChild(int index) {
		return items[getRightChildIndex(index)];
	}

	private Point parent(int index) {
		return items[getParentIndex(index)];
	}

	private void swap(int indexOne, int indexTwo) {
		Point temp = items[indexOne];
		items[indexOne] = items[indexTwo];
		items[indexTwo] = temp;
	}

	private void ensureExtraCapacity() {
		if (size == capacity) {
			items = Arrays.copyOf(items, capacity * 2);
			capacity *= 2;
		}
	}

	public Point peek() {
		if (size == 0)
			throw new IllegalStateException();
		return items[0];
	}

	public void delete(Point point) {
		if (size == 0)
			throw new IllegalStateException();
		items[0] = point;
		heapifyDown();
	}

	public void add(Point item) {
		ensureExtraCapacity();
		items[size] = item;
		size++;
		heapifyUp();
	}

	public void heapifyUp() {
		int index = size - 1;
		while (hasParent(index) && parent(index).getDistance() < items[index].getDistance()) {
			swap(getParentIndex(index), index);
			index = getParentIndex(index);
		}
	}

	public void heapifyDown() {
		int index = 0;
		while (hasLeftChild(index)) {
			int smallerChildIndex = getLeftChildIndex(index);
			if (hasRightChild(index) && rightChild(index).getDistance() > leftChild(index).getDistance())
				smallerChildIndex = getRightChildIndex(index);
			if (items[index].getDistance() > items[smallerChildIndex].getDistance())
				break;
			else
				swap(index, smallerChildIndex);
			index = smallerChildIndex;
		}
	}

	public static void main(String[] args) {
		Point[] points = new Point[9];
		points[0] = new Point(3, 3);
		points[1] = new Point(2, 2);
		points[2] = new Point(4, 4);
		points[3] = new Point(1, 1);
		points[4] = new Point(12, 1);
		points[5] = new Point(0, 0);
		points[6] = new Point(2, 3);
		points[7] = new Point(-5, 2);
		points[8] = new Point(-1, -1);
		int k = 4;
		MaxPointHeap pointHeap = new MaxPointHeap();

		for (int i = 0; i < k; i++) {
			pointHeap.add(points[i]);
		}
		for (int i = k; i < points.length; i++) {
			if (points[i].getDistance() < pointHeap.peek().getDistance()) {
				pointHeap.delete(points[i]);
			}
		}
		for (int i = 0; i < pointHeap.getHeapElement().length; i++) {
			Point p = pointHeap.getHeapElement()[i];
			System.out.println("(" + p.getX() + ", " + p.getY() + ")");
		}
	}

}

class Point {
	private int x;
	private int y;

	public Point(int x, int y) {
		this.x = x;
		this.y = y;
	}

	// In this case, to optimize we dont need to calculate square root.
	public long getDistance() {
		return x * x + y * y;
	}

	public int getX() {
		return x;
	}

	public int getY() {
		return y;
	}

}