n = gets.to_i
ups = []
downs = []
lefts = []
rights = []
n.times do
  x, y, u = gets.split
  x = x.to_i
  y = y.to_i
  case u
  when "U"
    ups << [x, y, x + y]
  when "D"
    downs << [x, y, x + y, x - y]
  when "L"
    lefts << [x, y, x + y, y - x]
  else
    rights << [x, y, x + y]
  end
end

ans = []

downs_size = downs.size
ups_size = ups.size
rights_size = rights.size
lefts_size = lefts.size

if downs_size > 0 && lefts_size > 0
  downs_copy = downs.sort { |a, b| a[2] <=> b[2] }
  lefts_copy = lefts.sort { |a, b| a[2] <=> b[2] }
  downs_rest = downs_size - 1
  lefts_rest = lefts_size - 1
  downs_current = downs_copy.shift
  lefts_current = lefts_copy.shift
  if downs_current[2] == lefts_current[2]
    if downs_current[0] <= lefts_current[0]
      ans << lefts_current[0] - downs_current[0]
    end
  end
  until downs_copy.empty? && lefts_copy.empty?
    break if downs_current.nil? || lefts_current.nil?
    if downs_current[2] == lefts_current[2]
      if downs_current[0] <= lefts_current[0]
        ans << lefts_current[0] - downs_current[0]
      end
      downs_current = downs_copy.shift
      lefts_current = lefts_copy.shift
    elsif downs_current[2] < lefts_current[2]
      downs_current = downs_copy.shift
    else
      lefts_current = lefts_copy.shift
    end
  end
end

if ups_size > 0 && rights_size > 0
  ups_copy = ups.sort { |a, b| a[2] <=> b[2] }
  rights_copy = rights.sort { |a, b| a[2] <=> b[2] }
  ups_rest = ups_size - 1
  rights_rest = rights_size - 1
  ups_current = ups_copy.shift
  rights_current = rights_copy.shift
  if ups_current[2] == rights_current[2]
    if ups_current[0] >= rights_current[0]
      ans << rights_current[0] - ups_current[0]
    end
  end
  until ups_copy.empty? && rights_copy.empty?
    break if ups_current.nil? || rights_current.nil?
    if ups_current[2] == rights_current[2]
      if ups_current[0] >= rights_current[0]
        ans << rights_current[0] - ups_current[0]
      end
      ups_current = ups_copy.shift
      rights_current = rights_copy.shift
    elsif ups_current[2] < rights_current[2]
      ups_current = ups_copy.shift
    else
      rights_current = rights_copy.shift
    end
  end
end

if ups_size > 0 && lefts_size > 0
  ups_copy = ups.sort { |a, b| a[2] <=> b[2] }
  lefts_copy = lefts.sort { |a, b| a[3] <=> b[3] }
  ups_rest = ups_size - 1
  lefts_rest = lefts_size - 1
  ups_current = ups_copy.shift
  lefts_current = lefts_copy.shift
  if ups_current[2] == lefts_current[3]
    if ups_current[0] <= lefts_current[0]
      ans << lefts_current[0] - ups_current[0]
    end
  end
  until ups_copy.empty? && lefts_copy.empty?
    break if ups_current.nil? || lefts_current.nil?
    if ups_current[2] == lefts_current[3]
      if ups_current[0] <= lefts_current[0]
        ans << lefts_current[0] - ups_current[0]
      end
      ups_current = ups_copy.shift
      lefts_current = lefts_copy.shift
    elsif ups_current[2] < lefts_current[3]
      ups_current = ups_copy.shift
    else
      lefts_current = lefts_copy.shift
    end
  end
end

if rights_size > 0 && downs_size > 0
  rights_copy = rights.sort { |a, b| a[2] <=> b[2] }
  downs_copy = downs.sort { |a, b| a[3] <=> b[3] }
  rights_rest = rights_size - 1
  downs_rest = downs_size - 1
  rights_current = rights_copy.shift
  downs_current = downs_copy.shift
  if rights_current[2] == downs_current[3]
    if rights_current[0] <= downs_current[0]
      ans << downs_current[0] - rights_current[0]
    end
  end
  until rights_copy.empty? && downs_copy.empty?
    break if rights_current.nil? || downs_current.nil?
    if rights_current[2] == downs_current[3]
      if rights_current[0] <= downs_current[0]
        ans << downs_current[0] - rights_current[0]
      end
      rights_current = rights_copy.shift
      downs_current = downs_copy.shift
    elsif rights_current[2] < downs_current[3]
      rights_current = rights_copy.shift
    else
      downs_current = downs_copy.shift
    end
  end
end

if rights_size > 0 && lefts_size > 0
  rights_copy = rights.sort { |a, b| a[1] <=> b[1] }
  lefts_copy = lefts.sort { |a, b| a[1] <=> b[1] }
  rights_rest = rights_size - 1
  lefts_rest = lefts_size - 1
  rights_current = rights_copy.shift
  lefts_current = lefts_copy.shift
  if rights_current[1] == lefts_current[1]
    if rights_current[0] <= lefts_current[0]
      ans << (lefts_current[0] - rights_current[0]) / 2.0
    end
  end
  until rights_copy.empty? && lefts_copy.empty?
    break if rights_current.nil? || lefts_current.nil?
    if rights_current[1] == lefts_current[1]
      if rights_current[0] <= lefts_current[0]
        ans << (lefts_current[0] - rights_current[0]) / 2.0
      end
      rights_current = rights_copy.shift
      lefts_current = lefts_copy.shift
    elsif rights_current[1] < lefts_current[1]
      rights_current = rights_copy.shift
    else
      lefts_current = lefts_copy.shift
    end
  end
end

if ups_size > 0 && downs_size > 0
  ups_copy = ups.sort { |a, b| a[0] <=> b[0] }
  downs_copy = downs.sort { |a, b| a[0] <=> b[0] }
  ups_rest = ups_size - 1
  downs_rest = downs_size - 1
  ups_current = ups_copy.shift
  downs_current = downs_copy.shift
  if ups_current[0] == downs_current[0]
    if ups_current[1] <= downs_current[1]
      ans << (downs_current[1] - ups_current[1]) / 2.0
    end
  end
  until ups_copy.empty? && downs_copy.empty?
    break if ups_current.nil? || downs_current.nil?
    if ups_current[0] == downs_current[0]
      if ups_current[1] <= downs_current[1]
        ans << (downs_current[1] - ups_current[1]) / 2.0
      end
      ups_current = ups_copy.shift
      downs_current = downs_copy.shift
    elsif ups_current[0] < downs_current[0]
      ups_current = ups_copy.shift
    else
      downs_current = downs_copy.shift
    end
  end
end

puts ans.empty? ? "SAFE" : (ans.min * 10).to_i
