#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 intersectLP(Line l,Point p) {
  return abs(cross(l.p2-p, l.p1-p)) < EPS;
}

// 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);
  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)
    {
      double area = getArg(Point(0,0),ps[i],ps[i+1])*0.5*r*r;
      Vector v1 = Point(0,0)-ps[i];
      Vector v2 = ps[i+1] - ps[i];
      if(cross(v1,v2) < 0)
	original_area.push_back(r*r*M_PI-area);
      else
	original_area.push_back(area);
    }
}

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;
      {
	vector<Point> vec;
	vec.push_back(np);
	vec.push_back(ps[i]);
	vec.push_back(ps[i+1]);
	tri = getArea(vec);
      }

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

      if(intersectLP(Line(ps[i],ps[i+1]),np))
	{
	  tri = 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)
	{
	  if(cross(v1,v2) > 0)
	    {
	      area = circle - yumi + tri;
	    }
	  else
	    {
	      area = yumi - tri;
	    }
	}
      else
	{
	  if(cross(v1,v2) > 0)
	    {
	      area = tri + yumi;
	    }
	  else
	    {
	      area = circle - (tri+yumi);
	    }
	}
      new_area.push_back(area);
    }

  rep(i,n)
    {
      if(i)printf(" ");
      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: 1316