#include<iostream>
#include<cmath>
#include<algorithm>
#include<iomanip>
#include<vector>
#include<cassert>
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define inf (1<<28)
#define EPS (1e-8)
#define COUNTER_CLOCKWISE 1
#define CLOCKWISE -1 
#define ONLINE_BACK 2
#define ONLINE_FRONT -2
#define ON_SEGMENT 0
#define equals(a,b) (fabs((a)-(b)) < EPS)

using namespace std;

class Point
{
  public:
  double x,y;

  Point(double x = -1,double y = -1): 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(a*x,a*y);}
  Point operator / (double a){return Point(x/a,y/a);}//※イケメンに限る

  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;
  }

//必要に応じて
double norm()
{
return x*x+y*y;
}

};

struct Segment
{
  Point p1,p2;
  Segment(Point p1 = Point(-1,-1),Point p2 = Point(-1,-1)):p1(p1),p2(p2){}
};
typedef Point Vector;
typedef Segment Line;
typedef vector<Point> Polygon;


double dot(Point a,Point b)
{
  return a.x*b.x + a.y*b.y;
}
double cross(Point a,Point b)
{
  return a.x*b.y - a.y*b.x;
}

double norm(Point a)
{
  return a.x*a.x+a.y*a.y;
}

bool pequals(Point a,Point b)
{
  return equals(a.x,b.x) && equals(a.y,b.y);
}

//rad は角度をラジアンで持たせること
Point rotate(Point a,double rad)
{
  return Point(cos(rad)*a.x - sin(rad)*a.y,sin(rad)*a.x + cos(rad)*a.y);
}

// 度をラジアンに変換
double toRad(double agl)
{
  return agl*M_PI/180.0;
}

int ccw(Point p0,Point p1,Point p2)
{
  Point a = p1-p0;
  Point 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;
}


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 isIntersect(Segment s1,Segment s2)
{
return isIntersect(s1.p1,s1.p2,s2.p1,s2.p2);
}


Point getCrossPoint(Point a1,Point a2,Point b1,Point b2)
{
  Point base = b2 - b1;
  double d1 = abs(cross(base,a1-b1));
  double d2 = abs(cross(base,a2-b1));
  double t = d1/(d1+d2);
  return a1+(a2-a1)*t;
}

// Line Line 上と同じ assertなし
Point getCrossPointLines( Line s1, Line s2){
    Point a = s1.p2 - s1.p1;
    Point base = s2.p2 -s2.p1;
    return s1.p1 + a * (cross(base, s2.p1 - s1.p1)/cross(base, a));
}

double getArea(vector<Point>& vec)
{
  double sum = 0;
  for(int i=0;i<vec.size();i++)
    sum += cross(vec[i],vec[(i+1)%vec.size()]);
  return fabs(sum)/2.0;
}

int n;
Point pegs[4][32];//a,b,c,d

void solve()
{
  vector<Point> vec[n+2];
  vec[0].push_back(Point(0,0));
  rep(i,n)vec[0].push_back(pegs[0][i]);
  vec[0].push_back(Point(1,0));

  REP(i,1,n+1)
    {
      vec[i].push_back(pegs[2][i-1]);
      Segment seg1(pegs[2][i-1],pegs[3][i-1]);
      rep(j,n)
	{
	  Segment seg2(pegs[0][j],pegs[1][j]);
	  if(isIntersect(seg1,seg2))
	    {
	      vec[i].push_back(getCrossPointLines(seg1,seg2));
	    }
	}
      vec[i].push_back(pegs[3][i-1]);
    }

  vec[n+1].push_back(Point(0,1));
  rep(i,n)vec[n+1].push_back(pegs[1][i]);
  vec[n+1].push_back(Point(1,1));
  /*
  rep(i,n+2)
    {
      rep(j,vec[i].size())
	{
	  cout << setiosflags(ios::fixed) << setprecision(5) << setw(10) << "(" << vec[i][j].x << "," << vec[i][j].y << ")";
	}
      cout << endl;
    }
  cout << endl;
  */

  double area = 0;
  rep(i,n+1)
    {
      assert(vec[i].size() == n+2);
      rep(j,n+1)
	{
	  vector<Point> a(4);
	  a[0] = vec[i][j];
	  a[1] = vec[i+1][j];
	  a[2] = vec[i+1][j+1];
	  a[3] = vec[i][j+1]; 
	  area = max(area,getArea(a));
	}
    }
  cout << setiosflags(ios::fixed) << setprecision(6) << area << endl;
}

int main()
{
  while(cin >> n,n)
    {
      rep(i,n)
	{
	  double x;
	  cin >> x;
	  pegs[0][i] = Point(x,0);
	}

      rep(i,n)
	{
	  double x;
	  cin >> x;
	  pegs[1][i] = Point(x,1);
	}

      rep(i,n)
	{
	  double y;
	  cin >> y;
	  pegs[2][i] = Point(0,y);
	}

      rep(i,n)
	{
	  double y;
	  cin >> y;
	  pegs[3][i] = Point(1,y);
	}

      solve();

    }
  return 0;
}

Measured memory_bytes: 1312