#include<cstdio>
#include<cmath>
#include<cfloat>
#include<cassert>
#include<vector>
#include<algorithm>

using namespace std;

/* double extention Library. */
  
const double EPS = 1e-8;
  
bool eq(double a, double b)
{
    return (fabs(a - b) <= EPS);
}
  
bool lt(double a, double b)
{
    return (a - b < -EPS);
}
  
bool leq(double a, double b)
{
    return (lt(a, b) || eq(a, b));
}
  
bool gt(double a, double b)
{
    return (a - b > +EPS);
}
  
bool geq(double a, double b)
{
    return (gt(a, b) || eq(a, b));
}

/* 2D geometry library. */

class Point{
public:
	double x, y;
	Point ( double x = 0, double y = 0): x(x), y(y){}
	Point operator + ( Point p ){ return Point(x + p.x, y + p.y); }
	Point operator - ( Point p ){ return Point(x - p.x, y - p.y); }
	Point operator * ( double a ){ return Point(x*a, y*a); }
	double abs() { return sqrt(norm());}
	double norm() { return x*x + y*y; }
	bool operator < ( const Point &p ) const {
		return x != p.x ? x < p.x : y < p.y;
	}
	bool operator == ( const Point &p ) const {
		return fabs(x-p.x) < EPS && fabs(y-p.y) < EPS;
	}
};

typedef Point Vector;
typedef vector<Point> Polygon;

double norm( Vector a ){ return a.x*a.x + a.y*a.y; }
double abs(Vector a) {return (sqrt(norm(a)));}
double abs(Vector a, Vector b) {return (sqrt(norm(a - b)));}
double dot( Vector a, Vector b ){ return a.x*b.x + a.y*b.y; }
double cross( Vector a, Vector b ){ return a.x*b.y - a.y*b.x; }
double atan(Vector a){ return atan2(a.y, a.x);}
bool sortX(Point a, Point b){return (a.x != b.x ? lt(a.x, b.x) : lt(a.y, b.y));}
bool sortY(Point a, Point b){return (a.y != b.y ? lt(a.y, b.y) : lt(a.x, b.x));}
bool sortT(Point a, Point b){return (lt(atan(a), atan(b)));}

static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;

//3点の位置関係を求める
int ccw( Point p0, Point p1, Point p2 ){
	Vector a = p1 - p0;
	Vector b = p2 - p0;
	if (cross(a, b) > EPS ) return COUNTER_CLOCKWISE;
	if (cross(a, b) < -EPS ) return CLOCKWISE;
	if ( dot(a, b) < -EPS ) return ONLINE_BACK;
	if ( norm(a) < norm(b) ) return ONLINE_FRONT;
	return ON_SEGMENT;
}

//多角形を点順にソート
Polygon normalize(Polygon &gon)
{
	int p = 0;
	
	for (int i = 1; i < gon.size(); i++){
		if (lt(gon[i].y, gon[p].y) ||
			(eq(gon[i].y, gon[p].y) && lt(gon[i].x, gon[p].x))){
			p = i;
		}
	}
	
	swap(gon[0], gon[p]);
	for (int i = 1; i < gon.size(); i++) gon[i] = gon[i] - gon[0];
	sort(gon.begin() + 1, gon.end(), sortT);
	for (int i = 1; i < gon.size(); i++) gon[i] = gon[i] + gon[0];
	
	return (gon);
}

bool isIntersect(Point p1, Point p2, Point p3, Point p4){
    return (ccw(p1, p2, p3) * ccw(p1, p2, p4) <= 0 &&
             ccw(p3, p4, p1) * ccw(p3, p4, p2) <= 0 );
}
  
  
  
bool isInside(Polygon gon, Point p)
{
    for (int i = 0; i < gon.size(); i++){
        if (ccw(gon[i], gon[(i + 1) % gon.size()], p) == CLOCKWISE) return (false);
    }
    return (true);
}
  
Point unitVector(Vector t)
{
    double u = abs(t);
    return (Point(t.x / u , t.y / u));
}
  
double getCos(Vector a, Vector b)
{
    return (dot(a, b) / (abs(a) * abs(b)));
}
  
double getSin(Point a , Point b)
{
    double t = getCos(a, b);
    return (sqrt(1.0 - t * t));
}
  
double getArg(Vector v)
{
    return (atan2(v.y, v.x));
}
  
double getDistPL(Point p, Point a, Point b)
{
    return (fabs(cross(b - a, p - a)) / abs(b - a));
}
  
double getDistPS(Point p, Point a, Point b)
{
    if(dot(b - a, p - a) < EPS) return (abs(p - a));
    if(dot(a - b, p - b) < EPS) return (abs(p - b));
    return (getDistPL(p, a, b));
}
  
Point interPointS(Point a1 , Point a2 , Point b1 , Point b2)
{
    Point b = b2 - b1;
    double d1 = fabs(cross(b, a1 - b1));
    double d2 = fabs(cross(b, a2 - b1));
    double t = d1 / (d1 + d2);
    Point a = a2 - a1;
    Point v = a * t;
    return (a1 + v);
}
  
Point interPointL(Point a1 , Point a2 , Point b1 , Point b2)
{
    Point a = a2 - a1;
    Point b = b2 - b1;
    double t = cross(b, b1 - a1) / cross(b, a);
    Point v = a * t;
    return (a1 + v);
}
  
void interPointLC(Point a, Point b, Point c, double r, Point ans[])
{
    if (getDistPL(c, a, b) > r + EPS) return;
    Point v = unitVector(b - a);
    double delta = dot(v, a - c) * dot(v, a - c) - abs(a - c) * abs(a - c) + r * r;
    double t = -dot(v, a - c);
    double s = sqrt(delta);
    ans[0] = a + v * (t + s);
    ans[1] = a + v * (t - s);
}
  
Point xTranslate(Point t, double k)
{
    return (Point(t.x, 2 * k - t.y));
}
  
Point yTranslate(Point t, double k)
{
    return (Point(2 * k - t.x, t.y));
}
  
Point oTranslate(Point t, Point k)
{
    return (k + (k - t));
}
  
Point rotate(Point t , Point p , double r)
{
    double ta=cos(r)*(t.x-p.x)-sin(r)*(t.y-p.y)+p.x;
    double tb=sin(r)*(t.x-p.x)+cos(r)*(t.y-p.y)+p.y;
    return Point(ta , tb);
}
  
void interPointCC(Point a , double ra , Point b , double rb , Point ans[])
{
    double di=fabs(abs(a-b));
    if(di > ra+rb || di < fabs(ra-rb)) return;
    double t=(ra*ra-rb*rb+di*di)/(di+di);
    double rd=acos(t/ra);
  
    Point dv=unitVector(b-a);
    Point g1=rotate(dv , Point(0,0) , rd);
    Point g2=rotate(dv , Point(0,0) , -rd);
    ans[0]=a+g1*ra;
    ans[1]=a+g2*ra;
}
  
Point normalVector(Point p,Point a,Point b)
{
    Point v=unitVector(b-a);
    v = cross(v , p-a) > 0 ?  Point(v.y,(-1)*v.x) : Point((-1)*v.y , v.x);
    return v*getDistPL(p,a,b);
}
  
Point fTranslate(Point t , Point a , Point b)
{
    return t+normalVector(t,a,b)*2;
}
  
double area(Point a, Point b, Point c){
    return fabs(cross(c-a , b-a)*0.5);
}
  
double getPolygonArea(Polygon t){
    double ans = 0.0;
    for (unsigned int i = 0; i < t.size(); i++)
        ans += cross(t[i] , t[(i + 1) % t.size()]);
    return (fabs(ans) / 2);
}
  
Polygon conhel(Polygon& ps)
{
    sort(ps.begin(), ps.end());
    int k = 0, n = static_cast<int>(ps.size());
    Polygon qs(n * 2);
      
    for (int i = 0; i < n; i++){
      while (k > 1 && cross(qs[k - 1] - qs[k - 2], ps[i] - qs[k - 1]) < EPS) k--;
      qs[k++] = ps[i];
    }
  
    for (int i = n - 2, t = k; i >= 0; i--){
      while (k > t && cross(qs[k - 1] - qs[k - 2], ps[i] - qs[k - 1]) < EPS) k--;
      qs[k++] = ps[i];
    }
  
    qs.resize(k - 1);
    return (qs);
}

int main()
{
	int t = 0;
	int n;
	
	while (scanf("%d", &n) && n){
		Polygon gon;
		for (int i = 0; i < n; i++){
			Point p;
			scanf("%lf %lf", &p.x, &p.y);
			gon.push_back(p);
		}
		
		printf("%d %.1lf\n", ++t, getPolygonArea(gon));
		
	}
	
	return (0);
}

Measured memory_bytes: 1100