Problem:
 Score : 100 points    Problem Statement There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print unsafe ; otherwise, print safe .      Constraints  1 \leq S \leq 100  1 \leq W \leq 100         Input Input is given from Standard Input in the following format:  S  W       Output If the wolves will attack the sheep, print unsafe ; otherwise, print safe .        Sample Input 1 4 5      Sample Output 1 unsafe  There are four sheep and five wolves. The number of wolves is not less than that of sheep, so they will attack them.       Sample Input 2 100 2      Sample Output 2 safe  Many a sheep drive away two wolves.       Sample Input 3 10 10      Sample Output 3 unsafe

Solution (Python):
import sys
import math
from collections import deque
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def S(): return sys.stdin.readline()
def LS(): return sys.stdin.readline().split()
def LS2(N): return [sys.stdin.readline().split() for i in range(N)]
def FILL(i,h,w): return [[i for j in range(w)] for k in range(h)]
def sisha(num,digit): return Decimal(str(num)).quantize(Decimal(digit),rounding=ROUND_HALF_UP)

MOD = 1000000007
INF = float("inf")
sys.setrecursionlimit(10**6+10)

input = sys.stdin.readline
S,W = MI()
if S<=W:
    print('unsafe')
else:
    print('safe')

Solution (Python):
s,w = map(int,input().split())
if w >= s:
    print("unsafe")
else:
    print("safe")

Solution (Python):
s,w=map(int,input().split())

if w>=s:
  print('unsafe')
else:
  print('safe')

Solution (Python):
a,b = list(map(int, input().split()))
if a <= b:
    print("unsafe")
else:
    print("safe")

Solution (Python):
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
def resolve():
    S, W = lr()
    if S <= W:
        print('unsafe')
    else:
        print('safe')
resolve()

Solution (Python):
S,W = map(int,input().split())
if W >= S:
  print("unsafe")
else:
  print("safe")

Solution (Python):
a,b = map(int,input().split())
if(a<=b):
  print("unsafe")
else:
  print("safe")

Solution (Python):
S,W = map(int,input().split())
if(W>=S):
    print("unsafe")
else:
    print("safe")

Solution (Python):
a,b = map(int,input().split())
if a>b:
  print("safe")
else:
  print("unsafe")

Solution (Python):
S, W = map(int, input().split())
if S <= W:
    print('unsafe')
else:
    print('safe')

Solution (Python):
S,W = map(int, input().split())

if S <= W:
    print("unsafe")
else:
    print("safe")

Solution (Python):
s,w=map(int,input().split())
print('safe' if s>w else 'unsafe')

Solution (Python):
a,b = map(int, input().split())
if b >= a:
    print("unsafe")
else:
    print("safe")

Solution (Python):

from decimal import *
from itertools import permutations, combinations,combinations_with_replacement,product
import math

s = input().split()
p = [int(w) for w in s] 
S = p[0]
W = p[1]
if(S>W):
    print('safe')
else:
    print('unsafe')

Solution (Python):
S, W = map(int, input().split())
print("unsafe" if S <= W else "safe")

Solution (Python):
s,w = map(int,input().split())
print('unsafe') if w>=s else print('safe')

Solution (Python):
s,w=map(int,input().split())
if w>=s:
  print('unsafe')
else:
  print('safe')

Solution (Python):
s, w = [int(elem) for elem in input().split()]

if s <= w:
    print('unsafe')
else:
    print('safe')

Solution (Python):
import sys
import os
import math
import string

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: x * y / math.gcd(x, y)

MOD = 10 ** 9 + 7
MAX = float('inf')


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    S, W = il()
    print('unsafe' if S <= W else 'safe')


if __name__ == '__main__':
    main()

Solution (Python):


s, w = map(int, input().split())

if w>=s:
    print('unsafe')
else:
    print('safe')

Solution (Python):
s,w=map(int,input().split())
if w>=s: print('unsafe')
else: print('safe')

Solution (Python):
s, w = map(int, input().split())
print("unsafe" if s <= w else "safe")

Solution (Python):
s,w = map(int,input().split())
if(s<=w):
    print('unsafe')
else:
    print('safe')

Solution (Python):
s,w = map(int, input().split())

if s <= w:
    print('unsafe')
else:
    print('safe')

Solution (Python):
s,w = [int(e) for e in input().split()]
if w >= s:
    print("unsafe")
else:
    print("safe")

Solution (Python):
s,w=map(int,input().split())
if w>=s:
    print('unsafe')
else:
    print('safe')

Solution (Python):
s, w = map(int, input().split())

if s <= w:
    print('unsafe')
else:
    print('safe')

Solution (Python):
s, w = map(int, input().split())
if s > w:
    print("safe")
else:
    print("unsafe")

Solution (Python):
data = input().split()
s = int(data[0])
w = int(data[1])

if s > w:
  print("safe")
else:
  print("unsafe")

Solution (Python):
s, w = map(int, input().split())

if s <= w:
  print("unsafe")
else:
  print("safe")

Solution (Python):

MOD = 10 ** 9 + 7
INFI = 10**10

import math

import itertools
import heapq


import copy
from functools import lru_cache

def sosuhante(n):
    for k in range(2, int(math.sqrt(n))+1):
        if n% k ==0:
            return False
    return True
def cmb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result

def kingaku(a,b,n):
    keta=len(str(n))
    return a*n+b*keta

def my_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default




def ret(a):
    c=[None]*(len(a)-1)
    if len(a)==1:
        return a[0]
    elif len(a)==0:
        return 0
    for i in range(1,len(a)):
        c[i-1]=abs(a[i]-a[i-1])
    return ret(c)


def main():

    s,w=map(int,input().split())
    ans="unsafe"
    if s>w:
        ans="safe"
    print(ans)



if __name__ == "__main__":

    main()

Solution (Python):
import sys
import math
from collections import deque
import heapq
MAX_INT = int(10e10)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

s, w = IL()

if s <= w:
  print("unsafe")
else:
  print("safe")

Solution (Python):
S,W = map(int,input().split())

if W >= S:
    print('unsafe')
else:
    print('safe')

Solution (Python):
s,w=map(int,input().split())
if w>=s:
  print("unsafe")
else:
  print("safe")

Solution (Python):
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush,heapify
import math
from copy import deepcopy
import queue

Mod = 1000000007
  
def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))+1):
        if prime[i] == 1:
            for j in range(2*i,n+1):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n+1):
        if prime[i] == 1:
            res.append(i)
    return res

 
class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[py] = px
        else:
            self.parent[px] = py
 
    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)

def main():  
    s, w = map(int, input().split())
    print("unsafe" if s <= w else "safe")
if __name__ == "__main__":
    main()

Solution (Python):
s,w=map(int,input().split())
if s>w:
  print('safe')
else:
  print('unsafe')

Solution (Python):
s,w=map(int,input().split())
if w>=s:
    print("unsafe")
else:
    print("safe")

Solution (Python):
s,w = [int(x) for x in input().split()]
if w >= s:
  print('unsafe')
else:
  print('safe')

Solution (Python):
S, W = map(int, input().split())
if S > W:
    print("safe")
else:
    print("unsafe")

Solution (Python):
s,w=map(int, input().split())
if w>=s:
    print("unsafe")
else:
    print("safe")

Solution (Python):
from sys import stdin
input = stdin.readline

S, W = map(int, input().split())

if W >= S:
    print("unsafe")
else:
    print("safe")

Solution (Python):
S, W = map(int, input().split())
if W >= S:
    print('unsafe')
else:
    print('safe')

Solution (Python):
s, w = list(map(int, input().split()))

if s <= w:
    print("unsafe")
else:
    print("safe")

Solution (Python):
S, W = map(int,input().split())
if S <= W: print("unsafe")
else: print("safe")

Solution (Python):
def A():
    S, W = map(int, input().split())
    if W>=S:
        print('unsafe')
    else:
        print('safe')

A()

Solution (Python):
S, W = map(int, input().split())
ans = 'unsafe' if W >= S else 'safe'
print(ans)

Solution (Python):
s,w=map(int,input().split( ))
if s>w:
    print('safe')
else:
    print('unsafe')

Solution (Python):
a,b = map(int,input().split())
if a>b:
    print('safe')
else:
    print('unsafe')

Solution (Python):
s=list(map(int,input().split()))
if s[0]<=s[1]:
  print('unsafe')
else:
  print('safe')

Solution (Python):
from sys import stdin
S,W = [int(x) for x in stdin.readline().rstrip().split()]
if W >= S:
    print("unsafe")
else:
    print("safe")

Solution (Python):
s, w = map(int, input().split())

if w >= s:
    print('unsafe')
else:
    print('safe')

Solution (Python):
a, b = map(int, input().split())


if a <= b:
    print('unsafe')
else:
    print('safe')

Solution (Python):
s,w=map(int,input().split())
print("unsafe" if w>=s else "safe")

Solution (Python):
S, W = map(int, input().split())
print('unsafe' if S <= W else 'safe')

Solution (Python):
def main():
    s, w = map(int, input().split())
    if s <= w:
        print("unsafe")
    else:
        print("safe")


main()

Solution (Python):
def main():
    s, w = [int(x) for x in input().split()]
    if w >= s:
        return 'unsafe'
    else:
        return 'safe'


if __name__ == '__main__':
    print(main())

Solution (Python):
S,W=map(int,input().split())
if S<=W:
  print('unsafe')
else:
  print('safe')

Solution (Python):
S, W = list(map(int, input().split(' ')))

if W >= S:
  print('unsafe')
else:
  print('safe')

Solution (Python):
import sys


def input():
    return sys.stdin.readline().strip()


def main():
    S, W = map(int, input().split())
    if S <= W:
        print("unsafe")
    else:
        print("safe")


if __name__ == "__main__":
    main()

Solution (Python):
s,w=map(int,input().split())
if w>=s:
    print("unsafe")
else:
    print("safe")

Solution (Python):
s, w = map(int, input().split())
if w >= s:
    print("unsafe")
else:
    print("safe")

Solution (Python):
def main():
    s, w = map(int, input().split())
    if s > w:
        print('safe')
    else:
        print('unsafe')


if __name__ == '__main__':
    main()

Solution (Python):
n,m=map(int,input().split())
if m>=n:
  print("unsafe")
else:
  print("safe")

Solution (Python):
import sys

s, w = map(int, sys.stdin.readline().split())

def main():
    ans = 'unsafe' if w >= s else 'safe'
    print(ans)

if __name__ == '__main__':
    main()

Solution (Python):
def main():
    s, w = map(int, input().split())
    if w >= s:
        print('unsafe')
    else:
        print('safe')


if __name__ == '__main__':
    main()

Solution (Python):
S,W=[int(i) for i in input().split(" ")]
if W>=S:
    print("unsafe")
else:
    print("safe")

Solution (Python):

s,w=map(int,input().split())
if w>=s:
  print("unsafe")
else:
  print("safe")

Solution (Python):

S,W=map(int,input().split())

if W>=S:
    print("unsafe")
else:
    print("safe")

Solution (Python):
s,w = map(int,input().split())
if s <= w:
  print('unsafe')
else:
  print('safe')

Solution (Python):
a,b=map(int,input().split())
if(a<=b):
    print("unsafe")
else:
    print("safe")

Solution (Python):
s,w = map(int, input().split())
if w >= s:
    print("unsafe")
else:
    print("safe")

Solution (Python):
i,j=map(int,input().split())
if i<=j:
  print("unsafe")
else:
  print("safe")

Solution (Python):
S, W = map(int, input().split())

if S > W:
	print("safe")
else:
	print("unsafe")

Solution (Python):
s,w=map(int,input().split())
if w>=s:
    print('unsafe')
else:
    print('safe')

Solution (Python):

l = [int(x) for x in input().split()]
if l[1] >= l[0]:
    print("unsafe")
else:
    print("safe")

Solution (Python):


s,w=map(int,input().split())

if s<=w:
    print("unsafe")
else:
    print("safe")

Solution (Python):
s, w = map(int, input().split())
if s <= w:
    print('unsafe')
else:
    print('safe')

Solution (Python):
S, W = map(int, input().split())

if S > W:
    print('safe')
else:
    print('unsafe')

Solution (Python):
S,W = map(int,input().split())
if S <= W:
    print("unsafe")
else:
    print("safe")

Solution (Python):



import sys



S, W = map(int, input().split())

if W >= S:
    print('unsafe')
else:
    print('safe')

Solution (Python):
s, w = map(int, input().split())
if w >= s:
  print("unsafe")
else:
  print("safe")

Solution (Python):
s,w=map(int,input().split())
if s<=w:
    print("unsafe")
else:
    print("safe")

Solution (Python):

S, W = map(int, input().split())

if S <= W:
    print("unsafe")
else:
    print("safe")

Solution (Python):
S,W=map(int,input().split())
print("unsafe" if S<=W else "safe")

Solution (Python):
S, W = map(int, input().split())
if W >= S:
    print('unsafe')
else:
    print('safe')

Solution (Python):
s, w = map(int, input().split())
if w >= s:
    print("unsafe")
else:
    print("safe")

Solution (Python):
n,k = map(int,input().split())

print("unsafe" if n<=k else "safe")

Solution (Python):
n,m=map(int,input().split())
if n<=m:
    print("unsafe")
else:
    print("safe")

Solution (Python):
S,W = map(int,input().split())
if W>=S:
    print("unsafe")
else:
    print("safe")

Solution (Python):
s, w = map(int, input().split())

if s > w:
    print('safe')
else:
    print('unsafe')

Solution (Python):
a, b = map(int,input().split())
if a <= b:
    print('unsafe')
else:
    print('safe')

Solution (Python):


s, w = map(int,input().split())
if s <= w:
    print('unsafe')
else:
    print('safe')

Solution (Python):
import sys
sys.setrecursionlimit(1000000)

def solve(S, W):
    if S <= W:
        return "unsafe"
    return "safe"

if __name__ == "__main__":
    S, W = tuple(map(int, input().split(" ")))

    print(solve(S, W))

Solution (Python):
s,w=map(int,input().split())
if (s <= w):
    print('unsafe')
else:
    print('safe')

Solution (Python):
import sys
from math import log2,floor,ceil,sqrt


sys.setrecursionlimit(7*10**4)

Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
 
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 18
MOD =  998244353


s,w = Ri()
if w >= s :
    print("unsafe")
else:
    print("safe")

Solution (Python):
S, W = map(int, input().split())
print(["safe", "unsafe"][W >= S])

Solution (Python):
s,w = map(int,input().split())
if s <= w:
    print("unsafe")
else:
    print("safe")

Solution (Python):
S, W = map(int, input().split())

if W >= S:
    print("unsafe")
else:
    print("safe")

Solution (Python):
S, W = map(int, input().split())

if W >= S:
    print("unsafe")
else:
    print("safe")

Solution (Python):
import sys
import heapq, math
from itertools import zip_longest, permutations, combinations, combinations_with_replacement
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache
from copy import deepcopy

S, W = map(int, input().split())

print("unsafe" if S <= W else "safe")

Solution (Python):
S, W = map(int, input().split())

if W >= S:
    print('unsafe')
else:
    print('safe')

Solution (Python):
S,W=map(int,input().split())
if S<=W:
    print('unsafe')
else:
    print('safe')

Solution (Python):
import math
import fractions
import collections
import itertools
S,W=map(int,input().split())
if S<=W:
    print("unsafe")
else:
    print("safe")

Solution (Python):
s,w=map(int,input().split())
if w>=s:
  print("unsafe")
else:
  print("safe")

Solution (Python):
s, w = map(int, input().split())

if w >= s:
    print('unsafe')
else:
    print("safe")

Solution (Python):
S, W = map(int, input().split())
if S <= W:
    print('unsafe')
else:
    print('safe')

Solution (Python):
n, m = list(map(int, input().split()))

if n <= m:
    print('unsafe')
else:
    print('safe')

Solution (Python):
S, W = map(int, input().split())

if W >= S:
    print("unsafe")
else:
    print("safe")

Solution (Python):
S, W = map(int, input().split())
print("safe") if W < S else print("unsafe")

Solution (Python):
s,w = map(int, input().split())
if (w >= s):
    print("unsafe")
else:
    print("safe")

Solution (Python):
s, w = map(int, input().split())
if w >= s:
    print("unsafe")
else:
    print("safe")

Solution (Python):


S, W = map(int, input().split())

if W >= S : 
    print('unsafe')
else :
    print('safe')

Solution (Python):
def resolve():
    S, W = map(int, input().split())

    if W >= S:
        print('unsafe')
        return

    print('safe')


resolve()

Solution (Python):
a, b = map(int, input().split())
print("unsafe" if a <= b else "safe")

Solution (Python):
if __name__ == '__main__':
	 S, W = map(int,input().split())
	 if S <= W:
	 	print('unsafe')
	 else:
	 	print('safe')

Solution (Python):
S,W=map(int,input().split())
print("unsafe" if W>=S else "safe")

Solution (Python):
s,w = map(int,input().split())

if w >= s:
    print('unsafe')
else:
    print('safe')

Solution (Python):
import sys
S,W = map(int,input().split())

print("safe" if S>W else "unsafe")

Solution (Python):
s,w = map(int,input().split())

if s <= w:
    print("unsafe")
else:
    print("safe")

Solution (Python):
S,W=map(int,input().split())
print('safe' if W<S else 'unsafe')

Solution (Python):
s , w = map(int,input().split())
if w >= s:
  	print("unsafe")
else:
  	print('safe')

Solution (Python):

S, W = [int(str) for str in input().strip().split()]

print('unsafe' if W >= S else 'safe')

Solution (Python):
s,w=map(int,input().split())

if s<=w:
  print("unsafe")
else:
  print("safe")

Solution (Python):
a,b=map(int,input().split())
if a>b:
  print('safe')
else:
  print('unsafe')

Solution (Python):
def resolve():
	s, w = map(int, input().split())
	if s > w:
		print('safe')
	else:
		print('unsafe')
resolve()

Solution (Python):
s, w = map(int, input().split())
if s <= w:
  print('unsafe')
else:
  print('safe')

Solution (Python):
s,w=map(int,input().split())
if s<=w:print('unsafe')
else:print('safe')

Solution (Python):




def main():
    s, w = map(int, input().split())
    if s <= w:
        print("unsafe")
    else:
        print("safe")


if __name__ == '__main__':
    main()

Solution (Python):
s,w = map(int,input().split())
ans = "safe" if w < s else "unsafe"
print(ans)

Solution (Python):
from sys import stdin


if __name__ == "__main__":
    _in = [_.rstrip() for _ in stdin.readlines()]
    S, W = list(map(int,_in[0].split(' ')))  
    
    TF = 'unsafe' if W>=S else 'safe'
    
    print(TF)

Solution (Python):
S, W = map(int,input().split())

ans = "unsafe" if W >= S else "safe"
print(ans)

Solution (Python):
S, W = list(map(int, input().split()))

if S <= W:
    print("unsafe")
else:
    print("safe")

Solution (Python):
S, W = map(int, input().split())
if W >= S:
    print("unsafe")
else:
    print("safe")

Solution (Python):
S,W=map(int,input().split())
if W>=S:
    print('unsafe')
else:
    print('safe')

Solution (Python):
import sys
from io import StringIO
import unittest

def resolve():
    s, w = map(int, input().split())

    if w >= s:
        print('unsafe')
    else:
        print('safe')

class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)
    def test_入力例_1(self):
        input = """4 5"""
        output = """unsafe"""
        self.assertIO(input, output)
    def test_入力例_2(self):
        input = """100 2"""
        output = """safe"""
        self.assertIO(input, output)
    def test_入力例_3(self):
        input = """10 10"""
        output = """unsafe"""
        self.assertIO(input, output)

if __name__ == "__main__":
    
    resolve()

Solution (Python):
s,w = map(int,input().split())
if w >= s:
    print("unsafe")
else:
    print("safe")

Solution (Python):
s,w=map(int,input().split())
if w>=s:
	print("unsafe")
else:
	print("safe")

Solution (Python):
s,w=map(int, input().split())
print('unsafe' if s <= w else 'safe')

Solution (Python):
S, W = list(map(int, input().split()))
if S <= W:
    print("unsafe")
else:
    print("safe")

Solution (Python):
s,w = map(int,input().split())
if s<=w:
  print('unsafe')
else:
  print('safe')

Solution (Python):

s, w = map(int, input().split()) 


if s <= w:
    print('unsafe')
else:
    print('safe')

Solution (Python):
s,w =map(int,input().split())
print('unsafe' if (w>=s) else 'safe')

Solution (Python):

s,w = list(map(int, input().split(" ")))

if w >= s:
    print('unsafe')
else:
    print('safe')

Solution (Python):
S, W = map(int, input().split())
print("unsafe" if S <= W else "safe")

Solution (Python):
s,w=map(int,input().split())

if w>=s:
    print("unsafe")
else:
    print("safe")

Solution (Python):
s, w = map(int, input().split())
print("safe" if s>w else "unsafe")

Solution (Python):
def main():
    S, W = map(int, input().split())
    if W >= S:
        print('unsafe')
    else:
        print('safe')


if __name__ == "__main__":
    main()

Solution (Python):
s,w = map(int,input().split())
if s <= w:
    print("unsafe")
else:
    print("safe")

Solution (Python):

N,K=map(int,input().split())
if N>K:
    print('safe')
else:
    print('unsafe')

Solution (Python):
S, W = [int(x) for x in input().split()]
if S > W:
  print("safe")
else:
  print("unsafe")

Solution (Python):
S, W = map(int, input().split())
if W >= S:
    print("unsafe")
else:
    print("safe")

Solution (Python):
import sys
sys.setrecursionlimit(1000000000)
import math
from math import gcd
def lcm(a, b): return a * b // gcd(a, b)
from itertools import count, permutations, chain
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7

def meg(f, ok, ng):
    while abs(ok-ng)>1:
        mid = (ok+ng)//2
        if f(mid):
            ok=mid
        else:
            ng=mid
    return ok

def get_inv(n, modp):
    return pow(n, modp-2, modp)

def factorials_list(n, modp):    
    fs = [1]
    for i in range(1, n+1):
        fs.append(fs[-1] * i % modp)
    return fs

def invs_list(n, fs, modp):     
    invs = [get_inv(fs[-1], modp)]
    for i in range(n, 1-1, -1):
        invs.append(invs[-1] * i % modp)
    invs.reverse()
    return invs

def comb(n, k, modp):
    num = 1
    for i in range(n, n-k, -1):
        num = num * i % modp
    den = 1
    for i in range(2, k+1):
        den = den * i % modp
    return num * get_inv(den, modp) % modp

def comb_from_list(n, k, modp, fs, invs):   
    return fs[n] * invs[n-k] * invs[k] % modp



class UnionFindEx:
    def __init__(self, size):
        
        self.roots = [-1] * size
    def getRootID(self, i):
        r = self.roots[i]
        if r < 0:   
            return i
        else:
            r = self.getRootID(r)
            self.roots[i] = r
            return r
    def getGroupSize(self, i):
        return -self.roots[self.getRootID(i)]
    def connect(self, i, j):
        r1, r2 = self.getRootID(i), self.getRootID(j)
        if r1 == r2:
            return False
        if self.getGroupSize(r1) < self.getGroupSize(r2):
            r1, r2 = r2, r1
        self.roots[r1] += self.roots[r2]    
        self.roots[r2] = r1
        return True

Yes = 'Yes'
No = 'No'


def main():
    S,W=mis()
    print('unsafe' if W>=S else 'safe')



main()

Solution (Python):
s,w = (int(num) for num in input().split())
if s <= w:
    print("unsafe")
else:
    print("safe")

Solution (Python):
N, K = map(int, input().split())
print("unsafe" if K >= N else "safe")

Solution (Python):
s,w=map(int,input().split())

if s<=w:
    print("unsafe")
else:
    print("safe")

Solution (Python):
S,M=map(int,input().split())
if M>=S:
  print("unsafe")
else:
  print("safe")

Solution (Python):
(s, w)=[int(x) for x in input().split()]
print('safe' if s > w else 'unsafe')

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
printV = lambda x: print(*x, sep="\n")
printH = lambda x: print(" ".join(map(str,x)))
def IS(): return sys.stdin.readline()[:-1]
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LII(rows_number): return [II() for _ in range(rows_number)]
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]
mo = 10**9+7

def main():
	s,w = MI()
	if (s <= w):
		print("unsafe")
	else:
		print("safe")

if __name__ == '__main__':
	main()

Solution (Python):
S, W = map(int, input().split())
if W >= S:
    print("unsafe")
else:
    print("safe")

Solution (Python):
s, w = map(int,input().split())
print("unsafe" if w >= s else "safe")

Solution (Python):
S, W= list(map(int, input().split()))

if W >= S:
  print('unsafe')
else:
  print('safe')

Solution (Python):
S,W = map(int,input().split())
if W >= S:
    print('unsafe')
else:
    print('safe')

Solution (Python):
S, W = list(map(int, input().split()))
if S <= W:
    print('unsafe')
else:
    print('safe')

Solution (Python):
S,W=map(int,input().split())
if W>=S:
  print("unsafe")
else:
  print("safe")

Solution (Python):
import sys
input = sys.stdin.readline

def main():
    s, w = map(int, input().split())

    if w >= s:
        print('unsafe')
    else:
        print('safe')

if __name__ == '__main__':
    main()

Solution (Python):
S, W = map(int, input().split())

if W >= S:
    print('unsafe')
else:
    print('safe')

Solution (Python):
S, W = map(int, input().split())

if S <= W:
    print('unsafe')
else:
    print('safe')

Solution (Python):
s, w = map(int, input().split())
if s <= w:
    print('unsafe')
else:
    print('safe')

Solution (Python):
s,w = map(int, input().split())
if w >= s:
    print("unsafe")
else:
    print("safe")

Solution (Python):
import sys
import math
import queue
import copy
import bisect
from collections import deque 


def input(): return sys.stdin.readline()[:-1]
def printl(li): print(*li, sep="\n")
def argsort(s): return sorted(range(len(s)), key=lambda k: s[k])




S,W = map(int, input().split())




















if S<=W:
    print('unsafe')
else:
    print('safe')

Solution (Python):
import sys

input = sys.stdin.readline


def main():
    a, b = map(int, input().split())
    if a <= b:
        print('unsafe')
    else:
        print('safe')


if __name__ == '__main__':
    main()

Solution (Python):
s,w = map(int,input().split())

ans = 'unsafe' if s<=w else 'safe'
print(ans)

Solution (Python):
S,W = map(int,input().split())
if W >=S:
    print('unsafe')
else:
    print('safe')

Solution (Python):
S, W = map(int, input().split())
if W >= S:
    print('unsafe')
else:
    print('safe')

Solution (Python):
s,w = map(int,input().split())


if s<=w:
    print('unsafe')
else:
    print('safe')

Solution (Python):
import sys
readline = sys.stdin.readline

def main():
    S, W = map(int, readline().rstrip().split())
    if W >= S:
        print('unsafe')
    else:
        print('safe')


if __name__ == '__main__':
    main()

Solution (Python):
S, W = map(int, input().split())

if S <= W:
    print("unsafe")
else:
    print("safe")

Solution (Python):
import sys
import math
import collections
from collections import deque
from functools import reduce
import heapq

s, w = map(int, sys.stdin.readline().split())



if s > w:
    print("safe")
else:
    print("unsafe")

Solution (Python):
s,w=map(int,input().split())
print('safe' if s>w else 'unsafe')

Solution (Python):
a, b = map(int, input().split())

if a > b:
    print("safe")
else:
    print("unsafe")

Solution (Python):
s,w=map(int,input().split())

if s<=w:
    print("unsafe")
else:
    print("safe")

Solution (Python):
S, W = map(int, input().split())
if S <= W:
    print('unsafe')
else:
    print('safe')

Solution (Python):
S,W=map(int,input().split())
if(W>=S):
    print("unsafe")
else:
    print("safe")

Solution (Python):
s,w=map(int,input().split())
print("safe")if s>w else print("unsafe")

Solution (Python):



from math import *
from copy import *					
from heapq import *					
from string import *				
from random import *				
from bisect import *				
from sys import stdin				
from sys import maxsize				
from operator import *				
from itertools import *				
from collections import Counter		
from collections import defaultdict 

'''

'''

def solve(l):
	s,w = l
	f = 1
	if(w < s):
		f = 0
	if(f):
		return 'unsafe'
	else:
		return 'safe'

l = list(map(int, stdin.readline().rstrip().split()))
ans = solve(l)
print(ans)

Solution (Python):
s, w = map(int, input().split())

if w >= s:
    print("unsafe")
else:
    print("safe")

Solution (Python):
s,w=map(int, input().split())
if w>=s:
    print("unsafe")
else:
    print("safe")

Solution (Python):
S, W = map(int, input().split())

if S <= W:
    print("unsafe")
else:
    print("safe")

Solution (Python):
s,w=map(int,input().split())
if s<=w:
  print('unsafe')
else:
  print('safe')