#include <iostream>
#include <vector>
#include <algorithm>

template <typename T>
struct vec2
{
    T x, y;
    vec2() :x(0), y(0) {}
    vec2(const T& x, const T& y) :x(x), y(y) {}
    template <typename U>
    vec2(const vec2<U>& u) : x(T(u.x)), y(T(u.y)) {}
    inline T& operator[](const int& i) { return (&x)[i]; }
    inline const T& operator[](const int& i) const { return (&x)[i]; }
    inline bool operator==(const vec2& a) const { return x == a.x && y == a.y; }
    inline bool operator!=(const vec2& a) const { return x != a.x || y != a.y; }
    inline bool operator<(const vec2& a) const { return x < a.x || (x == a.x && y < a.y); }
    inline bool operator>(const vec2& a) const { return x > a.x || (x == a.x && y > a.y); }
    inline vec2 operator+() const { return vec2(x, y); }
    inline vec2 operator-() const { return vec2(-x, -y); }
    inline vec2 operator+(const vec2& a) const { return vec2(x + a.x, y + a.y); }
    inline vec2 operator-(const vec2& a) const { return vec2(x - a.x, y - a.y); }
    inline vec2 operator*(const vec2& a) const { return vec2(x * a.x, y * a.y); }
    inline vec2 operator/(const vec2& a) const { return vec2(x / a.x, y / a.y); }
    inline vec2 operator+(const T& a) const { return vec2(x + a, y + a); }
    inline vec2 operator-(const T& a) const { return vec2(x - a, y - a); }
    inline vec2 operator*(const T& a) const { return vec2(x * a, y * a); }
    inline vec2 operator/(const T& a) const { return vec2(x / a, y / a); }
    inline vec2& operator+=(const vec2& a) { x += a.x; y += a.y; return *this; }
    inline vec2& operator-=(const vec2& a) { x -= a.x; y -= a.y; return *this; }
    inline vec2& operator*=(const vec2& a) { x *= a.x; y *= a.y; return *this; }
    inline vec2& operator/=(const vec2& a) { x /= a.x; y /= a.y; return *this; }
    inline vec2& operator+=(const T& a) { x += a; y += a; return *this; }
    inline vec2& operator-=(const T& a) { x -= a; y -= a; return *this; }
    inline vec2& operator*=(const T& a) { x *= a; y *= a; return *this; }
    inline vec2& operator/=(const T& a) { x /= a; y /= a; return *this; }
    inline T dot(const vec2& a) const { return x * a.x + y * a.y; }
    inline T cross(const vec2& a) const { return x * a.y - y * a.x; }
    inline T length2() const { return x * x + y * y; }
    inline friend vec2 operator+(const T& a, const vec2& b) { return vec2(a + b.x, a + b.y); }
    inline friend vec2 operator-(const T& a, const vec2& b) { return vec2(a - b.x, a - b.y); }
    inline friend vec2 operator*(const T& a, const vec2& b) { return vec2(a * b.x, a * b.y); }
    inline friend vec2 operator/(const T& a, const vec2& b) { return vec2(a / b.x, a / b.y); }
    inline friend T ccw(const vec2& a, const vec2& b, const vec2& c) { return (c - b).cross(a - b); }
    inline friend std::istream& operator>>(std::istream& is, vec2& a) { is >> a.x >> a.y; return is; }
    inline friend std::ostream& operator<<(std::ostream& os, vec2& a) { os << a.x << ' ' << a.y; return os; }
};

using namespace std;
typedef vec2<int> point;
#define inf 100'000'000

int main()
{
    int n;
    scanf("%d", &n);
    vector<point> a[12];
    for (int i = 0; i < n; i++)
    {
        point p;
        char d;
        scanf("%d %d %c", &p.x, &p.y, &d);
        if (d == 'U')
        {
            a[0].emplace_back(p);
            a[4].emplace_back(p.x - p.y, p.x + p.y);
            a[9].emplace_back(p.x + p.y, p.x - p.y);
        }
        else if (d == 'R')
        {
            a[2].emplace_back(p.y, p.x);
            a[8].emplace_back(p.x + p.y, p.x - p.y);
            a[6].emplace_back(p.x - p.y, p.x + p.y);
        }
        else if (d == 'D')
        {
            a[1].emplace_back(p);
            a[7].emplace_back(p.x - p.y, p.x + p.y);
            a[10].emplace_back(p.x + p.y, p.x - p.y);
        }
        else if (d == 'L')
        {
            a[3].emplace_back(p.y, p.x);
            a[5].emplace_back(p.x - p.y, p.x + p.y);
            a[11].emplace_back(p.x + p.y, p.x - p.y);
        }
    }
    for (int i = 0; i < 12; i++) sort(a[i].begin(), a[i].end());
    int l = inf;
    for (int i = 0; i < 12; i += 2)
    {
        for (const auto& p : a[i])
        {
            int j = i + 1;
            const auto k = lower_bound(a[j].begin(), a[j].end(), p);
            if (k != a[j].end())
            {
                if (p.x == k->x)
                {
                    l = min(l, k->y - p.y);
                }
            }
        }
    }
    if (l == inf) printf("SAFE\n");
    else printf("%d\n", l * 5);
    return 0;
}

Measured memory_bytes: 9448