#include <iostream>
#include <complex>
using namespace std;

const int TOO_MANY       = 100;
const int MAX_REFLECTION = 1000000;
const double         PI2 = 2*arg(complex<double>(-1,0));

// 2d-vector
typedef complex<double> vec;
istream& operator>>( istream& is, vec& p ) { int x,y; is>>x>>y; p=vec(x,y); return is; }
double inner( const vec& a, const vec& b ) { return a.real()*b.real() + a.imag()*b.imag(); }
double outer( const vec& a, const vec& b ) { return imag(conj(a)*b); }

// mirror
struct mirror
{
	vec u, v;
	friend istream& operator>>( istream& is, mirror& m ) { return is >> m.u >> m.v; }

	void operator-=( const vec& o ) { u-=o; v-=o; }

	// reflection
	vec operator()( const vec& p )
	 { return conj((p-u)/(v-u))*(v-u)+u; }
	mirror operator()( const mirror& m )
	 { mirror m2 = {operator()(m.u), operator()(m.v)}; return m2; }

	// distance from the origin in the direction theta
	double dist( double theta )
	 { return outer(u, v-u)/outer(vec(cos(theta),sin(theta)),v-u); }

	bool cross( const vec& b )
	 { return outer(-u,v-u)*outer(b-u,v-u) < 0 && outer(u,b)*outer(v,b) < 0; }
};

// arg_range
struct arange
{
	double m, M; // 0 to 4PI

	arange( const mirror& mr ) {
		m = arg(mr.u/mr.v)>0 ? arg(mr.v) : arg(mr.u);
		if(m<0) m+=PI2;
		M = abs(arg(mr.u/mr.v)) + m;
	}
	bool contains(double a) const
	 { return m<a-PI2 && a-PI2<M || m<a && a<M || m<a+PI2 && a+PI2<M; }
	bool empty() const
	 { return m==M; }

	// intersection
	void operator*=( const arange& rhs ) {
		if( contains(rhs.m) )
			if( contains(rhs.M) ) (*this) = rhs;
			else                        m = rhs.m;
		else
			if( contains(rhs.M) )       M = rhs.M;
			else if( !rhs.contains(m) ) M = m;
		if(M-m< 0  ) M+=PI2;
		if(M-m>=PI2) M-=PI2;
	}
};

int main()
{
	for(vec p; cin>>p, p!=vec(0,0);)
	{
		mirror ma,mb; cin>>ma>>mb; ma-=p, mb-=p; // always move p to the origin

		mirror m1=ma,        m2=mb;        // mirror image of mirrors : frontier
		vec    q1=ma(vec()), q2=mb(vec()); // pos of mirror image
		arange r1(ma),       r2(mb);       // range of arg where the mirror image must be

		int seen = 0;
		for(int i=0; i<MAX_REFLECTION && seen<TOO_MANY && (!r1.empty() || !r2.empty()); ++i)
		{
			// check if he can see the mirror image
			if( !(mb.cross(q1) && mb.dist(arg(q1)) < ma.dist(arg(q1))) )
				if( r1.contains(arg(q1)) )
					++seen;
			if( !(ma.cross(q2) && ma.dist(arg(q2)) < mb.dist(arg(q2))) )
				if( r2.contains(arg(q2)) )
					++seen;

			// do one reflection
			mirror m1_ = ma(m2),      m2_ = mb(m1);
			vec    q1_ = ma(q2),      q2_ = mb(q1);
			       r1 *= arange(m1_), r2 *= arange(m2_);
			if( m1.dist(r1.m) > m1_.dist(r1.m) ) r1.m = r1.M;
			if( m2.dist(r2.m) > m2_.dist(r2.m) ) r2.m = r2.M;
			m1 = m1_, m2 = m2_;
			q1 = q1_, q2 = q2_;
		}

		(seen<TOO_MANY ? cout<<seen : cout<<"TOO MANY") << endl;
	}
}