#include <bits/stdc++.h>
using namespace std;
using LL = long long int;
#define incID(i, l, r) for(int i = (l)    ; i <  (r); ++i)
#define decID(i, l, r) for(int i = (r) - 1; i >= (l); --i)
#define incII(i, l, r) for(int i = (l)    ; i <= (r); ++i)
#define decII(i, l, r) for(int i = (r)    ; i >= (l); --i)
#define inc(i, n)  incID(i, 0, n)
#define dec(i, n)  decID(i, 0, n)
#define inc1(i, n) incII(i, 1, n)
#define dec1(i, n) decII(i, 1, n)
#define inID(v, l, r) ((l) <= (v) && (v) <  (r))
#define inII(v, l, r) ((l) <= (v) && (v) <= (r))
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define MT make_tuple
#define FI first
#define SE second
#define FR front()
#define BA back()
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
auto setmin   = [](auto & a, auto b) { return (b <  a ? a = b, true : false); };
auto setmax   = [](auto & a, auto b) { return (b >  a ? a = b, true : false); };
auto setmineq = [](auto & a, auto b) { return (b <= a ? a = b, true : false); };
auto setmaxeq = [](auto & a, auto b) { return (b >= a ? a = b, true : false); };
#define SI(v) static_cast<int>(v.size())
#define RF(e, v) for(auto & e: v)
#define until(e) while(! (e))
#define if_not(e) if(! (e))
#define ef else if
#define UR assert(false)
#define IN(T, ...) T __VA_ARGS__; IN_(__VA_ARGS__);
void IN_() { };
template<typename T, typename ... U> void IN_(T &  a, U &  ... b) { cin >> a; IN_(b ...); };
template<typename T                > void OUT(T && a            ) { cout << a << endl; }
template<typename T, typename ... U> void OUT(T && a, U && ... b) { cout << a << " "; OUT(b ...); }

// ---- ----

template<typename T, typename I = LL> class Sequence {
private:
	I mi = 1, ma = 0, n = 0;
	vector<T> s;
public:
	Sequence() { }
	Sequence(I mi, I ma)      : mi(mi), ma(ma), n(ma - mi + 1) { s = vector<T>(n); }
	Sequence(I mi, I ma, T v) : mi(mi), ma(ma), n(ma - mi + 1) { s = vector<T>(n, v); }
	T & operator[](I i) { assert(inII(i, mi, ma)); return s[i - mi]; }
	T & front() { return s.front(); }
	T & back () { return s.back (); }
	I size() { return n; }
	vector<T> & get() { return s; }
};

template<typename T> class opt {
private:
	bool f;
	T v;
public:
	opt() { f = false; }
	opt(T v) : v(v) { f = true; }
	void reset() { f = false; }
	bool setmin  (T a) { return (! f || a <  v ? v = a, f = true : false); }
	bool setmax  (T a) { return (! f || a >  v ? v = a, f = true : false); }
	bool setmineq(T a) { return (! f || a <= v ? v = a, f = true : false); }
	bool setmaxeq(T a) { return (! f || a >= v ? v = a, f = true : false); }
	bool has_val() { return f; }
	bool is_null() { return ! f; }
	T & val() { assert(f); return v; }
	friend T operator||(opt a, T e) { return (a.f ? a.v : e); }
	friend istream & operator>>(istream & s, opt<T> & a) { a.f = true; return (s >> a.v); }
	friend ostream & operator<<(ostream & s, opt<T>   a) { return (a.f ? s << a.v : s << "[null]"); }
};

int main() {
	const int M = 200'000;
	Sequence<map<int, char>> mx(0, M), my(0, M), ms(0, 2 * M), md(-M, +M);
	
	IN(int, n);
	inc(i, n) {
		IN(int, x, y);
		IN(string, s);
		char c = s[0];
		
		mx[x][y] = c;
		my[y][x] = c;
		ms[x + y][x - y] = c;
		md[x - y][x + y] = c;
	}
	
	opt<int> ans;
	auto f = [&](auto & sm, char a, char b) {
		opt<int> mi;
		RF(m, sm.get()) {
			opt<int> p;
			for(auto [x, c]: m) {
				if(c == a) { p = x; }
				if(c == b) { if(p.has_val()) { mi.setmin(x - p.val()); } }
			}
		}
		if(mi.has_val()) { ans.setmin(mi.val()); }
	};
	f(mx, 'U', 'D');
	f(my, 'R', 'L');
	f(ms, 'R', 'U');
	f(ms, 'D', 'L');
	f(md, 'U', 'L');
	f(md, 'R', 'D');
	if(ans.has_val()) { OUT(ans.val() * 5); } else { OUT("SAFE"); }
}


Measured memory_bytes: 96944