#include <bits/stdc++.h>
  
using namespace std;
  
#define rep(i,n) REP(i,0,n)
#define REP(i,s,e) for(int i=(s); i<(int)(e); i++)
#define repr(i, n) REPR(i, n, 0)
#define REPR(i, s, e) for(int i=(int)(s-1); i>=(int)(e); i--)
#define pb push_back
#define all(r) r.begin(),r.end()
#define rall(r) r.rbegin(),r.rend()
#define fi first
#define se second
  
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
 
// #define DEBUG_MODE
#ifdef DEBUG_MODE
#define dump(x) cout << #x << " : " << x << endl
#define LINE cout << "line : " << __LINE__ << endl
#define dumpV(v) cout << #v << " : ["; for(auto& t : v) cout << t << ", "; cout<<"]" << endl
#define STOP assert(false)
#else
#define dump(x) ;
#define LINE     ;
#define dumpV(v);
#define STOP     ;
#endif
#define mp make_pair

namespace std{
  template<class S,class T>
  ostream &operator <<(ostream& out,const pair<S,T>& a){
    out<<'('<<a.fi<<", "<<a.se<<')';
    return out;
  }
}


typedef double D;
const D EPS = 1e-10;
using P = valarray<D>;
const P Origin = {(D)0.0, (D)0.0, (D)0.0};
#define x(P) (P)[0]
#define y(P) (P)[1]
#define z(P) (P)[2]
#define SQ(Q) ((Q)*(Q))
#define curr(P, idx) (P)[(idx)]
#define next(P, idx) (P)[((idx)+1)%(P).size()]
#define prev(P, idx) (P)[((idx)+(P).size()-1)%(P).size()]
namespace std {
    bool operator < (const P& a, const P& b) {
        if(x(a) != x(b)) return x(a) < x(b);
        if(y(a) != y(b)) return y(a) < y(b);
        return z(a) < z(b);
    }
}


struct L : array<P, 2> {
    L() {at(0) = at(1) = Origin;}
    L(const P& a, const P& b) {
        at(0) = a;
        at(1) = b;
    }
};
D dot(const P& a, const P& b) {
    auto p = a*b;
    return p.sum();
}
P cross(const P& a, const P& b) {
    // P ret(3);
    // x(ret) = y(a) * z(b) - y(b) * z(a);
    // y(ret) = z(a) * x(b) - z(b) * x(a);
    // z(ret) = x(a) * y(b) - x(b) * y(a);
    // return ret;
    return a.cshift(1)*b.cshift(-1)-a.cshift(-1)*b.cshift(1);
}
D norm(const P& p) {
    return sqrt(dot(p, p));
}
//----------------------------------------
//直線・線分の当たり判定、円・直線、線分の当たり判定、距離等 verify aoj 2641
bool isHitLP(const L&l ,const P& p) {
    P v = l[1] - l[0], v1 = p - l[0];
    return abs(norm(cross(v, v1))) < EPS;
}
bool isHitSP(const L& l, const P& p) {
    P v = l[1] - l[0], v1 = p - l[0];
    P u = l[0] - l[1], u1 = p - l[1];
    return abs(norm(cross(v, v1))) < EPS && norm(v1) < norm(v) + EPS
            && abs(norm(cross(u, u1))) < EPS && norm(u1) < norm(u) + EPS; 
}
D distLP(const L& l, const P& p) {
    if(isHitLP(l, p)) return (D)0.0;
    P AB = l[1] - l[0];
    P AP = p - l[0];
    if(abs(norm(AB)) < EPS) return norm(AP);
    return norm(cross(AB, AP)) / norm(AB);
}
D distSP(const L& l, const P& p) {
    if(isHitSP(l, p)) return (D)0.0;
    return min({norm(p - l[0]), norm(p - l[1]), distLP(l, p)});
}
struct C{
    P p;
    D r;
};
bool isHitPC(const P& p, const C& c) {
    return norm(p - c.p) < c.r + EPS;
}
vector<P> crossPointLC(const L&l ,const C& cir) {
    P s = l[0] - cir.p;
    P d = l[1] - l[0];
    auto A = dot(d, d), B = dot(d, s), C = dot(s, s) - SQ(cir.r);
    auto DD = (SQ(B) - A * C);
    vector<D> t;
    if(abs(DD) < 0) t.pb(B / A);
    else if(DD < 0) ;
    else {
        t.pb((-B + sqrt(DD)) / A);
        t.pb((-B - sqrt(DD)) / A);
    }
    vector<P> ret;
    rep(i, t.size()) ret.push_back(s + d * t[i]);
    rep(i, ret.size()) ret[i] += cir.p;
    return ret;
}
vector<P> crossPointSC(const L&l ,const C& c) {
    vector<P> ps = crossPointLC(l, c);
    sort(all(ps));
    auto it = ps.begin();
    while(it != ps.end()) {
        assert(abs(norm(*it - c.p) - c.r) < EPS);
        if(isHitSP(l, *it)) ++it;
        else it = ps.erase(it);
    }
    return ps;
}
bool isHitLC(const L& l, const C& c) {
    return distLP(l, c.p) < c.r + EPS;
}
bool isHitSC(const L& l, const C& c) {
    return crossPointSC(l, c).size() > 0;
}

struct Plane {
    P p;
    P n; // 法線ベクトル
    Plane(const P& _p, const P& _n) : p(_p), n(_n){ 
        n /= norm(n);
        assert(abs(norm(n) -1.0) < EPS);
    }
    Plane(const P& a, const P& b, const P& c) {
        p = a;
        n = cross(b - a, c - a);
        n /= norm(n);
        assert(abs(norm(n) -1.0) < EPS);
    }
};
struct Triangle : array<P, 3>{
    Triangle(){rep(i, 3) at(i) = Origin;}
    Triangle(const P& a, const P& b, const P& c) {
        at(0) = a;
        at(1) = b;
        at(2) = c;
    }
};
D distPlaneP(const Plane& pl, const P& p) {
    return abs(dot(p - pl.p, pl.n));
}
bool isHitPlaneS(const Plane& pl, const L& s) {
    return (dot(s[0] - pl.p, pl.n) * dot(s[1] - pl.p, pl.n) < EPS);
}
P crossPointPlaneS(const Plane& pl, const L& s) {
    assert(isHitPlaneS(pl, s));
    assert((abs(dot(s[0]-pl.p, pl.n))+abs(dot(s[1]-pl.p, pl.n))) > EPS);
    return s[0] + (s[1]-s[0])*(abs(dot(s[0]-pl.p, pl.n)) / (abs(dot(s[0]-pl.p, pl.n))+abs(dot(s[1]-pl.p, pl.n))));
}
bool isHitTriangleP(const Triangle& tri, const P& p) {
    Plane pl = {tri[0], tri[1], tri[2]};
    if(!(distPlaneP(pl, p) < EPS)) return false;
    vector<P> c(3);
    rep(i, 3) {
        c[i] = cross(next(tri, i) - curr(tri, i), p - next(tri, i));
    }
    auto a = dot(c[0], c[1]);
    auto b = dot(c[0], c[2]);
    return a > -EPS && b > -EPS;
}


int main(){
    P s, t;
    D x, y, z;
    cin >> x >> y >> z;
    s = {x, y, z};
    cin >> x >> y >> z;
    t = {x, y, z};
    Triangle tr;
    rep(i, 3) {
        cin >> x >> y >> z;
        tr[i] = P{x, y, z};
    }
    Plane pl(tr[0], tr[1], tr[2]);
    L l(s, t);
    if(!isHitPlaneS(pl, l)) {
        cout << "HIT" << endl;
        return 0;
    }
    auto p = crossPointPlaneS(pl, l);
    if(isHitTriangleP(tr, p)) {
        cout << "MISS" << endl;
    }    
    else {
        cout << "HIT" << endl;
    }
    return 0;
}


Measured memory_bytes: 3304