#include <bits/stdc++.h>
using namespace std;
using lint = long long;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
struct fast_ios { fast_ios(){ cin.tie(nullptr); ios::sync_with_stdio(false); cout << fixed << setprecision(20); }; } fast_ios_;
#define ALL(x) (x).begin(), (x).end()
#define FOR(i, begin, end) for(int i=(begin),i##_end_=(end);i<i##_end_;i++)
#define IFOR(i, begin, end) for(int i=(end)-1,i##_begin_=(begin);i>=i##_begin_;i--)
#define REP(i, n) FOR(i,0,n)
#define IREP(i, n) IFOR(i,0,n)
template <typename T> void ndarray(vector<T> &vec, int len) { vec.resize(len); }
template <typename T, typename... Args> void ndarray(vector<T> &vec, int len, Args... args) { vec.resize(len); for (auto &v : vec) ndarray(v, args...); }
template <typename V, typename T> void ndfill(V &x, const T &val) { x = val; }
template <typename V, typename T> void ndfill(vector<V> &vec, const T &val) { for (auto &v : vec) ndfill(v, val); }
template <typename T> bool chmax(T &m, const T q) { if (m < q) {m = q; return true;} else return false; }
template <typename T> bool chmin(T &m, const T q) { if (m > q) {m = q; return true;} else return false; }
template <typename T1, typename T2> pair<T1, T2> operator+(const pair<T1, T2> &l, const pair<T1, T2> &r) { return make_pair(l.first + r.first, l.second + r.second); }
template <typename T1, typename T2> pair<T1, T2> operator-(const pair<T1, T2> &l, const pair<T1, T2> &r) { return make_pair(l.first - r.first, l.second - r.second); }
template <typename T> vector<T> srtunq(vector<T> vec) { sort(vec.begin(), vec.end()), vec.erase(unique(vec.begin(), vec.end()), vec.end()); return vec; }
template <typename T> istream &operator>>(istream &is, vector<T> &vec) { for (auto &v : vec) is >> v; return is; }
template <typename... T> istream &operator>>(istream &is, tuple<T...> &tpl) { std::apply([&is](auto &&... args) { ((is >> args), ...);}, tpl); return is; }
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) { os << '['; for (auto v : vec) os << v << ','; os << ']'; return os; }
template <typename... T> ostream &operator<<(ostream &os, const tuple<T...> &tpl) { std::apply([&os](auto &&... args) { ((os << args << ','), ...);}, tpl); return os; }
template <typename T> ostream &operator<<(ostream &os, const deque<T> &vec) { os << "deq["; for (auto v : vec) os << v << ','; os << ']'; return os; }
template <typename T> ostream &operator<<(ostream &os, const set<T> &vec) { os << '{'; for (auto v : vec) os << v << ','; os << '}'; return os; }
template <typename T> ostream &operator<<(ostream &os, const unordered_set<T> &vec) { os << '{'; for (auto v : vec) os << v << ','; os << '}'; return os; }
template <typename T> ostream &operator<<(ostream &os, const multiset<T> &vec) { os << '{'; for (auto v : vec) os << v << ','; os << '}'; return os; }
template <typename T> ostream &operator<<(ostream &os, const unordered_multiset<T> &vec) { os << '{'; for (auto v : vec) os << v << ','; os << '}'; return os; }
template <typename T1, typename T2> ostream &operator<<(ostream &os, const pair<T1, T2> &pa) { os << '(' << pa.first << ',' << pa.second << ')'; return os; }
template <typename TK, typename TV> ostream &operator<<(ostream &os, const map<TK, TV> &mp) { os << '{'; for (auto v : mp) os << v.first << "=>" << v.second << ','; os << '}'; return os; }
template <typename TK, typename TV> ostream &operator<<(ostream &os, const unordered_map<TK, TV> &mp) { os << '{'; for (auto v : mp) os << v.first << "=>" << v.second << ','; os << '}'; return os; }
#define dbg(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ") " << __FILE__ << endl;

struct custom_hash
{
    // <https://codeforces.com/blog/entry/62393>
    static uint64_t splitmix64(uint64_t x)
    {
        // http://xorshift.di.unimi.it/splitmix64.c
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const
    {
        static const uint64_t FIXED_RANDOM = std::chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
};

// Usage
#include <unordered_map>
unordered_map<int, int, custom_hash> robust_unordered_map;

#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
gp_hash_table<int, null_type, custom_hash> robust_hash_table; // fast unordered_set / unordered_map

int main()
{
    int ret = 2e9;

    int N;
    cin >> N;
    vector<int> X(N), Y(N), VX(N), VY(N);

    REP(i, N)
    {
        cin >> X[i] >> Y[i];
        char c;
        cin >> c;
        if (c == 'U') VY[i] = 1;
        if (c == 'D') VY[i] = -1;
        if (c == 'R') VX[i] = 1;
        if (c == 'L') VX[i] = -1;
    }

    REP(_, 4)
    {
        vector<int> U(N), V(N);
        REP(i, N) U[i] = X[i] + Y[i], V[i] = Y[i] - X[i];

        if (_ < 2)
        {
            // unordered_map<int, vector<int>> up, down;
            vector<vector<int>> up(200010), down(200010);
            REP(i, N)
            {
                if (VY[i] > 0) up[X[i]].emplace_back(Y[i]);
                if (VY[i] < 0) down[X[i]].emplace_back(Y[i]);
            }
            REP(x, up.size()) if (up[x].size() and down[x].size())
            {
                vector<int> v2 = srtunq(down[x]);
                for (auto y : up[x])
                {
                    auto yy = lower_bound(ALL(v2), y);
                    if (yy != v2.end())
                    {
                        chmin(ret, (*yy - y) * 5);
                    }
                }
            }
        }

        vector<vector<int>> mpup(400010), mpright(400010);
        REP(i, N)
        {
            if (VY[i] > 0) mpup[U[i]].emplace_back(V[i]);
            if (VX[i] > 0) mpright[U[i]].emplace_back(V[i]);
        }
        REP(x, mpup.size()) if (mpup[x].size() and mpright[x].size())
        {
            vector<int> v2 = srtunq(mpright[x]);
            for (auto u : mpup[x])
            {
                auto uu = lower_bound(ALL(v2), u);
                if (uu != v2.end())
                {
                    chmin(ret, (*uu - u) * 5);
                }
            }
        }

        REP(i, N)
        {
            swap(X[i], Y[i]), swap(VX[i], VY[i]), X[i] *= -1, VX[i] *= -1, X[i] += 200000;
        }
    }

    cout << (ret < 1e9 ? to_string(ret) : "SAFE") << '\n';
}


Measured memory_bytes: 38776