from math import sqrt,fabs,ceil,floor,pow,exp,log,sin,cos,tan,asin,acos,atan,atan2,pi
import copy


inf=float("inf")


class Real:
	isLineLike=False
	eps=1e-10
	def __init__(self,x):
		self.x=float(x)
	def __float__(self):
		return self.x
	def __repr__(self):
		return str(self.x)
	def __eq__(self,other):
		return abs( float(self) - float(other) ) <= Real.eps
	def __ne__(self,other):
		return abs( float(self) - float(other) ) > Real.eps
	def __lt__(self,other):
		return float(self) < float(other)
	def __le__(self,other):
		return float(self) <= float(other) + Real.eps
	def __gt__(self,other):
		return float(self) > float(other)
	def __ge__(self,other):
		return float(self) + Real.eps >= float(other)
	def __add__(self,other):
		return Real(float(self)+float(other))
	def __sub__(self,other):
		return Real(float(self)-float(other))
	def __mul__(self,other):
		return Real(float(self)*float(other))
	def __div__(self,other):
		return Real(float(self)/float(other))
	def __mod__(self,other):
		return Real(float(self)%float(other))
	def __pow__(self,c):
		return Real(float(self)**c)
	def __rmul__(self,other):
		return Real(float(other)*float(self))
	def __pos__(self):
		return Real(float(self))
	def __neg__(self):
		return Real(-float(self))
	def __abs__(self):
		return Real(abs(float(self)))

class Angle:	#angle. kaku.
	isLineLike=False
	def __init__(self,th):
		self.th = Real(th)%(2*pi)
	def __float__(self):
		return float(self.th)
	def __repr__(self):
		return "Angle("+str(Real(self))+")"
	def __eq__(self,other):
		return Real(self)==Real(other) or abs(Real(self)-Real(other))==Real(2*pi)
	def isParaWith(self,other):
		return self==other or self==other+pi
	def __add__(self,other):
		return Angle( Real(self) + Real(other) )
	def __sub__(self,other):
		return Angle( Real(self) - Real(other) )
	def __mul__(self,c):
		return Angle( Real(self) * Real(c) )
	def __div__(self,c):
		return Angle( Real(self) / Real(c) )
	def __rmul__(self,c):
		return Angle( Real(c) * Real(self) )
	def __pos__(self):
		return Angle(Real(self))
	def __neg__(self):
		return Angle(-Real(self))
	def __abs__(self):
		return Angle(abs(Real(self)))

class Vector:	#point, vector. ten, bekutoru.
	isLineLike=False
	def __init__(self,x=None,y=None,d=None,th=None):
		if not(x is None) and not(y is None):
			self.setXY(x,y)
		if not(d is None) and not(th is None):
			self.setDTh(d,th)
	def setXY(self,x,y):
		self.x=Real(x);
		self.y=Real(y);
		self.calcFromXY()
	def setDTh(self,d,th):
		self.d=Real(d)
		self.th=Angle(th)
		self.calcFromDTh()
	def calcFromXY(self):
		self.d=sqrt(self.x**2+self.y**2)
		self.th=Angle(atan2(self.y,self.x))
	def calcFromDTh(self):
		self.x=self.d*cos(self.th)
		self.y=self.d*sin(self.th)
	def e(self):
		return self/self.d
	def __eq__(self,other):
		return self.x==other.x and self.y==other.y
	def isParaWith(self,other):
		return self.th.isParaWith(other.th)
	def __add__(self,other):
		return Vector(self.x+other.x, self.y+other.y)
	def __sub__(self,other):
		return Vector(self.x-other.x, self.y-other.y)
	def __mul__(self,c):
		return Vector(self.x*c, self.y*c)
	def __div__(self,c):
		return Vector(self.x/c, self.y/c)
	def __rmul__(self,c):
		return Vector(c*self.x, c*self.y)
	def __pos__(self):
		return Vector(self.x, self.y)
	def __neg__(self):
		return Vector(-self.x, -self.y)
	def __abs__(self):
		return +self.d
	def rotated(self,th):
		return Vector(d=self.d, th=self.th+th)
	def rotatedWithCenter(self,th,p):
		return (self-p).rotated(th)+p
	def inprod(self,other):
		return self.x*other.x+self.y*other.y
	def outprod(self,other):
		return self.x*other.y-self.y*other.x
	def isOn(self,obj):
		if isinstance(obj,DirSegLine) or isinstance(obj,SegLine):
			return obj.ap==self or obj.bp==self or (obj.th==(self-obj.ap).th and obj.th==(obj.bp-self).th)
		if isinstance(obj,HalfLine):
			return obj.ap==self or obj.th==(self-obj.ap).th
		if isinstance(obj,Line):
			return obj.th==(self-obj.ap).th or obj.th==(obj.bp-self).th
		if isinstance(obj,Circle):
			return abs(self-obj.p)==obj.d
	def isIn(self,obj):
		if isinstance(obj,Circle):
			return abs(self-obj.p)<obj.d
	def isOut(self,obj):
		if isinstance(obj,Circle):
			return abs(self-obj.p)>obj.d
	def __repr__(self):
		return "Vector("+str(self.x)+", "+str(self.y)+")"

Point=Vector

class DirSegLine:	#directed line segment. yuukou senbun.
	isLineLike=True
	def __init__(self,ap=None,bp=None,dv=None):
		if not(ap is None) and not(bp is None): self.setApBp(ap, bp)
		if not(ap is None) and not(dv is None): self.setApBp(ap, ap+dv)
		if not(bp is None) and not(dv is None): self.setApBp(bp-dv, bp)
	def setApBp(self,ap,bp):
		self.ap=+ap
		self.bp=+bp
		self.calcFromApBp()
	def calcFromApBp(self):
		self.dv = self.bp - self.ap
		self.d = abs(self.dv)
		self.th = +self.dv.th
	def __eq__(self,other):
		return self.ap==other.ap and self.bp==other.bp
	def isParaWith(self,other):
		return self.th.isParaWith(other.th)
	def __add__(self,v):
		return DirSegLine(self.ap+v, self.bp+v)
	def __sub__(self,v):
		return DirSegLine(self.ap-v, self.bp-v)
	def __abs__(self):
		return +self.d
	def rotated(self,th):
		return DirSegLine(self.ap.rotated(th), self.bp.rotated(th))
	def rotatedWithCenter(self,th,p):
		return (self-p).rotated(th)+p
	def __repr__(self):
		return "DirSegLine(ap="+str(self.ap)+", bp="+str(self.bp)+")"

class SegLine:	#line segmeny. senbun.
	isLineLike=True
	def __init__(self,ap=None,bp=None,dv=None):
		if not(ap is None) and not(bp is None): self.setApBp(ap, bp)
		if not(ap is None) and not(dv is None): self.setApBp(ap, ap+dv)
		if not(bp is None) and not(dv is None): self.setApBp(bp-dv, bp)
	def setApBp(self,ap,bp):
		self.ap=+ap
		self.bp=+bp
		self.calcFromApBp()
	def calcFromApBp(self):
		self.dv = self.bp - self.ap
		self.d = abs(self.dv)
		self.th = +self.dv.th
	def __eq__(self,other):
		return (self.ap==other.ap and self.bp==other.bp) or (self.ap==other.bp and self.bp==other.ap)
	def isParaWith(self,other):
		return self.th.isParaWith(other.th)
	def __add__(self,v):
		return SegLine(self.ap+v, self.bp+v)
	def __sub__(self,v):
		return SegLine(self.ap-v, self.bp-v)
	def __abs__(self):
		return +self.d
	def rotated(self,th):
		return SegLine(self.ap.rotated(th), self.bp.rotated(th))
	def rotatedWithCenter(self,th,p):
		return (self-p).rotated(th)+p
	def __repr__(self):
		return "SegLine(ap="+str(self.ap)+", bp="+str(self.bp)+")"

class HalfLine:
	isLineLike=True
	def __init__(self,ap=None,bp=None,dv=None,th=None):
		if not(ap is None) and not(bp is None): self.setApBp(ap, bp)
		if not(ap is None) and not(dv is None): self.setApBp(ap, ap+dv)
		if not(bp is None) and not(dv is None): self.setApBp(bp-dv, bp)
		if not(ap is None) and not(th is None): self.setApBp(ap, ap+Vector(d=1,th=th))
	def setApBp(self,ap,bp):
		self.ap=+ap
		self.bp=+bp
		self.calcFromApBp()
	def calcFromApBp(self):
		self.dv = self.bp - self.ap
		self.th = +self.dv.th
	def __eq__(self,other):
		return self.ap==other.ap and self.th==other.th
	def isParaWith(self,other):
		return self.th.isParaWith(other.th)
	def __add__(self,v):
		return HalfLine(self.ap+v, self.bp+v)
	def __sub__(self,v):
		return HalfLine(self.ap-v, self.bp-v)
	def rotated(self,th):
		return HalfLine(self.ap.rotated(th), self.bp.rotated(th))
	def rotatedWithCenter(self,th,p):
		return (self-p).rotated(th)+p
	def __repr__(self):
		return "HalfLine(ap="+str(self.ap)+", bp="+str(self.bp)+")"

class Line:
	isLineLike=True
	def __init__(self,ap=None,bp=None,dv=None,th=None):
		if not(ap is None) and not(bp is None): self.setApBp(ap, bp)
		if not(ap is None) and not(dv is None): self.setApBp(ap, ap+dv)
		if not(bp is None) and not(dv is None): self.setApBp(bp-dv, bp)
		if not(ap is None) and not(th is None): self.setApBp(ap, ap+Vector(d=1,th=th))
		if not(bp is None) and not(th is None): self.setApBp(bp-Vector(d=1,th=th), bp)
		if ap.isLineLike: self.setApBp(ap.ap,ap.bp)
	def setApBp(self,ap,bp):
		self.ap=+ap
		self.bp=+bp
		self.calcFromApBp()
	def calcFromApBp(self):
		self.dv = self.bp - self.ap
		self.th = +self.dv.th
	def __eq__(self,other):
		#return ( self.ap==other.ap or self.ap==other.bp or (self.ap-other.ap).isParaWith(other.dv) )	\
		#	and( self.bp==other.ap or self.bp==other.bp or (self.bp-other.bp).isParaWith(other.dv) )
		return self.ap.isOn(other) and self.bp.isOn(other)
	def isParaWith(self,other):
		return self.th.isParaWith(other.th)
	def __add__(self,v):
		return Line(self.ap+v, self.bp+v)
	def __sub__(self,v):
		return Line(self.ap-v, self.bp-v)
	def rotated(self,th):
		return Line(self.ap.rotated(th), self.bp.rotated(th))
	def rotatedWithCenter(self,th,p):
		return (self-p).rotated(th)+p
	def __repr__(self):
		return "Line(ap="+str(self.ap)+", bp="+str(self.bp)+")"

class Circle:
	isLineLike=False
	def __init__(self,p,d):
		self.setPD(p,d)
	def setPD(self,p,d):
		self.p=+p
		self.d=Real(d)
	def __eq__(self,other):
		return self.p==other.p and self.d==other.d
	def __add__(self,v):
		return Circle(self.p+v, +self.d)
	def __sub__(self,v):
		return Circle(self.p-v, +self.d)
	def rotated(self,th):
		return Circle(self.p.rotated(th), +self.d)
	def rotatedWithCenter(self,th,p):
		return (self-p).rotated(th)+p
	def __repr__(self):
		return "Circle(p="+str(self.p)+", d="+str(self.d)+")"

class Triangle:
	isLineLike=False
	def __init__(self,ap,bp,cp):
		self.setApBpCp(ap,bp,cp)
	def setApBpCp(self,ap,bp,cp):
		self.ap=+ap
		self.bp=+bp
		self.cp=+cp
		self.calcFromApBpCp(ap, bp, cp)
	def calcFromApBpCp(self,ap,bp,cp):
		self.ae=SegLine(bp,cp)
		self.be=SegLine(cp,ap)
		self.ce=SegLine(ap,bp)
	def __eq__(self,other):
		return (self.ap==other.ap and self.bp==other.bp and self.cp==other.cp) \
			or (self.ap==other.bp and self.bp==other.cp and self.cp==other.ap) \
			or (self.ap==other.cp and self.bp==other.ap and self.cp==other.bp)
	def __add__(self,v):
		return Triangle(self.ap+v,self.bp+v,self.cp+v)
	def __sub__(self,v):
		return Triangle(self.ap-v,self.bp-v,self.cp-v)
	def rotated(self,th):
		return Triangle(self.ap.rotated(th),self.bp.rotated(th),self.cp.rotated(th))
	def rotatedWithCenter(self,th,p):
		return (self-p).rotated(th)+p
	def dirArea(self):
		return (self.ae).outprod(self.be)/2 	#=(axb+bxc+cxa)/2
	def area(self):
		return abs(self.dirArea())
	def gravityCenter(self):	#juushin
		return (self.ap+self.bp+self.cp)/3
	def innerCenter(self):		#naishin
		return crossPoints(angleBisector(self.ae,self.be), angleBisector(self.be,self.ce))[0]
	def exterCenter(self):		#gaishin
		return crossPoints(perpendicularBisector(self.ae), perpendicularBisector(self.be))[0]
	def orthoCenter(self):		#suishin
		return crossPoints(perpendicular(self.ap,self.ae), perpendicular(self.bp,self.be))[0]
	def __repr__(self):
		return "Triangle("+str(self.ap)+", "+str(self.bp)+", "+str(self.cp)+")"

class Polygon:
	def __init__(self,ps):
		self.ps=copy.deepcopy(ps)
		self.uniquenize()
		self.checkSimplicity()
		self.checkConvexity()
	def uniquenize(self):
		nps = []
		for p in self.ps:
			if len(nps)==0:
				nps.append(p)
				continue
			if nps[-1]==p:
				pass
			else:
				nps.append(p)
		if len(nps)>1:
			if nps[0]==nps[-1]:
				nps.pop(0)
		self.ps=nps
	def __eq__(self,other):
		sps=copy.copy(self.ps)
		ops=copy.copy(other.ps)
		if len(sps)!=len(ops): return False
		for i in xrange(0,len(sps)):
			icchi=True
			for j in xrange(0,len(sps)):
				if sps[i]==sps[j]:
					pass
				else:
					icchi=False
					break
			if icchi: return True
			else: continue
		return False
	def __add__(self,v):
		g=Polygon(self.ps)
		for p in g:
			p+=v
		return g
	def __sub__(self,v):
		g=Polygon(self.ps)
		for p in g:
			p-=v
		return g
	def rotated(self,th):
		g=Polygon(self.ps)
		for p in g:
			p=p.rotated(th)
		return g
	def rotatedWithCenter(self,th,cp):
		g=Polygon(self.ps)
		for p in g:
			p=p.rotatedWithCenter(th,cp)
		return g
	def checkSimplicity(self):
		self.isSimple=True
	def checkConvexity(self):
		self.isConvex=True
	def getConvexHull(self):
		return None
	def dirArea(self):
		if self.isSimple:
			re=Real(0)
			for j in xrange(0,len(self.ps)):
				re += self.ps[j-1].outprod(self.ps[j])/2
			return re
	def area(self):
		return abs(self.dirArea())
	def __repr__(self):
		re="Polygon(["
		for p in self.ps:
			re += str(p)+", "
		re=re.rstrip(", ")
		re+="])"
		return re

def crossPoints(m,n):
	if m.isLineLike and n.isLineLike:
		c = m.dv.outprod(n.dv)
		if c==0: return []
		s = n.dv.outprod(m.ap-n.ap) / c
		t = m.dv.outprod(n.ap-m.ap) / c
		if (     ((isinstance(m,DirSegLine) or isinstance(m,SegLine)) and 0<=s<=1)	\
			or   (isinstance(m,HalfLine) and 0<=s)									\
			or   (isinstance(m,Line))												\
		   )and( ((isinstance(m,DirSegLine) or isinstance(m,SegLine)) and 0<=t<=1)	\
			or   (isinstance(m,HalfLine) and 0<=t)									\
			or   (isinstance(m,Line))												\
			):
			return [m.ap+m.dv*s]
		else:
			return []
	elif m.isLineLike and isinstance(n,Circle):
		re=[]
		l=perpendicular(n.p, m)
		if l.bp.isOn(n):
			p=+l.bp
			if p.isOn(m): re.append(p)
			return re
		if l.bp.isOut(n):
			return re
		if l.bp.isIn(n):
			r=sqrt(n.d**2-l.d**2)
			p1 = l.bp+Vector(d=r,th=m.th)
			p2 = l.bp-Vector(d=r,th=m.th)
			if p1.isOn(m): re.append(p1)
			if p2.isOn(m): re.append(p2)
			return re
	elif isinstance(n,Circle) and m.isLineLike:
		return crossPoints(n, m)
	elif isinstance(m,Circle) and isinstance(n,Circle):
		d = abs(m.p-n.p)
		if d==0 and m.d==n.d:	#itchi
			return []
		if d== m.d-n.d:			#naisetsu(n in m)
			return [(n.p*m.d-m.p*n.d)/(m.d-n.d)]
		if d < m.d-n.d:			#naihou(n in m)
			return []
		if d== n.d-m.d:			#naisetsu(m in n)
			return [(m.p*n.d-n.p*m.d)/(n.d-m.d)]
		if d < n.d-m.d:			#naihou(n in m)
			return []
		if d== m.d+n.d:			#gaisetsu
			return [(m.p*n.d+n.p*m.d)/(m.d+n.d)]
		if d > m.d+n.d:			#hanareteru
			return []
		if d < m.d+n.d:
			x = (d**2+m.d**2-n.d**2)/(2*d)
			y = sqrt(m.d**2-x**2)
			th = (n.p-m.p).th
			v1 = Vector(x,y)
			v1 = v1.rotated(th)
			v2 = Vector(x,-y)
			v2 = v2.rotated(th)
			return [m.p+v1, m.p+v2]

def perpendicular(p,m):
	ap=p
	th=m.th+pi/2
	bp=crossPoints(Line(m.ap,m.bp), Line(ap=ap,th=th))[0]
	re = DirSegLine(ap,bp)
	if not re.th.isParaWith(th): re.th=th
	return re

def angleBisector(m,n):
	if m.isParaWith(n):
		return Line(ap=(m.ap+n.ap)/2,th=m.th)
	else:
		return Line(ap=crossPoints(Line(m.ap,m.bp),Line(n.ap,n.bp))[0], th = (m.th+n.th)/2)

def perpendicularBisector(m):
	return Line(ap=(m.ap+m.bp)/2,th=m.th+pi/2)



n=0
while True:
	n+=1
	pl=int(raw_input())
	if pl==0: break
	ps=[]
	for i in xrange(pl):
		px,py = tuple(map(int, raw_input().split()))
		ps.append(Vector(px,py))
	g = Polygon(ps)
	print n, g.area()
	raw_input()

Measured memory_bytes: 6008