import java.util.Scanner;

public class Program {
    public static void main(String[] args) {
        Test.test2();
  /*      BinaryHeap<Integer, String> heap = new BinaryHeap<Integer, String>();
        try (Scanner in = new Scanner(System.in)) {
            Integer number = Integer.parseInt(in.next());

            for (int i = 0; i < number; i++) {
                String command = in.next();
                if (command.equals("ADD")) {
                    String value = in.next();
                    Integer key = Integer.parseInt(String.valueOf(in.nextInt()));
                    heap.insert(key, value);
                } else if (command.equals("PRINT_MIN")) {
                    System.out.println(heap.extractMin());
                }
            }
        }*/

    }
}

class Test {
    public static void test1(int n) {
        BinaryHeap<Integer, Integer> heap = new BinaryHeap<Integer, Integer>();
        for (int i = 0; i < n; i++) {
            int k = (i + 53) % 3;
            System.out.println(k);
            heap.insert(new Integer(k), new Integer(k));
        }
        int a = 9;
    }

    public static void test2()
    {
        BinaryHeap<Integer, Integer> heap = new BinaryHeap<Integer, Integer>();
        int k = 13;
        heap.insert(new Integer(k), new Integer(k));
      /*  k = 21;
        heap.insert(new Integer(k), new Integer(k));
        k = 13;
        heap.insert(new Integer(k), new Integer(k +2));
        k = 3;
        heap.insert(new Integer(k), new Integer(k));
        heap.extractMin();
        k = 28;
        heap.insert(new Integer(k), new Integer(k));
        k = 4;
        heap.insert(new Integer(k), new Integer(k));
        k = 3;
        heap.insert(new Integer(k), new Integer(k));
        heap.extractMin();*/
        System.out.println(heap.extractMin());
        k = 21;
        heap.insert(new Integer(k), new Integer(k));
        System.out.println(heap.extractMin());
    }
}

interface IPriorityQueue<K, V> {
    void insert(K newKey, V newValue);

    V findMin();

    V extractMin();

    void decreaseKey(K oldKey, V value, K newKey);

    void delete(K key, V value);

    void union(Object anotherQueue);
}

class BinaryHeap<K extends Comparable<K>, V extends Comparable<V>> implements IPriorityQueue<K, V> {
    int tailIndex;
    Pair<K, V>[] arrayHeap;

    public BinaryHeap() {
        tailIndex = 0;
        arrayHeap = new Pair[1000000];
        // (Pair<K, V>[])new Object[1000000];
    }

    private void bubbleDown(int index) {
        if (2 * index + 1 < tailIndex)
            if (arrayHeap[index].getKey().compareTo(arrayHeap[2 * index + 1].getKey()) > 0) {
                swap(2 * index + 1, index);
                bubbleDown(2 * index + 1);
            } else if (2 * index + 2 < tailIndex)
                if (arrayHeap[index].getKey().compareTo(arrayHeap[2 * index + 2].getKey()) > 0) {
                    swap(2 * index + 2, index);
                    bubbleDown(2 * index + 2);
                }
    }

    private void swap(int iA, int iB) {
        Pair<K, V> temp = arrayHeap[iA];
        arrayHeap[iA] = arrayHeap[iB];
        arrayHeap[iB] = temp;
    }

    private void bubbleUp(int index) {
        // если объект меньше родителя
        if (arrayHeap[(index - 1) / 2].compareTo(arrayHeap[index]) > 0) {
            swap((index - 1) / 2, index);
            bubbleUp((index - 1) / 2);
        }
    }

    @Override
    public void insert(K newKey, V newValue) {
        arrayHeap[tailIndex] = new Pair<K, V>(newKey, newValue);
        // добавляю элемент в конец, но затем мне нужно его поднять
        bubbleUp(tailIndex);
        tailIndex++;
    }

    @Override
    public V findMin() {
        return arrayHeap[0].getValue();
    }

    @Override
    public V extractMin() {
        if (tailIndex != -1) {
            V returnValue = arrayHeap[0].getValue();
            delete(0);
            return returnValue;
        }
        else return null;
    }

    private void delete(int index) {
        // ставлю на его место крайний элемент, а чтобы не учитывать последний элемент, я сдвигаю tail поинтер - затем мне нужно вызвать blowUp и blowDown, чтобы привести всё в порядок
        arrayHeap[index] = arrayHeap[tailIndex - 1];
        tailIndex--;
        //проверка Up and Bubble Down
        // если объект меньше родителя по ключу
        if (arrayHeap[(index - 1) / 2].compareTo(arrayHeap[index]) < 0)
            bubbleUp(index);
            // если объект больше детей по ключу
        else bubbleDown(index);
    }

    @Override
    public void delete(K key, V value) {
        int index = getIndexByKey(key);
        if (index != -1 && arrayHeap[index].getValue().equals(value))
            delete(index);
    }

    private int getIndexByKey(K key) {
        for (int i = 0; i < tailIndex; i++) {
            if (arrayHeap[i].getKey().equals(key))
                return i;
        }
        return -1;
    }

    @Override
    public void decreaseKey(K oldKey, V value, K newKey) {
        int index = getIndexByKey(oldKey);
        if (index != -1 && arrayHeap[index].getValue().equals(value)) {
            delete(index);
            insert(newKey, value);
        }
    }

    @Override
    public void union(Object anotherQueue) {

    }
}

class Pair<K extends Comparable<K>, V extends Comparable<V>> implements Comparable<Pair<K, V>> {
    private K key;

    public K getKey() {
        return key;
    }

    private V value;

    public V getValue() {
        return value;
    }

    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    @Override
    public String toString() {
        return key + "=" + value;
    }


    @Override
    public int compareTo(Pair<K, V> o) {
        if (o.key.compareTo(this.key) == 0)
            return this.value.compareTo(o.value);
          //  return o.value.compareTo(this.value);
        else return this.key.compareTo(o.key);
    }
}