#include<cmath>
#include<cstdio>
#include<iostream>
#include<vector>
#include<algorithm>
#include<complex>
#include<cassert>
#include<climits>

#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define inf (INT_MAX)
#define EPS (1e-10)
#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;

// Library - template - begin

class Point
{
  public:
  double x,y;

  Point(double x = -inf,double y = -inf): 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 !equals(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;
  }

};

struct Segment
{
  Point p1,p2;
  Segment(Point p1 = Point(-inf,-inf),Point p2 = Point(-inf,-inf)):p1(p1),p2(p2){}
  bool operator == (const Segment& p)const
  {
    return p.p1 == p1 && p.p2 == p2;
  }
};

typedef Point Vector;
typedef Segment Line;
typedef vector<Point> Polygon;

ostream& operator << (ostream& os,const Point& a)
{
  os << "(" << a.x << "," << a.y << ")";
}

ostream& operator << (ostream& os,const Segment& a)
{
  os << "( " << a.p1 << " , " << a.p2 << " )";
}

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

double abs(Point a){ return sqrt(norm(a)); }

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

// Library - template - end

// Library - CCW - bein

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

// Library - CCW - end

// Library - getArea - begin

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

// Library - getArea - end

// Library - intersect - begin

bool intersectLL(Line l, Line m) {
  return abs(cross(l.p2-l.p1, m.p2-m.p1)) > EPS || // non-parallel
         abs(cross(l.p2-l.p1, m.p1-l.p1)) < EPS;   // same line
}
bool intersectLS(Line l, Line s) {
  return cross(l.p2-l.p1, s.p1-l.p1)*       // s[0] is left of l
         cross(l.p2-l.p1, s.p2-l.p1) < EPS; // s[1] is right of l
}
bool intersectLP(Line l,Point p) {
  return abs(cross(l.p2-p, l.p1-p)) < EPS;
}
bool intersectSS(Line s, Line t) {
  return ccw(s.p1,s.p2,t.p1)*ccw(s.p1,s.p2,t.p2) <= 0 &&
         ccw(t.p1,t.p2,s.p1)*ccw(t.p1,t.p2,s.p2) <= 0;
}
bool intersectSP(Line s, Point p) {
  return abs(s.p1-p)+abs(s.p2-p)-abs(s.p2-s.p1) < EPS; // triangle inequality
}

Point projection(Line l,Point p) {
  double t = dot(p-l.p1, l.p1-l.p2) / norm(l.p1-l.p2);
  return l.p1 + (l.p1-l.p2)*t;
}
Point reflection(Line l,Point p) {
  return p + (projection(l, p) - p) * 2;
}
double distanceLP(Line l, Point p) {
  return abs(p - projection(l, p));
}
double distanceLL(Line l, Line m) {
  return intersectLL(l, m) ? 0 : distanceLP(l, m.p1);
}

double distanceLS(Line l, Line s) {
  if (intersectLS(l, s)) return 0;
  return min(distanceLP(l, s.p1), distanceLP(l, s.p2));
}
double distanceSP(Line s, Point p) {
  Point r = projection(s, p);
  if (intersectSP(s, r)) return abs(r - p);
  return min(abs(s.p1 - p), abs(s.p2 - p));
}

double distanceSS(Line s, Line t) {
  if (intersectSS(s, t)) return 0;
  return min(min(distanceSP(s, t.p1), distanceSP(s, t.p2)),
             min(distanceSP(t, s.p1), distanceSP(t, s.p2)));
}
Point crosspoint(Line l, Line m) {
  double A = cross(l.p2 - l.p1, m.p2 - m.p1);
  double B = cross(l.p2 - l.p1, l.p2 - m.p1);
  if (abs(A) < EPS && abs(B) < EPS) return m.p1; // same line
  if (abs(A) < EPS) assert(false); // !!!PRECONDITION NOT SATISFIED!!!
  return m.p1 +   (m.p2 - m.p1) * (B / A);
}


// Library - intersect - end

double r;
Point np;
int n;
vector<double> p;
vector<Point> ps;
vector<double> original_area;

double getArg(Point A,Point B,Point C)
{
  double a = abs(B-C);
  double b = abs(C-A);
  double c = abs(A-B);
  double arg = (b*b+c*c-a*a)/(2.0*b*c);
  //assert(!equals(arg,0.0));
  return acos(arg);
}

void make_ps()
{
  ps.push_back(Point(0,r));
  double arg = toRad(90);

  rep(i,n)
    {
      arg -= toRad(360.0*(p[i]/100.0));
      ps.push_back(Point(r*cos(arg),r*sin(arg)));
    }

  rep(i,n)
    {
      //cout << Point(0,0) << " " << ps[i] << " " << ps[i+1] << endl;
      double area = getArg(Point(0,0),ps[i],ps[i+1])*0.5*r*r;
      //cout << "i = " << i << " " << area << endl;
      Vector v1 = Point(0,0)-ps[i];
      Vector v2 = ps[i+1] - ps[i];
      //cout << "cross : "<< cross(v1,v2) << endl;
      if(cross(v1,v2) < 0)
	original_area.push_back(r*r*M_PI-area);
      else
	original_area.push_back(area);
    }
  /*
  rep(i,ps.size())
    {
      cout << "ps[" << i << "] = " << ps[i] << endl;
    }
  
  rep(i,original_area.size())
    {
      cout << "area[" << i << "] = " << original_area[i] << endl;
    }
  */

}

void compute()
{
  vector<double> new_area;

  rep(i,n)
    {
      int res1 = ccw(ps[i],ps[i+1],np);
      int res2 = ccw(ps[i],ps[i+1],Point(0,0));

      double tri,tri2;
      {
	vector<Point> vec;
	vec.push_back(np);
	vec.push_back(ps[i]);
	vec.push_back(ps[i+1]);
	tri = getArea(vec);
      }

      {
	vector<Point> vec;
	vec.push_back(Point(0,0));
	vec.push_back(ps[i]);
	vec.push_back(ps[i+1]);
	tri2 = getArea(vec);
      }


      double arg = getArg(Point(0,0),ps[i],ps[i+1]);

      if(intersectLP(Line(ps[i],ps[i+1]),np))
	{
	  tri = 0;
	}

      if(intersectLP(Line(ps[i],ps[i+1]),Point(0,0)))
	{
	  tri2 = 0;
	}

      double yumi = (r*r*0.5)*(arg-sin(arg));     

      double circle = r * r * M_PI;

      double area = inf;

      Vector v1 = np - ps[i];
      Vector v2 = ps[i+1] - ps[i];

      if(res1 != res2)
	{
	  //cout << "p1" << endl;
	  if(cross(v1,v2) > 0)
	    {
	      area = circle - yumi + tri;
	    }
	  else
	    {
	      area = yumi - tri;
	    }
	}
      else
	{
	  //cout << "p2" << endl;
	  if(cross(v1,v2) > 0)
	    {
	      area = tri + yumi;
	    }
	  else
	    {
	      area = circle - (tri+yumi);
	    }
	}
     
      new_area.push_back(area);

    }

  rep(i,n)
    {
      if(i)printf(" ");
      //cout << new_area[i] << " / " << original_area[i] << " = " << new_area[i]/original_area[i]*100 << endl;
      printf("%d",(int)(new_area[i]/original_area[i]*100));
    }
  puts("");

}

int main()
{

  cin >> r >> np.x >> np.y >> n;
  p.resize(n);
  rep(i,n)cin >> p[i];

  make_ps();

  compute();

  return 0;
}

Measured memory_bytes: 1320