using System;
using System.Collections.Generic;
using static Assistant.Input;
using static Assistant.Debug;
using System.Linq;
using Assistant;

namespace MSOL2020F
{
    class Program
    {
        static void Main(string[] args)
        {
            var N = RInt;

            List<Pos> U = new List<Pos>();
            List<Pos> D = new List<Pos>();
            List<Pos> L = new List<Pos>();
            List<Pos> R = new List<Pos>();
            List<Pos>[] U2 = new List<Pos>[200010].Select(x => new List<Pos>()).ToArray();
            List<Pos>[] D2 = new List<Pos>[200010].Select(x => new List<Pos>()).ToArray();
            List<Pos>[] L2 = new List<Pos>[200010].Select(x => new List<Pos>()).ToArray();
            List<Pos>[] R2 = new List<Pos>[200010].Select(x => new List<Pos>()).ToArray();
            List<Pos>[] Lm = new List<Pos>[400010].Select(x => new List<Pos>()).ToArray();
            List<Pos>[] Lp = new List<Pos>[400010].Select(x => new List<Pos>()).ToArray();
            List<Pos>[] Rm = new List<Pos>[400010].Select(x => new List<Pos>()).ToArray();
            List<Pos>[] Rp = new List<Pos>[400010].Select(x => new List<Pos>()).ToArray();
            for (int i = 0; i < N; i++)
            {
                var x = RInt;
                var y = RInt;
                var s = RString;
                var p = new Pos(x, y);
                if (s == "U")
                {
                    U.Add(p);
                    U2[p.x].Add(p);
                }
                else if (s == "D")
                {
                    D.Add(p);
                    D2[p.x].Add(p);
                }
                else if (s == "L")
                {
                    L.Add(p);
                    Lm[p.m].Add(p);
                    Lp[p.p].Add(p);
                    L2[p.y].Add(p);
                }
                else if (s == "R")
                {
                    R.Add(p);
                    Rm[p.m].Add(p);
                    Rp[p.p].Add(p);
                    R2[p.y].Add(p);
                }
            }

            int ans = int.MaxValue;
            int[][] Lmarr = new int[400010][];
            int[][] Rparr = new int[400010][];
            int[][] Lparr = new int[400010][];
            int[][] Rmarr = new int[400010][];
            for (int i = 0; i < 400010; i++)
            {
                Lmarr[i] = Lm[i].Select(a => a.y).OrderBy(a => a).ToArray();
                Rparr[i] = Rp[i].Select(a => a.y).OrderBy(a => a).ToArray();

                Lparr[i] = Lp[i].Select(a => -a.y).OrderBy(a => a).ToArray();
                Rmarr[i] = Rm[i].Select(a => -a.y).OrderBy(a => a).ToArray();
            }
            // ①
            foreach (var p in U)
            {
                var candm = Lmarr[p.m];
                if (candm.Length != 0)
                {
                    int indm = LowerBound(candm, p.y);
                    if (indm < candm.Length) ans = Math.Min(ans, (candm[indm] - p.y) * 10);
                }

                var candp = Rparr[p.p];
                if (candp.Length == 0) continue;
                int indp = LowerBound(candp, p.y);
                if (indp < candp.Length) ans = Math.Min(ans, (candp[indp] - p.y) * 10);
            }
            // ②
            foreach (var p in D)
            {
                var candm = Lparr[p.p];
                if (candm.Length != 0)
                {
                    int indm = LowerBound(candm, -p.y);
                    if (indm < candm.Length) ans = Math.Min(ans, (candm[indm] + p.y) * 10);
                }

                var candp = Rmarr[p.m];
                if (candp.Length == 0) continue;
                int indp = LowerBound(candp, -p.y);
                if (indp < candp.Length) ans = Math.Min(ans, (candp[indp] + p.y) * 10);
            }

            // ③
            int[][] Darr = new int[200010][];
            int[][] Larr = new int[200010][];
            for (int i = 0; i < 200010; i++)
            {
                Darr[i] = D2[i].Select(a => a.y).OrderBy(a => a).ToArray();
                Larr[i] = L2[i].Select(a => a.x).OrderBy(a => a).ToArray();
            }
            foreach (var u in U)
            {
                if (Darr[u.x].Length == 0) continue;
                int ind = LowerBound(Darr[u.x], u.y);
                if (ind < Darr[u.x].Length) ans = Math.Min(ans, (Darr[u.x][ind] - u.y) * 10 / 2);
            }
            foreach (var r in R)
            {
                if (Larr[r.y].Length == 0) continue;
                int ind = LowerBound(Larr[r.y], r.x);
                if (ind < Larr[r.y].Length) ans = Math.Min(ans, (Larr[r.y][ind] - r.x) * 10 / 2);
            }

            if (ans != int.MaxValue) Console.WriteLine(ans);
            else Console.WriteLine("SAFE");
        }

        public static int LowerBound<T>(T[] a, T v)
        {
            return LowerBound(a, v, Comparer<T>.Default);
        }
        public static int LowerBound<T>(T[] a, T v, Comparer<T> cmp)
        {
            var l = 0;
            var r = a.Length - 1;
            while (l <= r)
            {
                var mid = l + (r - l) / 2;
                var res = cmp.Compare(a[mid], v);
                if (res == -1) l = mid + 1;
                else r = mid - 1;
            }
            return l;
        }

        struct Pos
        {
            public int x;
            public int y;
            public int m => (x - y) + 200000;
            public int p => (x + y);
            public Pos(int x, int y)
            {
                this.x = x;
                this.y = y;
            }
        }

    }


}

namespace Assistant
{
    static class Input
    {
        static List<string> line = new List<string>();
        static int index = 0;
        static String RNext()
        {
            if (line.Count <= index) line.AddRange(Console.ReadLine().Split());
            return line[index++];
        }
        public static int RInt => int.Parse(RNext());
        public static long RLong => long.Parse(RNext());
        public static int[] RInts => Console.ReadLine().Split().Select(int.Parse).ToArray();
        public static long[] RLongs => Console.ReadLine().Split().Select(long.Parse).ToArray();
        public static string RString => RNext();
        //以下未テスト
        public static int[] RIntsC(int c) => Enumerable.Repeat(0, c).Select(x => int.Parse(RNext())).ToArray();
        public static long[] RLongsC(int c) => Enumerable.Repeat(0, c).Select(x => long.Parse(RNext())).ToArray();
        public static char[][] RMap(int h) => Enumerable.Repeat(0, h).Select(x => Console.ReadLine().ToCharArray()).ToArray();
    }

    public struct Mlong
    {
        long _v;
        const long mod = 1000000007;
        public Mlong(long n = 0) : this() { _v = n >= mod ? n % mod : n; }

        public static implicit operator Mlong(long _x) => new Mlong(_x);
        public static implicit operator long(Mlong _x) => _x._v;
        public static Mlong operator +(Mlong m1, Mlong m2) { long m = m1._v + m2._v; return m >= mod ? m - mod : m; }
        public static Mlong operator -(Mlong m1, Mlong m2) { long m = m1._v - m2._v; return m >= 0 ? m : m + mod; }
        public static Mlong operator *(Mlong m1, Mlong m2) => m1._v * m2._v % mod;
        public static Mlong operator /(Mlong m1, Mlong m2) => m1._v * ModPow(m2._v, mod - 2) % mod;

        public static long ModPow(long a, long n)
        {
            if (n == 0) return 1;
            else if (n % 2 == 1) return a * ModPow(a, n - 1) % mod;
            else return ModPow(a * a % mod, n / 2);
        }

        static Mlong[] fac, finv, inv;
        public static void nCkInit(int max)
        {
            fac = new Mlong[max]; finv = new Mlong[max]; inv = new Mlong[max];
            fac[0] = fac[1] = 1;
            finv[0] = finv[1] = 1;
            inv[1] = 1;
            for (int i = 2; i < max; i++)
            {
                fac[i] = fac[i - 1] * i;
                inv[i] = mod - inv[mod % i] * (mod / i);
                finv[i] = finv[i - 1] * inv[i];
            }
        }

        public static Mlong nCk(int n, int k)
        {
            if (n < k) return 0;
            if (n < 0 || k < 0) return 0;
            return fac[n] * finv[k] * finv[n - k];
        }
    }

    static class Debug
    {
        static public void Draw2D<T>(T[,] map, int mode = 1)
        {
#if DEBUG
            int W = map.GetLength(0);
            int H = map.GetLength(1);

            string[,] map2 = new string[W + 1, H + 1];
            for (int i = 0; i < W + 1; i++)
            {
                for (int j = 0; j < H + 1; j++)
                {
                    if (i == 0 && j == 0) map2[i, j] = 0.ToString();
                    else if (i == 0) map2[i, j] = (j - 1).ToString();
                    else if (j == 0) map2[i, j] = (i - 1).ToString();
                    else map2[i, j] = map[i - 1, j - 1].ToString();
                }
            }

            for (int i = 0; i < W + 1; i++)
            {
                for (int j = 0; j < H + 1; j++)
                {
                    if (mode == 0) Console.Write(map2[i, j].Last());
                    if (mode == 1) Console.Write(map2[i, j] + " ");
                }
                Console.WriteLine();
            }
            Console.WriteLine();
#endif
        }

        public static void Draw1D<T>(T[] array, int mode = 0)
        {
#if DEBUG
            Console.WriteLine(string.Join(" ", array));
#endif
        }
    }
}


Measured memory_bytes: 241084