One day *n* friends met at a party, they hadn't seen each other for a long time and so they decided to make a group photo together. 

Simply speaking, the process of taking photos can be described as follows. On the photo, each photographed friend occupies a rectangle of pixels: the *i*-th of them occupies the rectangle of width *w*<sub class="lower-index">*i*</sub> pixels and height *h*<sub class="lower-index">*i*</sub> pixels. On the group photo everybody stands in a line, thus the minimum pixel size of the photo including all the photographed friends, is *W* × *H*, where *W* is the total sum of all widths and *H* is the maximum height of all the photographed friends.

As is usually the case, the friends made *n* photos — the *j*-th (1 ≤ *j* ≤ *n*) photo had everybody except for the *j*-th friend as he was the photographer.

Print the minimum size of each made photo in pixels.
The first line contains integer *n* (2 ≤ *n* ≤ 200 000) — the number of friends. 

Then *n* lines follow: the *i*-th line contains information about the *i*-th friend. The line contains a pair of integers *w*<sub class="lower-index">*i*</sub>, *h*<sub class="lower-index">*i*</sub> (1 ≤ *w*<sub class="lower-index">*i*</sub> ≤ 10, 1 ≤ *h*<sub class="lower-index">*i*</sub> ≤ 1000) — the width and height in pixels of the corresponding rectangle.
#include <iostream>
#include <array>
#include <stdexcept>

using namespace std;


template <typename T, size_t N>
class StackVector
{
public:
    explicit StackVector(size_t a_size = 0)
        : size(a_size), capacity(N)
        {
            if (size > N)
                throw invalid_argument("");
        }

    T& operator[](size_t index)
    {
        return container[index];
    }
    const T& operator[](size_t index) const
    {
        return container[index];
    }

    typename array<T, N>::iterator begin()
    {
        return container.begin();
    }
    typename array<T, N>::iterator end()
    {
        return next(container.begin() + size);
    }

    typename array<T, N>::const_iterator begin() const
    {
        return container.begin();
    }
    typename array<T, N>::const_iterator end() const
    {
        return next(container.begin() + size);
    }

    size_t Size() const
    {
        return size;
    }
    size_t Capacity() const
    {
        return capacity;
    }

    void PushBack(const T& value)
    {
        if (size == capacity)
            throw overflow_error("");

        container[size] = value;
        ++size;
    }
    T PopBack()
    {
        if (size == 0)
            throw underflow_error("");

        --size;
        return container[size];
    }

private:
    array<T, N> container;
    size_t size;
    size_t capacity;
};