#include <iostream>
#include <iomanip>
#include <sstream>
#include <cstdio>
#include <string>
#include <vector>
#include <algorithm>
#include <complex>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <cassert>
#include <climits>
#include <queue>
#include <set>
#include <map>
#include <valarray>
#include <bitset>
#include <stack>
using namespace std;

#define REP(i,n) for(int i=0;i<(int)n;++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
#define chmax(a,b) (a<(b)?(a=b,1):0)
#define chmin(a,b) (a>(b)?(a=b,1):0)
#define valid(y,x,h,w) (0<=y&&y<h&&0<=x&&x<w)

#define double long double
typedef long long ll;
typedef pair<int,int> pii;
const int INF = 1e8;
const double PI = acos(-1);
const double EPS = 1e-8;
typedef complex<double> P;
namespace std {
  bool operator < (const P& a, const P& b) {
    // if (abs(a-b)<EPS) return 0;
    return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
  }
}
double cross(const P& a, const P& b) {
  return imag(conj(a)*b);
}
double dot(const P& a, const P& b) {
  return real(conj(a)*b);
}
struct L : public vector<P> {
  L(const P &a, const P &b) {
    push_back(a); push_back(b);
  }
  L() {}
};
ostream &operator<<(ostream &os, const L &a) {
  os << a[0] << " -> " << a[1];
  return os;
}

typedef vector<P> G;
#define curr(P, i) P[i]
#define next(P, i) P[(i+1)%P.size()]
struct C {
  P p; double r;
  C(const P &p, double r) : p(p), r(r) { }
};

int ccw(P a, P b, P c) {
  b -= a; c -= a;
  if (cross(b, c) > EPS)   return +1;       // counter clockwise
  if (cross(b, c) < -EPS)   return -1;       // clockwise
  if (dot(b, c) < -EPS)     return +2;       // c--a--b on line
  if (norm(b) < norm(c)) return -2;       // a--b--c on line
  return 0;
}

bool intersectLL(const L &l, const L &m) {
  return abs(cross(l[1]-l[0], m[1]-m[0])) > EPS*10 || // non-parallel
         abs(cross(l[1]-l[0], m[0]-l[0])) < EPS;   // same line
}
bool intersectLS(const L &l, const L &s) {
  return cross(l[1]-l[0], s[0]-l[0])*       // s[0] is left of l
         cross(l[1]-l[0], s[1]-l[0]) < EPS; // s[1] is right of l
}
bool intersectLP(const L &l, const P &p) {
  return abs(cross(l[1]-p, l[0]-p)) < EPS;
}
bool intersectSS(const L &s, const L &t) {
  return ccw(s[0],s[1],t[0])*ccw(s[0],s[1],t[1]) <= 0 &&
         ccw(t[0],t[1],s[0])*ccw(t[0],t[1],s[1]) <= 0;
}
bool intersectSS2(const L &s, const L &t) { // テヲツ篠・テ」ツ?療」ツ?ヲテ」ツ??」ツつ凝」ツつ?」ツ?、テ」ツ?ッテ、ツコツ、テ・ツキツョテ」ツ?ィティツ?ε」ツ?暗」ツ?ェテ」ツ??
  REP(i, 2) {
    if (ccw(s[0], s[1], t[i]) == 0) {
      int c = ccw(s[0],s[1],t[!i]);
      if (s[0] == t[i]) {
        if (c!=-2&&c) return 0;
      } else if (s[1] == t[i]) {
        if (c!=2&&c) return 0;
      } else if (abs(c)==1) return 0;
    }
  }
  return ccw(s[0],s[1],t[0])*ccw(s[0],s[1],t[1]) <= 0 &&
         ccw(t[0],t[1],s[0])*ccw(t[0],t[1],s[1]) <= 0;
}
bool intersectSP(const L &s, const P &p) {
  return abs(s[0]-p)+abs(s[1]-p)-abs(s[1]-s[0]) < EPS; // triangle inequality
}
bool intersectLH(const L &l, const L &h) {
  if (intersectLS(l,h)) return 1;
  if (!intersectLL(l,h)) return 0;
  if (abs(cross(l[1]-l[0],h[1]-h[0])) < EPS) return 1; // same line
  return (ccw(l[0],l[1],h[0]) == 1) ^ (cross(l[1]-l[0], h[1]-h[0]) > 0);
}
bool intersectHS(const L &h, const L &s) {
  if (intersectSS(h,s)) return 1;
  if (!intersectLS(h,s)) return 0;
  if (abs(cross(s[1]-s[0],h[1]-h[0])) < EPS) // same line
    return ccw(h[0],h[1],s[0]) != 2 || ccw(h[0],h[1],s[1]) != 2;
  return (ccw(s[0],s[1],h[0]) == 1) ^ (cross(s[1]-s[0], h[1]-h[0]) > 0);
}
bool intersectHH(const L &h, const L &k) {
  return intersectLH(h,k) && intersectLH(k,h);
}
bool intersectHS2(const L &h, const L &s) {
  L t(s); swap(t[0],t[1]);
  return intersectHH(h,s) && intersectHH(h,t);
}

P projection(const L &l, const P &p) {
  double t = dot(p-l[0], l[0]-l[1]) / norm(l[0]-l[1]);
  return l[0] + t*(l[0]-l[1]);
}
P reflection(const L &l, const P &p) {
  return p + P(2,0) * (projection(l, p) - p);
}
double distanceLP(const L &l, const P &p) {
  return abs(p - projection(l, p));
}
double distanceLL(const L &l, const L &m) {
  return intersectLL(l, m) ? 0 : distanceLP(l, m[0]);
}
double istanceLS(const L &l, const L &s) {
  if (intersectLS(l, s)) return 0;
  return min(distanceLP(l, s[0]), distanceLP(l, s[1]));
}
double distanceSP(const L &s, const P &p) {
  const P r = projection(s, p);
  if (intersectSP(s, r)) return abs(r - p);
  return min(abs(s[0] - p), abs(s[1] - p));
}
double distanceSS(const L &s, const L &t) {
  if (intersectSS(s, t)) return 0;
  return min(min(distanceSP(s, t[0]), distanceSP(s, t[1])),
             min(distanceSP(t, s[0]), distanceSP(t, s[1])));
}
P crosspoint(const L &l, const L &m) {
  double A = cross(l[1] - l[0], m[1] - m[0]);
  double B = cross(l[1] - l[0], l[1] - m[0]);
  if (abs(A) < EPS && abs(B) < EPS) return m[0]; // same line
  if (abs(A) < EPS) {
    cout << abs(A) << endl;
    cout << intersectLL(l,m) << endl;
    cout << l << " " << m << endl;
  }
  if (abs(A) < EPS) assert(false); // !!!PRECONDITION NOT SATISFIED!!!
  return m[0] + B / A * (m[1] - m[0]);
}
bool intersectLHL(const L &l, const L &m) {
  if (!intersectLL(l,m)) return 0;
  P cp = crosspoint(l,m);
  if (ccw(m[0],m[1],cp) == 2) return 0;
  return 1;
}
bool intersectHLS(const L &l, const L &s) {
  if (!intersectLS(l,s)) return 0;
  P cp = crosspoint(l,s);
  if (ccw(l[0],l[1],cp) == 2) return 0;
  return 1;
}
double area(const G& g) {
  double A = 0;
  for (int i = 0; i < g.size(); ++i) {
    A += cross(g[i], next(g, i));
  }
  return abs(A/2);
}

G convex_cut(const G& g, const L& l) {
  G Q;
  REP(i, g.size()) {
    P A = curr(g, i), B = next(g, i);
    if (ccw(l[0], l[1], A) != -1) Q.push_back(A);
    if (ccw(l[0], l[1], A)*ccw(l[0], l[1], B) == -1)
      // if (abs(cross(l[1]-l[0],B-A)) > EPS)
        Q.push_back(crosspoint(L(A, B), l));
  }
  return Q;
}
///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////

// テ、ツクツ?ヲツァツ佚」ツ?ェテ・ツ、ツ堙ィツァツ津・ツスツ「テ」ツ?ョテゥツ?催・ツソツ?
P centroid(const vector<P> &v) {
  double S = 0;
  P res;
  REP(i,v.size()) {
    int j = i+1;
    if (j == v.size()) j = 0;
    double tmp = cross(v[i], v[j]);
    S += tmp;
    res += (v[i] + v[j]) * tmp;
  }
  S /= 2;
  res /= 6*S;
  return res;
}

double manDistanceSP(const L &l, const P &p) {
  double res = INF;
  L xl = L(p, p + P(1,0));
  if (intersectLS(xl, l)){
    P cp = crosspoint(xl, l);
    double d = abs(p-cp);
    res = min(res, d);
  }
  L yl = L(p, p + P(0,1));
  if (intersectLS(yl, l)) {
    P cp = crosspoint(yl, l);
    double d = abs(p-cp);
    res = min(res, d);
  }
  res = min(res, abs(l[0].real()-p.real()) + abs(l[0].imag()-p.imag()));
  res = min(res, abs(l[1].real()-p.real()) + abs(l[1].imag()-p.imag()));
  return res;
}

// テァツつケ-テ・ツ?クテ・ツ、ツ堙ィツァツ津・ツスツ「テ・ツ個?・ツ青ォテゥツ鳴「テ、ツソツ?
bool convex_contain(const G &g, const P &p) { // テ・ツ債甘ヲツ卍づィツィツ暗・ツ崢榲」ツつ甘」ツつ津、ツサツョテ・ツョツ?
  REP(i,g.size())
    if (ccw(g[i], next(g, i), p) == -1) return 0;
  return 1;
}
// テ・ツ?クテ・ツ、ツ堙ィツァツ津・ツスツ「テ・ツ青古・ツ」ツォテ」ツ?ョテゥツ?催」ツ?ェテ」ツつ甘・ツ按、テ・ツョツ?
bool intersectGG(const G &g1, const G &g2) {
  if (convex_contain(g1, g2[0])) return 1;
  if (convex_contain(g2, g1[0])) return 1;
  REP(i,g1.size()) REP(j,g2.size()) {
    if (intersectSS(L(g1[i], next(g1, i)), L(g2[j], next(g2, j)))) return 1;
  }
  return 0;
}
// テ・ツ?クテ・ツ、ツ堙ィツァツ津・ツスツ「テ」ツ?ィテァツつケテ」ツ?ョティツキツ敕ゥツ崢「
double distanceGP(const G &g, const P &p) {
  if (convex_contain(g, p)) return 0;
  double res = INF;
  REP(i, g.size()) {
    res = min(res, distanceSP(L(g[i], next(g, i)), p));
  }
  return res;
}
// テ・ツ楪づァツ崢エテ、ツコツ古ァツュツ嘉・ツ按?ァツキツ?
L bisector(const P &a, const P &b) {
  P A = (a+b)*P(0.5,0);
  return L(A, A+(b-a)*P(0, PI/2));
}
// テ」ツδ愿」ツδュテ」ツδ偲」ツつ、テゥツ?佚・ツ淞?
G voronoi_cell(G g, const vector<P> &v, int s) {
  REP(i, v.size())
    if (i!=s)
      g = convex_cut(g, bisector(v[s], v[i]));
  return g;
}
// ティツァツ津・ツコツヲテゥツ鳴「テゥツ?」
double angle(const P &a, const P &b) {        // テ」ツδ凖」ツつッテ」ツδ暗」ツδォテッツスツ?」ツ?凝」ツつ嘉」ツ?ソテ」ツ?淌」ツδ凖」ツつッテ」ツδ暗」ツδォテッツスツづ」ツ?ョティツァツ津・ツコツヲテ」ツ?ョティツィツ暗ァツョツ夕0,2pi)
  double ret = arg(b)-arg(a);
  return (ret>=0) ? ret : ret + 2*PI;
}
double angle2(const P &a, const P &b) { // テ」ツδ凖」ツつッテ」ツδ暗」ツδォaテ」ツ?ィテ」ツδ凖」ツつッテ」ツδ暗」ツδォbテ」ツ?ョテゥツ鳴禿」ツ?ョティツァツ津・ツコツヲ
  return min(angle(a,b), angle(b,a));
}
double rtod(double rad) {       // テ」ツδゥテ」ツつクテ」ツつ「テ」ツδウテ「ツ?津・ツコツヲ
  return rad*180/PI;
}
double dtor(double deg) {       // テ・ツコツヲテ「ツ?津」ツδゥテ」ツつクテ」ツつ「テ」ツδウ
  return deg*PI/180;
}
int quadrant(const P &a) {      // テヲツ卍づィツィツ暗・ツ崢榲」ツつ甘・ツ?エテ」ツ?ッテ・ツ青ォテ」ツ?ソテ」ツ??・ツ債甘ヲツ卍づィツィツ暗・ツ崢榲」ツつ甘・ツ?エテ」ツ?ッテ・ツ青ォテ」ツ?セテ」ツ?ェテ」ツ??
  if (a.real() > 0 && a.imag() >= 0) return 0;
  if (a.real() <= 0 && a.imag() > 0) return 1;
  if (a.real() < 0 && a.imag() <= 0) return 2;
  return 3;
}
bool cmpAngle(const P &a, const P&b) { // テ」ツδュテ」ツδ静」ツつケテ」ツδ暗」ツ?ェティツァツ津・ツコツヲテヲツッツ氾ィツシツ?
  int q1 = quadrant(a);
  int q2 = quadrant(b);
  if (q1 != q2) return q1 < q2;
  return cross(a,b)>0;
}
// テ」ツδ凖」ツつッテ」ツδ暗」ツδォテ」ツ?ョテ・ツ崢榲ィツサツ「
P rotate(P p, double ang) {
  return p * P(cos(ang), sin(ang));
}
// テ・ツ篠淌ァツつケテ・ツ堕ィテ」ツつ甘」ツ?ョテァツ崢エテァツキツ堙」ツ?ョテ・ツ崢榲ィツサツ「
L rotate(L l, double ang) {
  return L(rotate(l[0], ang),rotate(l[1], ang));
}

int n;
P p[15];
int l[15];

void func(vector<G> &gs, P q[3]) {
  L m[3]; REP(i,3) m[i] = L(q[i],q[(i+1)%3]);
  if (cross(q[1]-q[0],q[2]-q[0]) < 0) {
    REP(i,3) swap(m[i][0],m[i][1]);
  }
  vector<G> res;
  
  FOR(it, gs) {
    REP(S,(1<<3)-1) {
      G r = *it;        
      REP(i,3) {
        L tmp = m[i];
        if (S>>i&1) swap(tmp[0],tmp[1]);
        r = convex_cut(r,tmp);
      }
      if (r.size() == 0 || area(r)<EPS) continue;
      // cout << "A " ;
      // FOR(it, r) cout << *it << " "; cout << endl;

      P g;
      FOR(it, r) g += *it;
      g /= r.size();
      // cout << g << " " << centroid(r) << endl;
      if (angle(q[0]-g,q[1]-g) < angle(q[0]-g,q[2]-g)) 
        res.push_back(r);
    }
  }
  gs = res;
}

int main() {
  while(cin >> n, n) {
    static int cs = 1;
    printf("Case %d: ", cs++);
    
    REP(i,n) cin >> p[i].real() >> p[i].imag();
    REP(i,n) {cin >> l[i];l[i]--;}
    if (n <= 3) {
      puts("Infinity");
      continue;
    }
    
    // const double INF = 1e6;
    P tmp[] = {P(INF,INF),P(-INF,INF),P(-INF,-INF),P(INF,-INF)};
    vector<G> gs;
    gs.push_back(G(tmp,tmp+4));
    
    REP(i,n) {
      P t[3] = {p[l[i]],p[l[(i+1)%n]],p[l[(i+2)%n]]};
      func(gs, t);
    }
    double ans = 0;
    FOR(it, gs) {
      // FOR(jt, *it) cout << *jt << " "; cout << endl;
      if (area(*it) < EPS) continue;
      P g;
      FOR(jt,*it) g += *jt;
      g /= it->size();
      // g = centroid(*it);
      bool ok = 1;
      for (int i=1; i<n-1; ++i) {
        if (angle(p[l[0]]-g,p[l[i]]-g) > angle(p[l[0]]-g,p[l[i+1]]-g)) {
          ok = 0;
          break;
        } 
      }
      if (ok) {
        // cout << g << " " << area(*it) <<  endl;        
        ans += area(*it);
      }
    }
    if (ans < EPS) {
      puts("No area"); 
    } else if (ans > 1e8) {
      puts("Infinity");
    } else {
      printf("%.10Lf\n", ans);
    }
  }
}

Measured memory_bytes: 1320