#include <bits/stdc++.h>
#define x first
#define y second
#define int int long long // 2e9 & 9e18
using namespace std; const int inf = numeric_limits<int>::max();
struct __io{__io(){ios_base::Init i; ios_base::sync_with_stdio(0); cin.tie(0);}} __io; // fast I/O
#ifdef LOCAL // setting up print debugging (yes lol)
template<class K, class V>ostream& operator<<(ostream&s,const pair<K,V>&p){s<<'<'<<p.x<<", "<<p.y<<'>';return s;}
template<class T, class=typename T::value_type, class=typename enable_if<!is_same<T,string>::value>::type>
ostream& operator<<(ostream&s,const T&v){s<<'[';for(auto&x:v){s<<x<<", ";}if(!v.empty()){s<<"\b\b";}s<<']';return s;}
void __prnt(){cerr<<endl;} template<class T, class...Ts>void __prnt(T&&a,Ts&&...etc){cerr<<a<<' ';__prnt(etc...);}
#define print(...) __prnt(__VA_ARGS__)
#else
#define print(...)
#endif

struct plane {
    int x;
    int y;
    char d;
};
ostream& operator<<(ostream&s,const plane &p){
    s<<'<'<<p.x<<", "<<p.y<< ", " << p.d << '>';
    return s;
}

int reference(int n, vector<plane> &v);

signed main() {
    int n;
    cin >> n;
    vector<plane> v, u, d, l, r;
    // map<int, plane> mu, md, ml, mr;
    for (int i = 0; i < n; ++i) {
        plane p;
        cin >> p.x >> p.y >> p.d;
        switch (p.d) {
            case 'U': u.push_back(p); /*mu[] = p;*/ break;
            case 'D': d.push_back(p); /*md[] = p;*/ break;
            case 'L': l.push_back(p); /*ml[] = p;*/ break;
            case 'R': r.push_back(p); /*mr[] = p;*/ break;
        }
        v.push_back(p);
    }
    print(u);
    print(d);
    print(l);
    print(r);

    int t = inf;
    {
        map<int, vector<plane>> ma;
        for (plane &p : u) {
            ma[p.x + p.y].push_back(p);
        }
        for (plane &p : r) {
            auto jt = ma.find(p.x + p.y);
            if (jt != ma.end()) {
                for (auto it = jt->y.begin(); it != jt->y.end(); ++it) {
                    int w = it->x - p.x;
                    if (w > 0) {
                        t = min(t, w*10);
                    }
                }
            }
        }
    }
    {
        map<int, plane> ma;
        for (plane &p : d) {
            ma[p.x + p.y] = p;
        }
        for (plane &p : l) {
            auto it = ma.find(p.x + p.y);
            if (it != ma.end()) {
                int w = p.x - it->y.x;
                if (w > 0) {
                    t = min(t, w*10);
                }
            }
        }
    }
    {
        map<int, plane> ma;
        for (plane &p : u) {
            ma[p.x - p.y] = p;
        }
        for (plane &p : l) {
            auto it = ma.find(p.x - p.y);
            if (it != ma.end()) {
                int w = p.x - it->y.x;
                if (w > 0) {
                    t = min(t, w*10);
                }
            }
        }
    }
    {
        map<int, plane> ma;
        for (plane &p : d) {
            ma[p.x - p.y] = p;
        }
        for (plane &p : r) {
            auto it = ma.find(p.x - p.y);
            if (it != ma.end()) {
                int w = it->y.x - p.x;
                if (w > 0) {
                    t = min(t, w*10);
                }
            }
        }
    }
    // t = min(t, reference(n, v));
    print("cross-direction:", t);

    {
        map<int, vector<plane>> m;
        for (auto &p : d) m[p.x].push_back(p);
        for (auto &p : u) m[p.x].push_back(p);
        for (auto &[_, v] : m) {
            sort(v.begin(), v.end(), [](plane &a, plane &b){return a.y < b.y;});
            print("vert", v);
            for (int i = 1; i < (int)v.size(); ++i) {
                if (v[i-1].d == 'U' && v[i].d == 'D') {
                    t = min(t, (v[i].y - v[i-1].y) * 5);
                }
            }
        }
    }
    {
        map<int, vector<plane>> m;
        for (auto &p : l) m[p.y].push_back(p);
        for (auto &p : r) m[p.y].push_back(p);
        for (auto &[_, v] : m) {
            sort(v.begin(), v.end(), [](plane &a, plane &b){return a.x < b.x;});
            print("hor", v);
            for (int i = 1; i < (int)v.size(); ++i) {
                if (v[i-1].d == 'R' && v[i].d == 'L') {
                    t = min(t, (v[i].x - v[i-1].x) * 5);
                }
            }
        }
    }


    if (t < inf) {
        cout << t << endl;
    } else {
        cout << "SAFE" << endl;
    }
}


///////////////////////////////// DEBUG ///////////////////////////
// https://atcoder.jp/contests/m-solutions2020/submissions/15455643

using lint = long long;
template<class T = lint, class R = lint>
struct Point2D {
    T x, y;
    constexpr Point2D(T x = 0, T y = 0) noexcept : x(x), y(y) {};
    constexpr Point2D(pair<T, T> p) noexcept : x(p.first), y(p.second) {};
    constexpr bool operator==(const Point2D& rhs) const noexcept { return x == rhs.x && y == rhs.y; }
    constexpr bool operator!=(const Point2D& rhs) const noexcept { return !((*this) == rhs); }
    constexpr bool operator< (const Point2D& rhs) const noexcept { return x < rhs.x || (x == rhs.x && y < rhs.y); }
    constexpr bool operator> (const Point2D& rhs) const noexcept { return rhs < (*this); }
    constexpr bool operator<=(const Point2D& rhs) const noexcept { return !((*this) > rhs); }
    constexpr bool operator>=(const Point2D& rhs) const noexcept { return !((*this) < rhs); }
    constexpr Point2D  operator+ (const Point2D& rhs) const noexcept { return { x + rhs.x, y + rhs.y }; }
    constexpr Point2D  operator- (const Point2D& rhs) const noexcept { return { x - rhs.x, y - rhs.y }; }
    constexpr Point2D  operator* (const T& lmap) const noexcept { return { lmap * x, lmap * y }; }
    constexpr Point2D  operator/ (const T& lmap) const noexcept { return { x / lmap, y / lmap }; }
    constexpr Point2D& operator+=(const Point2D& rhs) noexcept { return ((*this) = (*this) + rhs); }
    constexpr Point2D& operator-=(const Point2D& rhs) noexcept { return ((*this) = (*this) - rhs); }
    constexpr Point2D& operator*=(const T& lmap) noexcept { return ((*this) = (*this) * lmap); }
    constexpr Point2D& operator/=(const T& lmap) noexcept { return ((*this) = (*this) / lmap); }
    constexpr Point2D  operator- () const noexcept { return { -x, -y }; }
    constexpr T operator* (const Point2D& rhs) const noexcept { return x * rhs.x + y * rhs.y; }
    constexpr Point2D nor() const noexcept { return { y, -x }; }
    constexpr long double hypot() const noexcept { return ::hypotl(x, y); }
    friend istream& operator>>(istream& is, Point2D& p) { return is >> p.x >> p.y; }
    friend ostream& operator<<(ostream& os, const Point2D& p) { return os << p.x << " " << p.y << "\n"; }
    R& operator[](vector<vector<R>>& v) { return v[x][y]; }
};
 
using pnt = Point2D<>;
 
template<class T>
inline bool chmin(T& a, const T b) { return a > b && (a = b, true); }
 
int reference(int n, vector<plane> &v) {
 
    int N = n;
 
    vector<pnt> U, R, L, D;
    for (int ir = 0; ir < N; ir++) {
        pnt xy(v[ir].x, v[ir].y);
        char d = v[ir].d;
        if (d == 'R') R.emplace_back(xy);
        if (d == 'L') L.emplace_back(xy);
        if (d == 'U') U.emplace_back(xy);
        if (d == 'D') D.emplace_back(xy);
    }
    sort(R.begin(), R.end(), [](auto l, auto r) {return l.x < r.x; });
    sort(L.begin(), L.end(), [](auto l, auto r) {return l.x < r.x; });
    sort(U.begin(), U.end(), [](auto l, auto r) {return l.x < r.x; });
    sort(D.begin(), D.end(), [](auto l, auto r) {return l.x < r.x; });
 
    lint ans = inf;
    auto update = [&ans](auto &l, auto &r, pnt grad, int speed) {
 
        map<lint, vector<lint>> lmap, rmap;
        for (const auto& xy : l) lmap[xy * grad].emplace_back(xy.x);
        for (const auto& xy : r) rmap[xy * grad].emplace_back(xy.x);
 
        for (const auto& [key, vecl] : lmap) {
            auto it = rmap.find(key);
            if (it != rmap.end()) {
 
                auto vecr = it->second;
 
                auto ir = vecr.begin();
                for (const auto& xl : vecl) {
                    while (ir != vecr.end() && *ir < xl) ir++;
                    if (ir == vecr.end()) break;
                    chmin(ans, (*ir - xl) * speed);
                }
            }
        }
    
    };
 
    // update(R, U, pnt(1, 1), 10);
    // update(D, L, pnt(1, 1), 10);
    // update(R, D, pnt(1, -1), 10);
    // update(U, L, pnt(1, -1), 10);
 
    return ans;
}


Measured memory_bytes: 34152