#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
#define rep(i, n) for(int i = 0; i < n; ++i)
#define rep2(i, a, b) for(int i = (a); i <= (b); ++i)
#define ll long long
void chle(int&x,int y){if(x>y)x=y;}

struct frac {
    ll q, p;
    inline void simp() {
        if(p < 0) { p *= -1, q *= -1; }
        ll g = __gcd(q < 0 ? -q : q, p);
        p /= g, q /= g;
    }
    frac(ll q = 0, ll p = 1) : q(q), p(p) { simp(); }
    frac operator-() const { return frac{-q,p}; }
    bool operator==(const frac &r) const { return !operator!=(r); }
    bool operator!=(const frac r) const { return q * r.p != p * r.q; }
    frac operator+(const frac r) const { return frac(*this) += r; }
    frac operator-(const frac r) const { return frac(*this) -= r; }
    frac operator*(const frac r) const { return frac(*this) *= r; }
    frac operator/(const frac r) const { return frac(*this) /= r; }
    frac &operator+=(const frac r) {
        ll g = abs(__gcd(p, r.p));
        q = r.p / g * q + p / g * r.q;
        p = p / g * r.p;
        (*this).simp();
        return *this;
    }
    frac &operator-=(const frac r) {
        ll g = __gcd(p, r.p);
        q = r.p / g * q - p / g * r.q;
        p = p / g * r.p;
        (*this).simp();
        return *this;
    }
    frac &operator*=(const frac r) {
        q *= r.q;
        p *= r.p;
        (*this).simp();
        return *this;
    }
    frac &operator/=(const frac r) {
        q *= r.p;
        p *= r.q;
        (*this).simp();
        return *this;
    }
};


struct P
{
    frac x,y;
    bool operator==(const P &r)
    {
        return r.x==x && r.y==y;
    }
};

struct line
{
    frac a,b,c;
    line(frac a,frac b,frac c) : a(a),b(b),c(c) {}
    line(P point, line L)
    {
        auto x=point.x,y=point.y;
        a=L.a,b=L.b;
        c=x*a+y*b;
    }
    line(P p1, P p2)
    {
        auto p=p1.x,q=p1.y;
        auto r=p2.x,s=p2.y;
        *this={s-q,p-r,p*s-q*r};
    }
    bool parallel(const line& rhs) const
    {
        return rhs.a*b==a*rhs.b;
    }
    P cross(const line& rhs) const
    {
        auto d=rhs.a,e=rhs.b,f=rhs.c;
        return {
            (e*c-f*b)/(a*e-b*d),
            (f*a-c*d)/(a*e-b*d)
        };
    }
};

vector<P> t2;

int dfs(vector<P> t1)
{
    static int loops=0;
    loops++;
    assert(loops<1000000);

    bool match[3]={};
    bool fix[3]={};
    for(int i=0;i<3;i++) // t2
    {
        for(int j=0;j<3;j++) // t1
        {
            if(t1[j]==t2[i])
            {
                // cerr<<i<<" "<<j<<endl;
                match[i]=fix[j]=1;
            }
        }
    }

    bool yet=0;
    int cnt=6;
    for(int j=0;j<3;j++)
    {
        if(fix[j]) continue;
        for(int i=0;i<3;i++)
        {
            if(match[i]) continue;
            // j -->> i
            yet=1;
            auto t1cp=t1;
            // update t1
            auto p1=t1[j],p2=t1[(j+1)%3],p3=t1[(j+2)%3];
            auto q1=t2[i] /*,q2=t2[(i+1)%3],q3=t2[(i+2)%3]*/;
            auto l1=line(p1,q1);
            auto l2=line(p2,p1);
            auto l3=line(p3,p1);
            t1[j]=q1;
            if(l1.parallel(line(p2,p3)))
            {
                chle(cnt,1+dfs(t1));
            }
            else
            {
                auto cp=t1;
                for(bool $:{0,1})
                {
                    if(find(begin(t2), end(t2),p3)==end(t2))
                    {
                        t1=cp;
                        auto l4=line(p2,l1);
                        auto l5=line(p3,l2);
                        if(!l4.parallel(l5))
                        {
                            t1[(j+2)%3]=l4.cross(l5);
                            chle(cnt,2+dfs(t1));
                        }
                    }
                    swap(cp[(j+1)%3],cp[(j+2)%3]);
                    swap(l2,l3);
                    swap(p2,p3);
                }
            }
            t1=t1cp;
        }
    }
    // cerr<<"\t"<<yet<<endl;
    return yet?cnt:0;
}

main()
{
    vector<P> t1(3);
    t2.resize(3);
    while(1)
    {
        for(auto &p:t1)
        {
            cin>>p.x.q>>p.y.q;
        }
        for(auto &p:t2)
        {
            cin>>p.x.q>>p.y.q;
        }
        if(cin.fail()) break;
        // cout<<dfs(t1)<<"\n":
        int ans=dfs(t1);
        if(ans>4) cout<<"Many\n";
        else cout<<ans<<"\n";
    }
}



Measured memory_bytes: 3124