Go: package main

import (
	"bufio"
		"os"
	"strconv"
	"math"
	"fmt"
)

var scanner = bufio.NewScanner(os.Stdin)

func main() {
	for scanner.Scan() {
		m, _ := strconv.Atoi(scanner.Text())
		if m == 0 {
			break
		}
		args1 := make([]float64, m)
		x := 0.0
		for i := 0; i < m-1; i++ {
			scanner.Scan()
			tmp, _ := strconv.ParseFloat(scanner.Text(), 64)
			x += tmp
			args1[i] = tmp
		}
		args1[m-1] = 360-x
		first_object := 0.0
		for _, v := range args1 {
			first_object+= math.Sin(v*math.Pi/180)
		}
		scanner.Scan()
		n, _ := strconv.Atoi(scanner.Text())
		args2 := make([]float64, n)
		y := 0.0
		for i := 0; i < n-1; i++ {
			scanner.Scan()
			tmp, _ := strconv.ParseFloat(scanner.Text(), 64)
			y += tmp
			args2[i] = tmp
		}
		args2[n-1] = 360-y
		second_object := 0.0
		for _, v := range args2 {
			second_object+= math.Sin(v*math.Pi/180)
		}
		if first_object > second_object+ 0.0000001 {
			fmt.Println(1)
		} else if second_object > first_object +0.0000001 {
			fmt.Println(2)
		} else {
			fmt.Println(0)
		}
	}
}

C++: #define _USE_MATH_DEFINES
#include<bits/stdc++.h>
#define EPS (1e-10)
#define equals(a,b)(fabs((a)-(b))<EPS)
#define rep(i,n)for(int i=0;i<n;i++)
using namespace std;

struct Point {
	double x, y;
	Point(double x = 0, double y = 0) :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); }

	double norm() { return x*x + y*y; }
	double abs() { return sqrt(norm()); }

	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;
	}
};
typedef vector<Point>Polygon;
typedef Point Vector;
double norm(Vector a) {
	return a.x*a.x + a.y*a.y;
}
double abs(Vector a) {
	return sqrt(norm(a));
}
struct Segment {
	Point p1, p2;
};
typedef Segment Line;
double dot(Vector a, Vector b) {
	return a.x*b.x + a.y*b.y;
}
double cross(Vector a, Vector b) {
	return a.x*b.y - a.y*b.x;
}
bool isOrthogonal(Vector a, Vector b) {
	return equals(dot(a, b), 0.0);
}
bool isOrthogonal(Point a1, Point a2, Point b1, Point b2) {
	return isOrthogonal(a1 - a2, b1 - b2);
}
bool isOrthogonal(Segment s1, Segment s2) {
	return equals(dot(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0);
}
bool isParallel(Vector a, Vector b) {
	return equals(cross(a, b), 0.0);
}
bool isParallel(Point a1, Point a2, Point b1, Point b2) {
	return isParallel(a1 - a2, b1 - b2);
}
bool isParallel(Segment s1, Segment s2) {
	return equals(cross(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0);
}
Point project(Segment s, Point p) {
	Point base = s.p2 - s.p1;
	double r = dot(p - s.p1, base) / base.norm();
	return s.p1 + base*r;
}
Point reflect(Segment s, Point p) {
	return p + (project(s, p) - p)*2.0;
}
#define COUNTER_CLOCKWISE 1
#define CLOCKWISE -1
#define ONLINE_BACK 2
#define ONLINE_FRONT -2
#define ON_SEGMENT 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 (a.norm() < b.norm())return ONLINE_FRONT;
	return ON_SEGMENT;
}
bool intersect(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 intersect(Segment s1, Segment s2) {
	return intersect(s1.p1, s1.p2, s2.p1, s2.p2);
}
double getDistance(Point a, Point b) {
	return abs(a - b);
}
double getDistanceLP(Line l, Point p) {
	return abs(cross(l.p2 - l.p1, p - l.p1) / abs(l.p2 - l.p1));
}
double getDistanceSP(Segment s, Point p) {
	if (dot(s.p2 - s.p1, p - s.p1) < 0.0)return abs(p - s.p1);
	if (dot(s.p1 - s.p2, p - s.p2) < 0.0)return abs(p - s.p2);
	return getDistanceLP(s, p);
}
double getDistance(Segment s1, Segment s2) {
	if (intersect(s1, s2))return 0.0;
	return min(min(getDistanceSP(s1, s2.p1), getDistanceSP(s1, s2.p2)),
		min(getDistanceSP(s2, s1.p1), getDistanceSP(s2, s1.p2)));
}
int contains(Polygon g, Point p) {
	int n = g.size();
	bool x = false;
	rep(i, n) {
		Point a = g[i] - p, b = g[(i + 1) % n] - p;
		if (abs(cross(a, b)) < EPS&&dot(a, b) < EPS)return 1;
		if (a.y > b.y)swap(a, b);
		if (a.y < EPS&&EPS<b.y&&cross(a, b)>EPS)x = !x;
	}
	return x ? 2 : 0;
}
bool isconvex(Polygon g) {
	int back = 3;
	rep(i, g.size()) {
		int d = ccw(g[(i + g.size() - 1) % g.size()], g[i], g[(i + 1) % g.size()]);
		if (back != 3 && d != back)
			return false;
		else back = d;
	}
	return true;
}
double area(Polygon g) {
	double cnt = 0;
	rep(i, g.size())
		cnt += g[i].x*g[(i + 1) % g.size()].y - g[(i + 1) % g.size()].x*g[i].y;
	return abs(cnt) / 2;
}
class Circle {
public:
	Point c;
	double r;
	Circle(Point c = Point(), double r = 0.0) :c(c), r(r) {}
};
pair<Point, Point>getCrossPoints(Circle c, Line l) {
	Vector pr = project(l, c.c);
	Vector e = (l.p2 - l.p1) / abs(l.p2 - l.p1);
	double base = sqrt(c.r*c.r - norm(pr - c.c));
	return make_pair(pr + e*base, pr - e*base);
}
Point getCrossPoint(Segment s1, Segment s2) {
	Vector base = s2.p2 - s2.p1;
	double d1 = abs(cross(base, s1.p1 - s2.p1));
	double d2 = abs(cross(base, s1.p2 - s2.p1));
	double t = d1 / (d1 + d2);
	return s1.p1 + (s1.p2 - s1.p1)*t;
}
double getDistance(Circle c1, Circle c2) {
	return max(0.0, getDistance(c1.c, c2.c) - c1.r - c2.r);
}
double getDistance(Circle c, Point p) {
	return max(0.0, getDistance(c.c, p) - c.r);
}
int main() {
	int m;
	while (cin >> m, m) {
		Polygon g1(m);
		double s = 0;
		rep(i, m - 1) {
			double v; cin >> v;
			g1[i] = { cos(s*M_PI / 180),sin(s*M_PI / 180) };
			s += v;
		}
		g1[m - 1] = { cos(s*M_PI / 180),sin(s*M_PI / 180) };
		int n; cin >> n;
		Polygon g2(n);
		s = 0;
		rep(i, n - 1) {
			double v; cin >> v;
			g2[i] = { cos(s*M_PI / 180),sin(s*M_PI / 180) };
			s += v;
		}
		g2[n - 1] = { cos(s*M_PI / 180),sin(s*M_PI / 180) };
		double a1 = area(g1), a2 = area(g2);
		if (a1 > a2)puts("1");
		else if (a1 < a2)puts("2");
		else puts("0");
	}
}

C++: #include <iostream>
#include <cmath>

using namespace std;

const double EPS = 1e-10;
const double PI = 3.14159265358979323;

int main()
{
    int m,n;
    while(cin >> m && m) {
        
        double s1, s2, theta;
        s1 = 0.0;
        int a,sum = 0;
        for(int i = 0; i < m - 1; i++) {
            cin >> a;
            theta = (PI * a) / 180.0;
            s1 += cos(theta / 2.0) * sin(theta / 2.0);
            sum += a;
        }
        theta = (PI * (360 - sum)) / 180.0;
        s1 += cos(theta / 2.0) * sin(theta / 2.0);

        cin >> n;
        s2 = 0.0;
        sum = 0;
        for(int i = 0; i < n - 1; i++) {
            cin >> a;
            theta = (PI * a) / 180.0;
            s2 += cos(theta / 2.0) * sin(theta / 2.0);
            sum += a;
        }
        theta = (PI * (360 - sum)) / 180.0;
        s2 += cos(theta / 2.0) * sin(theta / 2.0);

        if(s1 - EPS > s2) {
            cout << "1" << endl;
        } else if(fabs(s1 - s2) < EPS) {
            cout << "0" << endl;
        } else {
            cout << "2" << endl;
        }
    }
}

C++: #include <iostream>
#define _USE_MATH_DEFINES
#include <math.h>

using namespace std;
static const double eps = 1e-7;

void solve()
{
	int m;
	while(cin >> m, m)
	{
		double s1 = 0.0;
		int radius = 360;
		for(int i = 0; i < m - 1; ++i)
		{
			int v;
			cin >> v;
			radius -= v;
			s1 += sin(M_PI * v / 180);
		}
		s1 += sin(M_PI * radius / 180);
		
		int n;
		cin >> n;
		double s2 = 0.0;
		radius = 360;
		for(int i = 0; i < n - 1; ++i)
		{
			int v;
			cin >> v;
			radius -= v;
			s2 += sin(M_PI * v / 180);
		}
		s2 += sin(M_PI * radius / 180);
		if(fabs(s1 - s2) < eps)
		{
			cout << 0 << endl;
		}
		else if(s1 > s2)
		{
			cout << 1 << endl;
		}
		else
		{
			cout << 2 << endl;
		}
	}
}

int main()
{
	solve();
	return(0);
}