pizza

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef pair<ll, int > pli;

void read(int &x) {
    char c;
    do { c = getchar(); } while (!isalnum(c));
    x = c - '0';
    while (isalnum(c = getchar())) x = x * 10 + c - '0';
}

void write(string xx){ for (char c : xx) putchar(c); putchar('\n'); }

const int N = 100000 + 10;
const int M = 200000 + 10;
const ll inf = 1e16 + 7;

int n, m;

struct Edge{
    int from, to, wei;
    bool isOptimal;
    int getNode(int x) { return x ^ from ^ to; }

    bool operator < (const Edge &X) const
    { return from < X.from or (from == X.from and to < X.to) or (from == X.from and to == X.to and wei < X.wei); }
} edg[2 * M];
map<Edge, int > MapEdge;

vector<int > adj[N];

ll D[3][N];
priority_queue<pli, vector<pli >, greater<pli > > PQ;

void djkstra(int start, char mode){
    while (!PQ.empty()) PQ.pop();
    PQ.push({0, start});

    for (int i = 1; i <= n; i++) D[start][i] = inf;
    D[start][start] = 0;

    while (!PQ.empty()){
        int u = PQ.top().second;
        ll du = PQ.top().first;
        PQ.pop();
        if (du != D[start][u]) continue;

        for (int eid : adj[u]){
            if (mode == 'N' && eid > m) continue;
            if (mode == 'R' && eid <= m) continue;
            int v = edg[eid].to;
            ll ndu = du + 1LL * edg[eid].wei;
            if (ndu < D[start][v]){
                D[start][v] = ndu;
                PQ.push({ndu, v});
            }
        }
    }
}

vector<ll > VX, VY;

void init_optimal(){
    ll optimalWei = D[1][2];
    for (int i = 1; i <= m; i++)
    if (MapEdge[edg[i]] > 1) edg[i].isOptimal = 0;
    else{
        ll d1 = D[1][edg[i].from], d2 = D[2][edg[i].to];
        if (d1 + d2 + edg[i].wei > optimalWei) {
            edg[i].isOptimal = 0;
            continue;
        }
        VX.push_back(d1);
        VY.push_back(d1 + edg[i].wei);
    }

    sort(VX.begin(), VX.end());
    sort(VY.begin(), VY.end());
}

void determine_optimal(){
    for (int i = 1; i <= m; i++)
    if (!edg[i].isOptimal) continue;
    else{
        ll X = D[1][edg[i].from], Y = X + edg[i].wei;
        int numLess = upper_bound(VY.begin(), VY.end(), X) - VY.begin();
        int numMore = VX.size() - ( lower_bound(VX.begin(), VX.end(), Y) - VX.begin() );
        int numLeft = VX.size() - numMore - numLess - 1;
        edg[i].isOptimal = (numLeft == 0);
    }
}

void init(){
    djkstra(1, 'N');
    djkstra(2, 'R');
    init_optimal();
    determine_optimal();
}

void solve(){
    for (int i = 1; i <= m; i++)
        if (edg[i].isOptimal)
            write("SAD");
        else
        if (D[1][edg[i].from] + edg[i].wei + D[2][edg[i].to] == D[1][2])
            write("SOSO");
        else
        {
            ll forcedBA = D[1][edg[i].to] + edg[i].wei + D[2][edg[i].from];
            if (forcedBA < D[1][2]) write("HAPPY");
            else write("SOSO");
        }
}

main(){
    freopen("pizza.in", "r", stdin);
    freopen("pizza.out", "w", stdout);
    read(n), read(m);
    for (int i = 1; i <= m; i++){
        int u, v, w;
        read(u), read(v), read(w);
        edg[i] = {u, v, w, 1};
        adj[u].push_back(i);
        MapEdge[edg[i]]++;

        edg[i + m] = {v, u, w, 0};
        adj[v].push_back(i + m);
    }
    init();
    solve();
}