#include <cstdio>
#include <complex>
#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;

#define eps 1e-8
static const double PI=2*acos(0);

typedef complex<double> P;

namespace std {
  int operator<(const P& a, const P& b) {
    if (fabs(real(a)-real(b))>eps) return real(a)<real(b);
    if (fabs(imag(a)-imag(b))>eps) return imag(a)<imag(b);
    return 0;
  }
}

int n;

vector<pair<int,int> > get_max_pairs(vector<P>& ps) {
  vector<pair<int,int> > res;
  double maxd=-1e20;
  for (int i=0;i<ps.size();++i)
    for (int j=i+1;j<ps.size();++j) {
      double d=abs(ps[i]-ps[j]);
      if (d>maxd+eps) {
	res.clear();
	maxd=d;
	res.push_back(make_pair(i,j));
	res.push_back(make_pair(j,i));
      } else if (d>maxd-eps) {
	res.push_back(make_pair(i,j));
	res.push_back(make_pair(j,i));
      }
    }
  return res;
}

int check(int a0, int a1, vector<P>& as, int b0, int b1, vector<P>& bs) {
  vector<P> nbs;
  for (int i=0;i<bs.size();++i) {
    P p=bs[i];
    p-=bs[b0];
    p*=(as[a1]-as[a0])/(bs[b1]-bs[b0]);
    p+=as[a0];
    nbs.push_back(p);
  }
  sort(nbs.begin(),nbs.end());
  for (int i=0;i<nbs.size();++i)
    if (abs(nbs[i]-as[i])>eps) 
      return 0;
  return 1;
}

int main() {
  while(scanf("%d",&n),n) {
    vector<P> as,bs;
    for (int i=0;i<n;++i) {
      double x,y; scanf("%lf%lf",&x,&y);
      as.push_back(P(x,y));
    }
    for (int i=0;i<n;++i) {
      double x,y; scanf("%lf%lf",&x,&y);
      bs.push_back(P(x,y));
    }
    if (n==1) {
      puts("0");
      continue;
    }

    sort(as.begin(),as.end());
    vector<pair<int,int> > mas=get_max_pairs(as);
    vector<pair<int,int> > mbs=get_max_pairs(bs);
   
    double ans=1e20;

    for (int i=0;i<mbs.size();++i) {
      int a0=mas[0].first,a1=mas[0].second;
      int b0=mbs[i].first,b1=mbs[i].second;
      double a=arg((bs[b1]-bs[b0])/(as[a1]-as[a0]));
      if (a<0) a+=2*PI;
      a=min(a,2*PI-a);
      if (a<ans&&check(a0,a1,as,b0,b1,bs)) ans=a;
    }
    printf("%.8lf\n",ans);
  }
}