#include <iostream>
#include <vector>
#include <cassert>
namespace boost {
template <class T>
struct integer_iterator {
    T a;
    bool operator != (integer_iterator const & it) const { return a != it.a; }
    T operator * () const { return a; }
    integer_iterator & operator ++ () { ++ a; return *this; }
    integer_iterator operator ++ (int) { return { a ++ }; }
};
template <class T>
struct integer_range {
    T l, r;
    typedef integer_iterator<T> iterator;
    iterator begin() const { return { l }; }
    iterator end  () const { return { r }; }
};
template <class T>
integer_range<T> irange(T l, T r) { assert (l <= r); return { l, r }; }
template <class T>
struct integer_iterator_with_step {
    T a, d, i;
    bool operator != (integer_iterator_with_step const & it) const { return a != it.a or d != it.d or i != it.i; }
    T operator * () const { return a+d*i; }
    integer_iterator_with_step & operator ++ () { ++ i; return *this; }
    integer_iterator_with_step operator ++ (int) { return { a, d, i ++ }; }
};
template <class T>
struct strided_integer_range {
    T l, r, s;
    typedef integer_iterator_with_step<T> iterator;
    iterator begin() const { return { l, s, 0 }; }
    iterator end  () const { return { l, s, (r - l) / s }; }
};
template <class T>
strided_integer_range<T> irange(T l, T r, T s) { assert (s > 0 ? l <= r : s < 0 ? l >= r : false); return { l, r, s }; }
}
#include <utility>
#include <cmath>
#define ttt template <typename T>
#define pca point<T> const &
ttt struct point { T x, y; };
ttt point<T> operator + (pca a, pca b) { return { a.x+b.x, a.y+b.y }; }
ttt point<T> operator - (pca a, pca b) { return { a.x-b.x, a.y-b.y }; }
ttt point<T> operator - (pca a) { return { -a.x, -a.y }; }
ttt point<T> operator * (T a, pca b) { return { a*b.x, a*b.y }; }
ttt std::pair<T,T> to_pair(pca a) { return { a.x, a.y }; }
ttt bool operator == (pca a, pca b) { return to_pair(a) == to_pair(b); }
ttt bool operator != (pca a, pca b) { return to_pair(a) != to_pair(b); }
ttt bool operator <  (pca a, pca b) { return to_pair(a) <  to_pair(b); }
ttt bool operator <= (pca a, pca b) { return to_pair(a) <= to_pair(b); }
ttt bool operator >= (pca a, pca b) { return to_pair(a) >= to_pair(b); }
ttt bool operator >  (pca a, pca b) { return to_pair(a) >  to_pair(b); }
ttt T length_squared(pca p) { return p.x*p.x + p.y*p.y; }
ttt double length(pca p) { return sqrt(length_squared(p)); }
ttt point<T> normalized(pca a) { return (1 / length(a)) * a; }
ttt T   dot(pca p, pca q) { return p.x * q.x + p.y * q.y; }
ttt T cross(pca p, pca q) { return p.x * q.y - p.y * q.x; }
ttt int ccw(pca a, pca b, pca c) { T x = cross(b - a, c - a); return x > 0 ? 1 : x < 0 ? -1 : 0; }
#undef ttt
#undef pca
template <typename T> std::istream & operator >> (std::istream & input, point<T> & p) { return input >> p.x >> p.y; }
template <typename T> std::ostream & operator << (std::ostream & output, const point<T> & p) { return output << p.x << ' ' << p.y; }
using namespace std;
using namespace boost;
int main() {
    int number = 0;
    while (true) {
        int n; cin >> n;
        if (n == 0) break;
        vector<point<double> > ps(n);
        for (auto & p : ps) cin >> p;
        double area = 0;
        for (int i : irange(0,n)) {
            int j = (i+1) % n;
            area += cross(ps[i], ps[j]);
        }
        area = abs(area) / 2;
        printf("%d %.1lf\n", ++ number, area);
    }
    return 0;
}

Measured memory_bytes: 1240