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++: #include<iostream>
#include<cmath>

using namespace std;

double pi=3.1415926535;

double calc(int x) {
  return sin((double)x/180.0*pi);
}
 

int main(void){
  int n,m;
  
  while(true){
    cin >> n;
    if(n==0)break;
    double sum1=0,sum2=0,s1=0,s2=0,v;
   
    for(int i=0;i<n-1;i++){
      cin >> v;
      sum1+=v;
      s1+=calc(v);
    }
    s1+=calc(360.0-sum1);
    cin >> m;
    for(int j=0;j<m-1;j++){
      int v;
      cin >> v;
      sum2+=v;
      s2+=calc(v);
    }
    s2+=calc(360.0-sum2);
    if(s1>s2) cout << 1 << endl;
    else if(s1<s2) cout << 2 << endl;
    else cout << 0 << endl;
  }

  return 0;
}

C++: #include <iostream>
#include<cmath>
 
using namespace std;
 
double EPS = 1e-10;
double pi = 3.1415926535;
 
double calc(int x) {
  return sin((double)x*pi/180.0);
}
  
 
int main(void){

  int n,m;
   
  while( cin >> n , n ){

    doubles1 = 0, s2 = 0, angle, c = 360;
    
    for( int i = 0 ; i < n - 1 ; i++ ){
      cin >> angle;
      c -= angle;
      s1 += calc(angle);
    }
    s1 += calc(c);

    cin >> m;
    s = 360;

    for( int j = 0 ; j < m - 1 ; j++ ){
      cin >> angle;
      c -= angle;
      s2 += calc(angle);
    }
    s2 += calc(c);

    if( s1 > s2 + EPS ) cout << 1 << endl;
    else if( s1 + EPS < s2 ) cout << 2 << endl;
    else cout << 0 << endl;
  }
 
  return 0;
}

C++: #include <bits/stdc++.h>

using namespace std;

namespace geometry
{	
	typedef double D;
	typedef complex<D> P;
	typedef pair<P, P> S;
	typedef S L;
	typedef pair<P, D> C;
	
	#define PI			(acos(-1))
	#define EPS 		(1e-10)
	#define EQ(a, b) 	(abs((a) - (b)) < EPS)
	#define EQV(a, b) 	(EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()))
	
	static const int COUNTER_CLOCKWISE 	=  1;
	static const int CLOCKWISE			= -1;
	static const int ONLINE_BACK		=  2;
	static const int ONLINE_FRONT		= -2;
	static const int ON_SEGMENT			=  0;
	
	D norm(P a) { return a.real() * a.real() + a.imag() * a.imag(); }
	
	D dot(P a, P b) { return a.real() * b.real() + a.imag() * b.imag(); }
	D cross(P a, P b) { return a.real() * b.imag() - a.imag() * b.real(); }
	
	bool isOrthogonal(P a1, P a2, P b1, P b2) { return EQ(dot(a1 - a2, b1 - b2), 0.0); }
	bool isOrthogonal(L a, L b) { return isOrthogonal(a.first, a.second, b.first, b.second); }
	bool isParallel(P a1, P a2, P b1, P b2) { return EQ(cross(a1 - a2, b1 - b2), 0.0); }
	bool isParallel(L a, L b) { return isParallel(a.first, a.second, b.first, b.second); }
	
	bool isPointOnLine(P a, P b, P c) { return EQ(cross(b - a, c - a), 0.0); }
	bool isPointOnLine(L a, P b) { return isPointOnLine(a.first, a.second, b); }
	bool isPointOnSegment(P a, P b, P c) {
		return EQ(cross(b - a, c - a), 0.0) &&
		       (dot(b - a, c - a) > -EPS) &&
			   (dot(a - b, c - b) > -EPS);
	}
	bool isPointOnSegment(S a, P b) { return isPointOnLine(a.first, a.second, b); }
	
	bool intersect(P a1, P a2, P b1, P b2) {
		return (cross(a2 - a1, b1 - a1) * cross(a2 - a1, b2 - a1) < EPS) &&
		       (cross(b2 - b1, a1 - b1) * cross(b1 - b1, a2 - b1) < EPS);
	}
	bool intersect(S a, S b){
		return intersect(a.first, a.second, b.first, b.second);
	}
	
	int ccw(P p0, P p1, P p2){
		P a = p1 - p0;
		P 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;
	}
	
	D distanceLP(P a, P b, P c) { return abs(cross(b - a, c - a)) / abs(b - a); }
	D distanceLP(L a, P b) { return distanceLP(a.first, a.second, b); }
	D distanceSP(P a, P b, P c) {
		if (dot(b - a, c - a) < EPS) return abs(c - a);
		if (dot(a - b, c - b) < EPS) return abs(c - b);
		return abs(cross(b - a, c - a)) / abs(b - a);
	}
	D distanceSP(S a, P b) { return distanceSP(a.first, a.second, b); }
	
	bool intersectCL(C c, L l){
		return c.second - distanceLP(l, c.first) > -EPS;
	}
	bool intersectCS(C c, S s){
		if (EQ(c.second - abs(c.first - s.first), 0.0) ||
			EQ(c.second - abs(c.first - s.second), 0.0)) return true;
		if (c.second - distanceSP(s, c.first) > -EPS){
			return (c.second - abs(c.first - s.first) < EPS ||
				    c.second - abs(c.first - s.second) < EPS);
		}
		return false;
	}
	
	P project(S s, P p){
		P base = s.second - s.first;
		D r = dot(p - s.first, base) / norm(base);
		return s.first + base * r;
	}
	P reflect(S s, P p){
		return p + (project(s, p) - p) * (D)2.0;
	}
	
	P crossPoint(S s1, S s2){
		P base = s2.second - s2.first;
		D d1 = abs(cross(base, s1.first - s2.first));
		D d2 = abs(cross(base, s1.second - s2.first));
		D t = d1 / (d1 + d2);
		return s1.first + (s1.second - s1.first) * t;
	}
	
	void debug(P p){
		printf("x: %f, y: %f\n", p.real(), p.imag()); 
	}
	void debug(C c){
		printf("x: %f, y: %f, r: %f\n", c.first.real(), c.first.imag(), c.second);
	}
	void debug(S s){
		printf("{\n");
		printf("    ");
		debug(s.first);
		printf("    ");
		debug(s.second);
		printf("}\n");
	}
	void debug(vector<P> poly){
		printf("{\n");
		for (int i = 0; i < poly.size(); i++){
			printf("    ");
			debug(poly[i]);
		}
		printf("}\n");
	}
}

using namespace geometry;

int main()
{
	int n[2];
	while (true){
		int c[2] = {360, 360};
		D s[2] = {0.0, 0.0};
		for (int p = 0; p < 2; p++){
			scanf("%d", &n[p]);
			if (!n[p]) return 0;
			for (int i = 0; i < n[p] - 1; i++){
				int a;
				scanf("%d", &a);
				s[p] += sin((double)a / 180 * PI);
				c[p] -= a;
			}
			s[p] += sin((double)c[p] / 180 * PI);
		}
		//printf("%f %f\n", s[0], s[1]);
		if (EQ(s[0], s[1])) puts("0");
		else if (s[0] > s[1]) puts("1");
		else puts("2");
	}
}

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

using namespace std;

int main()
{
  int n;
  double r, s, t, a[2];
  bool f = false;

  while(1){
    a[0] = a[1] = 0;
    for(int j = 0; j <= 1; j++){
      cin >> n;
      if(n == 0){
	f = true;
	break;
      }
      s = 360.0;
      for(int i = 0; i < n-1; i++){
	cin >> r;
	s -= r;
	a[j] += sin(r/180.0*3.1415);
      }
      a[j] += sin(s/180.0*3.1415);
    }
    if(f){
      break;
    }
    if(a[0] == a[1]){
      t = 0;
    } else if(a[0] > a[1]){
      t = 1;
    } else {
      t = 2;
    }
    cout << t << endl;
  }


  return 0;
}