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

#define NDEBUG
#include <cassert>


typedef long long ll;
typedef long double Double;
typedef unsigned long long ull;
typedef pair<int, int> ii;
typedef pair<ll, ll> llll;
typedef pair<double, double> dd;

typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<ii> vii;
typedef vector<vector<ii>> vvii;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef vector<llll> vllll;
typedef vector<bool> vb;
typedef vector<string> vs;
typedef vector<double> vd;
typedef vector<long double> vD;

#define sz(a) int((a).size())
#define pb push_back
#define eb emplace_back
#define FOR(var, from, to) for (int var = (from); var <= (to); ++var)
#define rep(var, n) for (int var = 0; var < (n); ++var)
#define rep1(var, n) for (int var = 1; var <= (n); ++var)
#define repC2(vari, varj, n)               \
  for (int vari = 0; vari < (n)-1; ++vari) \
    for (int varj = vari + 1; varj < (n); ++varj)
#define repC3(vari, varj, vark, n)                  \
  for (int vari = 0; vari < (n)-2; ++vari)          \
    for (int varj = vari + 1; varj < (n)-1; ++varj) \
      for (int vark = varj + 1; vark < (n); ++vark)
#define ALL(c) (c).begin(), (c).end()
#define RALL(c) (c).rbegin(), (c).rend()
#define tr(i, c) for (auto i = (c).begin(); i != (c).end(); ++i)
#define found(s, e) ((s).find(e) != (s).end())
#define mset(arr, val) memset(arr, val, sizeof(arr))
#define mid(x, y) ((x) + ((y) - (x)) / 2)
#define IN(x, a, b) ((a) <= (x) && (x) <= (b))
#define cons make_pair
#define clamp(v, lo, hi) min(max(v, lo), hi)
#define ABS(x) max((x), -(x))
#define PQ(T) priority_queue<T, vector<T>, greater<T>>

template <typename T1, typename T2>
inline void amin(T1& a, T2 const& b) {
  if (a > b) a = b;
}
template <typename T1, typename T2>
inline void amax(T1& a, T2 const& b) {
  if (a < b) a = b;
}
template <typename X, typename T>
auto vectors(X x, T a) {
  return vector<T>(x, a);
}
template <typename X, typename Y, typename Z, typename... Zs>
auto vectors(X x, Y y, Z z, Zs... zs) {
  auto cont = vectors(y, z, zs...);
  return vector<decltype(cont)>(x, cont);
}

inline ll square(ll x) { return x * x; }
inline ll gcd(ll a, ll b) {
  while (a) swap(a, b %= a);
  return b;
}
inline ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
template <typename T>
inline T mod(T a, T b) {
  return ((a % b) + b) % b;
}

template <typename T>
int find_left(vector<T>& v, T elem) {
  return (int)(upper_bound(v.begin(), v.end(), elem) - v.begin()) - 1;
}
template <typename T>
int find_right(vector<T>& v, T elem) {
  return (int)(lower_bound(v.begin(), v.end(), elem) - v.begin());
}

const ll MOD = 1000000007LL;

inline ll ADD(ll x, ll y) { return (x + y) % MOD; }
inline ll SUB(ll x, ll y) { return (x - y + MOD) % MOD; }
inline ll MUL(ll x, ll y) { return x * y % MOD; }
inline ll POW(ll x, ll e) {
  ll v = 1;
  for (; e; x = MUL(x, x), e >>= 1)
    if (e & 1) v = MUL(v, x);
  return v;
}
inline ll INV(ll y) { /*assert(y%MOD!=0);*/
  return POW(y, MOD - 2);
}
inline ll DIV(ll x, ll y) { return MUL(x, INV(y)); }

#define INTSPACE 12
char _buf[INTSPACE * 1000000 + 3];

int loadint() {
  if (fgets(_buf, INTSPACE + 3, stdin) == NULL) return 0;
  return atoi(_buf);
}

int loadvec(vector<int>& v, int N = -1) {
  if (N == 0) {
    v.clear();
    return 0;
  }
  if (N == -1) {
    N = loadint();
    if (N == 0) return 0;
  }
  int bufsize = INTSPACE * N + 3;
  if (fgets(_buf, bufsize, stdin) == NULL) return 0;
  v.resize(N);

  int i = 0;
  bool last = false;
  for (char* p = &_buf[0];;) {
    char* q = p;
    while (*q > ' ') ++q;
    if (*q == 0x0D || *q == 0x0A) last = true;
    *q = 0;
    v[i++] = atoi(p);
    if (last || i == N) break;
    p = q + 1;
  }
  return i;
}
void read_cr() { fgets(_buf, 256, stdin); }

void horizontal(vector<int>& v) {
  int L = v.size();
  for (int i = 0; i < L; ++i) {
    printf("%d%c", v[i], (i == L - 1) ? '\n' : ' ');
  }
}
void horizontall(vector<long long>& v) {
  int L = v.size();
  for (int i = 0; i < L; ++i) {
    printf("%lld%c", v[i], (i == L - 1) ? '\n' : ' ');
  }
}


int solve(int N, vi& xs, vi& ys, vector<char>& dir) {
  map<int, vi> r_h, l_h, u_v, d_v;
  map<int, vi> r_add, r_sub, l_add, l_sub, u_add, u_sub, d_add, d_sub;
  rep(i, N) {
    int x = xs[i], y = ys[i];
    switch (dir[i]) {
      case 'R':
        r_h[y].pb(x);
        r_add[x + y].pb(x);
        r_sub[x - y].pb(x);
        break;
      case 'L':
        l_h[y].pb(x);
        l_add[x + y].pb(x);
        l_sub[x - y].pb(x);
        break;
      case 'U':
        u_v[x].pb(y);
        u_add[x + y].pb(x);
        u_sub[x - y].pb(x);
        break;
      case 'D':
        d_v[x].pb(y);
        d_add[x + y].pb(x);
        d_sub[x - y].pb(x);
        break;
    }
  }

  for (auto& p : r_h) {
    sort(ALL(p.second));
  }
  for (auto& p : r_add) {
    sort(ALL(p.second));
  }
  for (auto& p : r_sub) {
    sort(ALL(p.second));
  }

  for (auto& p : l_h) {
    sort(ALL(p.second));
  }
  for (auto& p : l_add) {
    sort(ALL(p.second));
  }
  for (auto& p : l_sub) {
    sort(ALL(p.second));
  }

  for (auto& p : u_v) {
    sort(ALL(p.second));
  }
  for (auto& p : u_add) {
    sort(ALL(p.second));
  }
  for (auto& p : u_sub) {
    sort(ALL(p.second));
  }

  for (auto& p : d_v) {
    sort(ALL(p.second));
  }
  for (auto& p : d_add) {
    sort(ALL(p.second));
  }
  for (auto& p : d_sub) {
    sort(ALL(p.second));
  }

  int bump = INT_MAX;

  for (auto& p : r_h) {
    int y = p.first;
    for (int x : p.second) {
      int add = x + y, sub = x - y;
      int S = l_h[y].size();
      if (S > 0) {
        int ix = upper_bound(ALL(l_h[y]), x) - l_h[y].begin();
        if (ix < S) {
          int x2 = l_h[y][ix];
          amin(bump, 5 * (x2 - x));
        }
      }
      S = u_add[add].size();
      if (S > 0) {
        int ix = upper_bound(ALL(u_add[add]), x) - u_add[add].begin();
        if (ix < S) {
          int x2 = u_add[add][ix];
          amin(bump, 10 * (x2 - x));
        }
      }
      S = d_sub[sub].size();
      if (S > 0) {
        int ix = upper_bound(ALL(d_sub[sub]), x) - d_sub[sub].begin();
        if (ix < S) {
          int x2 = d_sub[sub][ix];
          amin(bump, 10 * (x2 - x));
        }
      }
    }
  }

  for (auto& p : u_v) {
    int x = p.first;
    for (int y : p.second) {
      int add = x + y, sub = x - y;

      int S = d_v[x].size();
      if (S > 0) {
        int ix = upper_bound(ALL(d_v[x]), y) - d_v[x].begin();
        if (ix < S) {
          int y2 = d_v[x][ix];
          amin(bump, 5 * (y2 - y));
        }
      }

      S = l_sub[sub].size();
      if (S > 0) {
        int ix = upper_bound(ALL(l_sub[sub]), x) - l_sub[sub].begin();
        if (ix < S) {
          int x2 = l_sub[sub][ix];
          amin(bump, 10 * (x2 - x));
        }
      }

    }
  }

  for (auto& p : d_v) {
    int x = p.first;
    for (int y : p.second) {
      int add = x + y, sub = x - y;



      int S = l_add[add].size();
      if (S > 0) {
        int ix = upper_bound(ALL(l_add[add]), x) - l_add[add].begin();
        if (ix < S) {
          int x2 = l_add[add][ix];
          amin(bump, 10 * (x2 - x));
        }
      }
    }
  }

  return bump;
}

int main() {
  int N;
  scanf("%d%*c", &N);
  vi x(N), y(N);
  vector<char> u(N);
  rep(i, N) { scanf("%d %d %c%*c", &x[i], &y[i], &u[i]); }
  int bump = solve(N, x, y, u);
  if (bump == INT_MAX)
    printf("SAFE\n");
  else
    printf("%d\n", bump);
  return 0;
}


Measured memory_bytes: 85488