Buggy python submission (verdict: Time Limit Exceeded):
def main():
  import sys
  input = sys.stdin.readline
  N = int(input())
  XYU = [list(map(str,input().split())) for _ in range(N)]
  from collections import deque

  UD = [deque() for _ in range(200001)]
  LR = [deque() for _ in range(200001)]


  for X,Y,u in XYU:
    X = int(X)
    Y = int(Y)
    if u=='R':
      LR[Y].append((X,u))
    elif u=='L':
      LR[Y].append((X,u))
    elif u=='U':
      UD[X].append((Y,u))
    else:
      UD[X].append((Y,u))

  safe = True
  ans = 10**7
  for l in UD:
    length = len(l)
    if length>=2:
      l = sorted(l)
      for i in range(length - 1):
        a = l[i]
        b = l[i+1]
        if (a[1]=='U')and(b[1]=='D'):
          safe = False
          ans = min(ans,(b[0] - a[0])*5)

  for l in LR:
    length = len(l)
    if length>=2:
      l = sorted(l)
      for i in range(length - 1):
        a = l[i]
        b = l[i+1]
        if (a[1]=='R')and(b[1]=='L'):
          safe = False
          ans = min(ans,(b[0] - a[0])*5)

  del UD
  del LR
  UR = [deque() for _ in range(400001)]
  DL = [deque() for _ in range(400001)]
  DR = [deque() for _ in range(400001)]
  UL = [deque() for _ in range(400001)]


  for X,Y,u in XYU:
    X = int(X)
    Y = int(Y)
    if u=='R':
      UR[X+Y].append((Y,u))
      DR[X-Y+200000].append((Y,u))
    elif u=='L':
      DL[X+Y].append((Y,u))
      UL[X-Y+200000].append((Y,u))
    elif u=='U':
      UR[X+Y].append((Y,u))
      UL[X-Y+200000].append((Y,u))
    else:
      DL[X+Y].append((Y,u))
      DR[X-Y+200000].append((Y,u))
  for l in UR:
    length = len(l)
    if length>=2:
      l = sorted(l)
      for i in range(length - 1):
        a = l[i]
        b = l[i+1]
        if (a[1]=='U')and(b[1]=='R'):
          safe = False
          ans = min(ans,(b[0] - a[0]) * 10)

  for l in DL:
    length = len(l)
    if length>=2:
      l = sorted(l)
      for i in range(length - 1):
        a = l[i]
        b = l[i+1]
        if (a[1]=='L')and(b[1]=='D'):
          safe = False
          ans = min(ans,(b[0] - a[0]) * 10)

  for l in UL:
    length = len(l)
    if length>=2:
      l = sorted(l)
      for i in range(length - 1):
        a = l[i]
        b = l[i+1]
        if (a[1]=='U')and(b[1]=='L'):
          safe = False
          ans = min(ans,(b[0] - a[0]) * 10)

  for l in DR:
    length = len(l)
    if length>=2:
      l = sorted(l)
      for i in range(length - 1):
        a = l[i]
        b = l[i+1]
        if (a[1]=='R')and(b[1]=='D'):
          safe = False
          ans = min(ans,(b[0] - a[0]) * 10)

  if safe:
    print('SAFE')
  else:
    print(ans)
    
main()

Fixed submission:
def main():
  import sys
  input = sys.stdin.readline
  N = int(input())
  XYU = [list(map(str,input().split())) for _ in range(N)]
  from collections import deque
  INF = float('inf')

  UD = [0] * 200001
  LR = [0] * 200001
  UR = [0] * 400001
  DL = [0] * 400001
  DR = [0] * 400001
  UL = [0] * 400001


  for X,Y,u in XYU:
    X = int(X)
    Y = int(Y)
    if u=='R':
      if type(LR[Y])==int:
        LR[Y] = deque()
      if type(UR[X+Y])==int:
        UR[X+Y] = deque()
      if type(DR[X-Y+200000])==int:
        DR[X-Y+200000] = deque()

      LR[Y].append((X,u))
      UR[X+Y].append((Y,u))
      DR[X-Y+200000].append((Y,u))
    elif u=='L':
      if type(LR[Y])==int:
        LR[Y] = deque()
      if type(DL[X+Y])==int:
        DL[X+Y] = deque()
      if type(UL[X-Y+200000])==int:
        UL[X-Y+200000] = deque()
      LR[Y].append((X,u))
      DL[X+Y].append((Y,u))
      UL[X-Y+200000].append((Y,u))
    elif u=='U':
      if type(UD[X])==int:
        UD[X] = deque()
      if type(UR[X+Y])==int:
        UR[X+Y] = deque()
      if type(UL[X-Y+200000])==int:
        UL[X-Y+200000] = deque()
      UD[X].append((Y,u))
      UR[X+Y].append((Y,u))
      UL[X-Y+200000].append((Y,u))
    else:
      if type(UD[X])==int:
        UD[X] = deque()
      if type(DL[X+Y])==int:
        DL[X+Y] = deque()
      if type(DR[X-Y+200000])==int:
        DR[X-Y+200000] = deque()
      UD[X].append((Y,u))
      DL[X+Y].append((Y,u))
      DR[X-Y+200000].append((Y,u))

  safe = True
  ans = INF
  for l in UD:
    if type(l)!=int:
      length = len(l)
      if length>=2:
        l = sorted(l)
        for i in range(length - 1):
          a = l[i]
          b = l[i+1]
          if (a[1]=='U')and(b[1]=='D'):
            safe = False
            ans = min(ans,(b[0] - a[0])*5)

  for l in LR:
    if type(l)!=int:
      length = len(l)
      if length>=2:
        l = sorted(l)
        for i in range(length - 1):
          a = l[i]
          b = l[i+1]
          if (a[1]=='R')and(b[1]=='L'):
            safe = False
            ans = min(ans,(b[0] - a[0])*5)


  for l in UR:
    if type(l)!=int:
      length = len(l)
      if length>=2:
        l = sorted(l)
        for i in range(length - 1):
          a = l[i]
          b = l[i+1]
          if (a[1]=='U')and(b[1]=='R'):
            safe = False
            ans = min(ans,(b[0] - a[0]) * 10)

  for l in DL:
    if type(l)!=int:
      length = len(l)
      if length>=2:
        l = sorted(l)
        for i in range(length - 1):
          a = l[i]
          b = l[i+1]
          if (a[1]=='L')and(b[1]=='D'):
            safe = False
            ans = min(ans,(b[0] - a[0]) * 10)

  for l in UL:
    if type(l)!=int:
      length = len(l)
      if length>=2:
        l = sorted(l)
        for i in range(length - 1):
          a = l[i]
          b = l[i+1]
          if (a[1]=='U')and(b[1]=='L'):
            safe = False
            ans = min(ans,(b[0] - a[0]) * 10)

  for l in DR:
    if type(l)!=int:
      length = len(l)
      if length>=2:
        l = sorted(l)
        for i in range(length - 1):
          a = l[i]
          b = l[i+1]
          if (a[1]=='R')and(b[1]=='D'):
            safe = False
            ans = min(ans,(b[0] - a[0]) * 10)

  if safe:
    print('SAFE')
  else:
    print(ans)
    
main()

Buggy python submission (verdict: Time Limit Exceeded):
def main():
  import sys
  input = sys.stdin.readline
  N = int(input())
  XYU = [list(map(str,input().split())) for _ in range(N)]
  from collections import deque
  INF = float('inf')

  UD = [deque() for _ in range(200001)]
  LR = [deque() for _ in range(200001)]
  UR = [deque() for _ in range(400001)]
  DL = [deque() for _ in range(400001)]
  DR = [deque() for _ in range(400001)]
  UL = [deque() for _ in range(400001)]


  for X,Y,u in XYU:
    X = int(X)
    Y = int(Y)
    if u=='R':
      LR[Y].append((X,u))
      UR[X+Y].append((Y,u))
      DR[X-Y+200000].append((Y,u))
    elif u=='L':
      LR[Y].append((X,u))
      DL[X+Y].append((Y,u))
      UL[X-Y+200000].append((Y,u))
    elif u=='U':
      UD[X].append((Y,u))
      UR[X+Y].append((Y,u))
      UL[X-Y+200000].append((Y,u))
    else:
      UD[X].append((Y,u))
      DL[X+Y].append((Y,u))
      DR[X-Y+200000].append((Y,u))

  safe = True
  ans = INF
  for l in UD:
    length = len(l)
    if length>=2:
      l = sorted(l)
      for i in range(length - 1):
        a = l[i]
        b = l[i+1]
        if (a[1]=='U')and(b[1]=='D'):
          safe = False
          ans = min(ans,(b[0] - a[0])*5)

  for l in LR:
    length = len(l)
    if length>=2:
      l = sorted(l)
      for i in range(length - 1):
        a = l[i]
        b = l[i+1]
        if (a[1]=='R')and(b[1]=='L'):
          safe = False
          ans = min(ans,(b[0] - a[0])*5)


  for l in UR:
    length = len(l)
    if length>=2:
      l = sorted(l)
      for i in range(length - 1):
        a = l[i]
        b = l[i+1]
        if (a[1]=='U')and(b[1]=='R'):
          safe = False
          ans = min(ans,(b[0] - a[0]) * 10)

  for l in DL:
    length = len(l)
    if length>=2:
      l = sorted(l)
      for i in range(length - 1):
        a = l[i]
        b = l[i+1]
        if (a[1]=='L')and(b[1]=='D'):
          safe = False
          ans = min(ans,(b[0] - a[0]) * 10)

  for l in UL:
    length = len(l)
    if length>=2:
      l = sorted(l)
      for i in range(length - 1):
        a = l[i]
        b = l[i+1]
        if (a[1]=='U')and(b[1]=='L'):
          safe = False
          ans = min(ans,(b[0] - a[0]) * 10)

  for l in DR:
    length = len(l)
    if length>=2:
      l = sorted(l)
      for i in range(length - 1):
        a = l[i]
        b = l[i+1]
        if (a[1]=='R')and(b[1]=='D'):
          safe = False
          ans = min(ans,(b[0] - a[0]) * 10)

  if safe:
    print('SAFE')
  else:
    print(ans)
    
main()

Fixed submission:
def main():
  import sys
  input = sys.stdin.readline
  N = int(input())
  XYU = [list(map(str,input().split())) for _ in range(N)]
  from collections import deque
  INF = float('inf')

  UD = [0] * 200001
  LR = [0] * 200001
  UR = [0] * 400001
  DL = [0] * 400001
  DR = [0] * 400001
  UL = [0] * 400001


  for X,Y,u in XYU:
    X = int(X)
    Y = int(Y)
    if u=='R':
      if type(LR[Y])==int:
        LR[Y] = deque()
      if type(UR[X+Y])==int:
        UR[X+Y] = deque()
      if type(DR[X-Y+200000])==int:
        DR[X-Y+200000] = deque()

      LR[Y].append((X,u))
      UR[X+Y].append((Y,u))
      DR[X-Y+200000].append((Y,u))
    elif u=='L':
      if type(LR[Y])==int:
        LR[Y] = deque()
      if type(DL[X+Y])==int:
        DL[X+Y] = deque()
      if type(UL[X-Y+200000])==int:
        UL[X-Y+200000] = deque()
      LR[Y].append((X,u))
      DL[X+Y].append((Y,u))
      UL[X-Y+200000].append((Y,u))
    elif u=='U':
      if type(UD[X])==int:
        UD[X] = deque()
      if type(UR[X+Y])==int:
        UR[X+Y] = deque()
      if type(UL[X-Y+200000])==int:
        UL[X-Y+200000] = deque()
      UD[X].append((Y,u))
      UR[X+Y].append((Y,u))
      UL[X-Y+200000].append((Y,u))
    else:
      if type(UD[X])==int:
        UD[X] = deque()
      if type(DL[X+Y])==int:
        DL[X+Y] = deque()
      if type(DR[X-Y+200000])==int:
        DR[X-Y+200000] = deque()
      UD[X].append((Y,u))
      DL[X+Y].append((Y,u))
      DR[X-Y+200000].append((Y,u))

  safe = True
  ans = INF
  for l in UD:
    if type(l)!=int:
      length = len(l)
      if length>=2:
        l = sorted(l)
        for i in range(length - 1):
          a = l[i]
          b = l[i+1]
          if (a[1]=='U')and(b[1]=='D'):
            safe = False
            ans = min(ans,(b[0] - a[0])*5)

  for l in LR:
    if type(l)!=int:
      length = len(l)
      if length>=2:
        l = sorted(l)
        for i in range(length - 1):
          a = l[i]
          b = l[i+1]
          if (a[1]=='R')and(b[1]=='L'):
            safe = False
            ans = min(ans,(b[0] - a[0])*5)


  for l in UR:
    if type(l)!=int:
      length = len(l)
      if length>=2:
        l = sorted(l)
        for i in range(length - 1):
          a = l[i]
          b = l[i+1]
          if (a[1]=='U')and(b[1]=='R'):
            safe = False
            ans = min(ans,(b[0] - a[0]) * 10)

  for l in DL:
    if type(l)!=int:
      length = len(l)
      if length>=2:
        l = sorted(l)
        for i in range(length - 1):
          a = l[i]
          b = l[i+1]
          if (a[1]=='L')and(b[1]=='D'):
            safe = False
            ans = min(ans,(b[0] - a[0]) * 10)

  for l in UL:
    if type(l)!=int:
      length = len(l)
      if length>=2:
        l = sorted(l)
        for i in range(length - 1):
          a = l[i]
          b = l[i+1]
          if (a[1]=='U')and(b[1]=='L'):
            safe = False
            ans = min(ans,(b[0] - a[0]) * 10)

  for l in DR:
    if type(l)!=int:
      length = len(l)
      if length>=2:
        l = sorted(l)
        for i in range(length - 1):
          a = l[i]
          b = l[i+1]
          if (a[1]=='R')and(b[1]=='D'):
            safe = False
            ans = min(ans,(b[0] - a[0]) * 10)

  if safe:
    print('SAFE')
  else:
    print(ans)
    
main()

Buggy python submission (verdict: Runtime Error):
def main()
  import sys
  input = sys.stdin.readline
  N = int(input())
  XYU = [list(map(str,input().split())) for _ in range(N)]
  from collections import deque
  INF = float('inf')

  UD = [deque() for _ in range(200001)]
  LR = [deque() for _ in range(200001)]
  UR = [deque() for _ in range(400001)]
  DL = [deque() for _ in range(400001)]
  DR = [deque() for _ in range(400001)]
  UL = [deque() for _ in range(400001)]


  for X,Y,u in XYU:
    X = int(X)
    Y = int(Y)
    if u=='R':
      LR[Y].append((X,u))
      UR[X+Y].append((Y,u))
      DR[X-Y+200000].append((Y,u))
    elif u=='L':
      LR[Y].append((X,u))
      DL[X+Y].append((Y,u))
      UL[X-Y+200000].append((Y,u))
    elif u=='U':
      UD[X].append((Y,u))
      UR[X+Y].append((Y,u))
      UL[X-Y+200000].append((Y,u))
    else:
      UD[X].append((Y,u))
      DL[X+Y].append((Y,u))
      DR[X-Y+200000].append((Y,u))

  safe = True
  ans = INF
  for l in UD:
    length = len(l)
    if length>=2:
      l = sorted(l)
      for i in range(length - 1):
        a = l[i]
        b = l[i+1]
        if (a[1]=='U')and(b[1]=='D'):
          safe = False
          ans = min(ans,(b[0] - a[0])*5)

  for l in LR:
    length = len(l)
    if length>=2:
      l = sorted(l)
      for i in range(length - 1):
        a = l[i]
        b = l[i+1]
        if (a[1]=='R')and(b[1]=='L'):
          safe = False
          ans = min(ans,(b[0] - a[0])*5)


  for l in UR:
    length = len(l)
    if length>=2:
      l = sorted(l)
      for i in range(length - 1):
        a = l[i]
        b = l[i+1]
        if (a[1]=='U')and(b[1]=='R'):
          safe = False
          ans = min(ans,(b[0] - a[0]) * 10)

  for l in DL:
    length = len(l)
    if length>=2:
      l = sorted(l)
      for i in range(length - 1):
        a = l[i]
        b = l[i+1]
        if (a[1]=='L')and(b[1]=='D'):
          safe = False
          ans = min(ans,(b[0] - a[0]) * 10)

  for l in UL:
    length = len(l)
    if length>=2:
      l = sorted(l)
      for i in range(length - 1):
        a = l[i]
        b = l[i+1]
        if (a[1]=='U')and(b[1]=='L'):
          safe = False
          ans = min(ans,(b[0] - a[0]) * 10)

  for l in DR:
    length = len(l)
    if length>=2:
      l = sorted(l)
      for i in range(length - 1):
        a = l[i]
        b = l[i+1]
        if (a[1]=='R')and(b[1]=='D'):
          safe = False
          ans = min(ans,(b[0] - a[0]) * 10)

  if safe:
    print('SAFE')
  else:
    print(ans)
    
main()

Fixed submission:
def main():
  import sys
  input = sys.stdin.readline
  N = int(input())
  XYU = [list(map(str,input().split())) for _ in range(N)]
  from collections import deque
  INF = float('inf')

  UD = [0] * 200001
  LR = [0] * 200001
  UR = [0] * 400001
  DL = [0] * 400001
  DR = [0] * 400001
  UL = [0] * 400001


  for X,Y,u in XYU:
    X = int(X)
    Y = int(Y)
    if u=='R':
      if type(LR[Y])==int:
        LR[Y] = deque()
      if type(UR[X+Y])==int:
        UR[X+Y] = deque()
      if type(DR[X-Y+200000])==int:
        DR[X-Y+200000] = deque()

      LR[Y].append((X,u))
      UR[X+Y].append((Y,u))
      DR[X-Y+200000].append((Y,u))
    elif u=='L':
      if type(LR[Y])==int:
        LR[Y] = deque()
      if type(DL[X+Y])==int:
        DL[X+Y] = deque()
      if type(UL[X-Y+200000])==int:
        UL[X-Y+200000] = deque()
      LR[Y].append((X,u))
      DL[X+Y].append((Y,u))
      UL[X-Y+200000].append((Y,u))
    elif u=='U':
      if type(UD[X])==int:
        UD[X] = deque()
      if type(UR[X+Y])==int:
        UR[X+Y] = deque()
      if type(UL[X-Y+200000])==int:
        UL[X-Y+200000] = deque()
      UD[X].append((Y,u))
      UR[X+Y].append((Y,u))
      UL[X-Y+200000].append((Y,u))
    else:
      if type(UD[X])==int:
        UD[X] = deque()
      if type(DL[X+Y])==int:
        DL[X+Y] = deque()
      if type(DR[X-Y+200000])==int:
        DR[X-Y+200000] = deque()
      UD[X].append((Y,u))
      DL[X+Y].append((Y,u))
      DR[X-Y+200000].append((Y,u))

  safe = True
  ans = INF
  for l in UD:
    if type(l)!=int:
      length = len(l)
      if length>=2:
        l = sorted(l)
        for i in range(length - 1):
          a = l[i]
          b = l[i+1]
          if (a[1]=='U')and(b[1]=='D'):
            safe = False
            ans = min(ans,(b[0] - a[0])*5)

  for l in LR:
    if type(l)!=int:
      length = len(l)
      if length>=2:
        l = sorted(l)
        for i in range(length - 1):
          a = l[i]
          b = l[i+1]
          if (a[1]=='R')and(b[1]=='L'):
            safe = False
            ans = min(ans,(b[0] - a[0])*5)


  for l in UR:
    if type(l)!=int:
      length = len(l)
      if length>=2:
        l = sorted(l)
        for i in range(length - 1):
          a = l[i]
          b = l[i+1]
          if (a[1]=='U')and(b[1]=='R'):
            safe = False
            ans = min(ans,(b[0] - a[0]) * 10)

  for l in DL:
    if type(l)!=int:
      length = len(l)
      if length>=2:
        l = sorted(l)
        for i in range(length - 1):
          a = l[i]
          b = l[i+1]
          if (a[1]=='L')and(b[1]=='D'):
            safe = False
            ans = min(ans,(b[0] - a[0]) * 10)

  for l in UL:
    if type(l)!=int:
      length = len(l)
      if length>=2:
        l = sorted(l)
        for i in range(length - 1):
          a = l[i]
          b = l[i+1]
          if (a[1]=='U')and(b[1]=='L'):
            safe = False
            ans = min(ans,(b[0] - a[0]) * 10)

  for l in DR:
    if type(l)!=int:
      length = len(l)
      if length>=2:
        l = sorted(l)
        for i in range(length - 1):
          a = l[i]
          b = l[i+1]
          if (a[1]=='R')and(b[1]=='D'):
            safe = False
            ans = min(ans,(b[0] - a[0]) * 10)

  if safe:
    print('SAFE')
  else:
    print(ans)
    
main()

Buggy python submission (verdict: Time Limit Exceeded):
import sys
input = sys.stdin.readline
N = int(input())
XYU = [list(map(str,input().split())) for _ in range(N)]
from collections import deque
INF = float('inf')

UD = [deque() for _ in range(200001)]
LR = [deque() for _ in range(200001)]
UR = [deque() for _ in range(400001)]
DL = [deque() for _ in range(400001)]
DR = [deque() for _ in range(400001)]
UL = [deque() for _ in range(400001)]


for X,Y,u in XYU:
  X = int(X)
  Y = int(Y)
  if u=='R':
    LR[Y].append((X,u))
    UR[X+Y].append((Y,u))
    DR[X-Y+200000].append((Y,u))
  elif u=='L':
    LR[Y].append((X,u))
    DL[X+Y].append((Y,u))
    UL[X-Y+200000].append((Y,u))
  elif u=='U':
    UD[X].append((Y,u))
    UR[X+Y].append((Y,u))
    UL[X-Y+200000].append((Y,u))
  else:
    UD[X].append((Y,u))
    DL[X+Y].append((Y,u))
    DR[X-Y+200000].append((Y,u))
    
safe = True
ans = INF
for l in UD:
  length = len(l)
  if length>=2:
    l = sorted(l)
    for i in range(length - 1):
      a = l[i]
      b = l[i+1]
      if (a[1]=='U')and(b[1]=='D'):
        safe = False
        ans = min(ans,(b[0] - a[0])*5)
        
for l in LR:
  length = len(l)
  if length>=2:
    l = sorted(l)
    for i in range(length - 1):
      a = l[i]
      b = l[i+1]
      if (a[1]=='R')and(b[1]=='L'):
        safe = False
        ans = min(ans,(b[0] - a[0])*5)
        
        
for l in UR:
  length = len(l)
  if length>=2:
    l = sorted(l)
    for i in range(length - 1):
      a = l[i]
      b = l[i+1]
      if (a[1]=='U')and(b[1]=='R'):
        safe = False
        ans = min(ans,(b[0] - a[0]) * 10)
        
for l in DL:
  length = len(l)
  if length>=2:
    l = sorted(l)
    for i in range(length - 1):
      a = l[i]
      b = l[i+1]
      if (a[1]=='L')and(b[1]=='D'):
        safe = False
        ans = min(ans,(b[0] - a[0]) * 10)
    
for l in UL:
  length = len(l)
  if length>=2:
    l = sorted(l)
    for i in range(length - 1):
      a = l[i]
      b = l[i+1]
      if (a[1]=='U')and(b[1]=='L'):
        safe = False
        ans = min(ans,(b[0] - a[0]) * 10)
        
for l in DR:
  length = len(l)
  if length>=2:
    l = sorted(l)
    for i in range(length - 1):
      a = l[i]
      b = l[i+1]
      if (a[1]=='R')and(b[1]=='D'):
        safe = False
        ans = min(ans,(b[0] - a[0]) * 10)
          
if safe:
  print('SAFE')
else:
  print(ans)

Fixed submission:
def main():
  import sys
  input = sys.stdin.readline
  N = int(input())
  XYU = [list(map(str,input().split())) for _ in range(N)]
  from collections import deque
  INF = float('inf')

  UD = [0] * 200001
  LR = [0] * 200001
  UR = [0] * 400001
  DL = [0] * 400001
  DR = [0] * 400001
  UL = [0] * 400001


  for X,Y,u in XYU:
    X = int(X)
    Y = int(Y)
    if u=='R':
      if type(LR[Y])==int:
        LR[Y] = deque()
      if type(UR[X+Y])==int:
        UR[X+Y] = deque()
      if type(DR[X-Y+200000])==int:
        DR[X-Y+200000] = deque()

      LR[Y].append((X,u))
      UR[X+Y].append((Y,u))
      DR[X-Y+200000].append((Y,u))
    elif u=='L':
      if type(LR[Y])==int:
        LR[Y] = deque()
      if type(DL[X+Y])==int:
        DL[X+Y] = deque()
      if type(UL[X-Y+200000])==int:
        UL[X-Y+200000] = deque()
      LR[Y].append((X,u))
      DL[X+Y].append((Y,u))
      UL[X-Y+200000].append((Y,u))
    elif u=='U':
      if type(UD[X])==int:
        UD[X] = deque()
      if type(UR[X+Y])==int:
        UR[X+Y] = deque()
      if type(UL[X-Y+200000])==int:
        UL[X-Y+200000] = deque()
      UD[X].append((Y,u))
      UR[X+Y].append((Y,u))
      UL[X-Y+200000].append((Y,u))
    else:
      if type(UD[X])==int:
        UD[X] = deque()
      if type(DL[X+Y])==int:
        DL[X+Y] = deque()
      if type(DR[X-Y+200000])==int:
        DR[X-Y+200000] = deque()
      UD[X].append((Y,u))
      DL[X+Y].append((Y,u))
      DR[X-Y+200000].append((Y,u))

  safe = True
  ans = INF
  for l in UD:
    if type(l)!=int:
      length = len(l)
      if length>=2:
        l = sorted(l)
        for i in range(length - 1):
          a = l[i]
          b = l[i+1]
          if (a[1]=='U')and(b[1]=='D'):
            safe = False
            ans = min(ans,(b[0] - a[0])*5)

  for l in LR:
    if type(l)!=int:
      length = len(l)
      if length>=2:
        l = sorted(l)
        for i in range(length - 1):
          a = l[i]
          b = l[i+1]
          if (a[1]=='R')and(b[1]=='L'):
            safe = False
            ans = min(ans,(b[0] - a[0])*5)


  for l in UR:
    if type(l)!=int:
      length = len(l)
      if length>=2:
        l = sorted(l)
        for i in range(length - 1):
          a = l[i]
          b = l[i+1]
          if (a[1]=='U')and(b[1]=='R'):
            safe = False
            ans = min(ans,(b[0] - a[0]) * 10)

  for l in DL:
    if type(l)!=int:
      length = len(l)
      if length>=2:
        l = sorted(l)
        for i in range(length - 1):
          a = l[i]
          b = l[i+1]
          if (a[1]=='L')and(b[1]=='D'):
            safe = False
            ans = min(ans,(b[0] - a[0]) * 10)

  for l in UL:
    if type(l)!=int:
      length = len(l)
      if length>=2:
        l = sorted(l)
        for i in range(length - 1):
          a = l[i]
          b = l[i+1]
          if (a[1]=='U')and(b[1]=='L'):
            safe = False
            ans = min(ans,(b[0] - a[0]) * 10)

  for l in DR:
    if type(l)!=int:
      length = len(l)
      if length>=2:
        l = sorted(l)
        for i in range(length - 1):
          a = l[i]
          b = l[i+1]
          if (a[1]=='R')and(b[1]=='D'):
            safe = False
            ans = min(ans,(b[0] - a[0]) * 10)

  if safe:
    print('SAFE')
  else:
    print(ans)
    
main()