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):
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, re
from collections import deque, defaultdict, Counter, OrderedDict
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from heapq import heappush, heappop, heapify, nlargest, nsmallest
def STR(): return list(input())
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def sortListWithIndex(listOfTuples, idx):   return (sorted(listOfTuples, key=lambda x: x[idx]))
def sortDictWithVal(passedDic):
    temp = sorted(passedDic.items(), key=lambda kv: (kv[1], kv[0]))
    toret = {}
    for tup in temp:
        toret[tup[0]] = tup[1]
    return toret
def sortDictWithKey(passedDic):
    return dict(OrderedDict(sorted(passedDic.items())))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

s, w = MAP()
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())
print('safe' if a > b else 'unsafe')

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

Solution (Python):
import math


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):
n, m = map(int, input().split())

if m >= n:
    print('unsafe')

else:
    print('safe')

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

Solution (Python):

n, m = map(int,input().split())

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

Solution (Python):
from __future__ import print_function

import sys
sys.setrecursionlimit(500000)

import re
import array
import copy
import functools
import operator

import math
import string
import fractions
from fractions import Fraction

import collections
import itertools
import bisect

import random
import time

import heapq
from heapq import heappush
from heapq import heappop
from heapq import heappushpop
from heapq import heapify
from heapq import heapreplace
from queue import PriorityQueue as pq
from queue import Queue

from itertools import accumulate

from collections import deque
from collections import Counter

from operator import mul
from functools import reduce

input = sys.stdin.readline


def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)
    return


















def combinations_count(n, r):
    r = min(r, n - r)
    numer = reduce(mul, range(n, n - r, -1), 1)
    denom = reduce(mul, range(1, r + 1), 1)
    return numer // denom


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


if __name__ == '__main__':
    main()

Solution (Python):
s,w=map(int,input().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):
s, w = map(int, input().split())
print("safe" if w < s else "unsafe")

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

S, W = map(int, readline().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 = map(int, input().split())
print('unsafe') if(W >= S) 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())

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","unsafe"][W>=S])

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

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

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

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 w>=s:
  print('unsafe')
else:
  print('safe')

Solution (Python):
S, W = [int(x) for x in 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('unsafe' if s<=w else 'safe')

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

main()

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

Solution (Python):
import collections
import math
import operator as op
from functools import reduce
from collections import Counter
import numpy as np
import math
import bisect
import heapq

MOD = 1000000007

def get_inputs(cast_func=None):
    if cast_func is None:
        return input().split()
    else:
        return list(map(cast_func, input().split()))


def get_input(cast_func=None):
    if cast_func is None:
        return input()
    else:
        return cast_func(input())


def main():
    S, W = get_inputs(int)
    if W >= S:
        print("unsafe")
    else:
        print("safe")



if __name__ == '__main__':
    main()

Solution (Python):
S,W=[int(x) for x in input().rstrip().split()]

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

Solution (Python):
import sys,os
from collections import defaultdict, deque
from math import ceil, floor
if sys.version_info[1] >= 5:
    from math import gcd
else:
    from fractions import gcd
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = (lambda *something: print(*something)) if 'TERM_PROGRAM' in os.environ else lambda *x: 0
def main(given=sys.stdin.readline):
    input = lambda: given().rstrip()
    LMIIS = lambda: list(map(int,input().split()))
    II = lambda: int(input())
    MOD = 10**9+7

    S,W = LMIIS()
    if S <= W:
        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):
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("safe")
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):
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):

import numpy as np
import sys




import numpy as np

"""Template"""


class IP:
    """
    入力を取得するクラス
    """

    def __init__(self):
        self.input = sys.stdin.readline

    def I(self):
        """
        1文字の取得に使います
        :return: int
        """
        return int(self.input())

    def S(self):
        """
        1文字の取得(str
        :return: str
        """
        return self.input()

    def IL(self):
        """
        1行を空白で区切りリストにします(int
        :return: リスト
        """
        return list(map(int, self.input().split()))

    def SL(self):
        """
        1行の文字列を空白区切りでリストにします
        :return: リスト
        """
        return list(map(str, self.input().split()))

    def ILS(self, n):
        """
        1列丸々取得します(int
        :param n: 行数
        :return: リスト
        """
        return [int(self.input()) for _ in range(n)]

    def SLS(self, n):
        """
        1列丸々取得します（str
        :param n: 行数
        :return: リスト
        """
        return [self.input() for _ in range(n)]

    def SILS(self, n):
        """
        Some Int LineS
        横に複数、縦にも複数
        :param n: 行数
        :return: list
        """
        return [self.IL() for _ in range(n)]

    def SSLS(self, n):
        """
        Some String LineS
        :param n: 行数
        :return: list
        """
        return [self.SL() for _ in range(n)]


"""ここからメインコード"""


def main():
    
    r, e = range, enumerate
    ip = IP()

    """この下から書いてね"""
    
    
    
    
    
    s, w = ip.IL()
    if s <= w:
        print("unsafe")
    else:
        print("safe")



main()

Solution (Python):
def main():

    S, W = map(int, input().split())
    if S <= W: return "unsafe"
    return "safe"

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

Solution (Python):
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,copy,time
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp():
    '''
    一つの整数
    '''
    return int(input())
def inpl():
    '''
    一行に複数の整数
    '''
    return list(map(int, input().split()))
def inpl_str():
    '''
    一行に複数の文字
    '''
    return list(input().split())

s, w = inpl()
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('safe') if s > w else print('unsafe')

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

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

	if n <= m:
		print("unsafe")
	else:
		print("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())
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):
l = [int(x) for x in input().split(' ')]
if l[0]>l[1]:
  print("safe")
else:
  print('unsafe')

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):

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

Solution (Python):
import sys
import heapq
from collections import deque


INF = sys.maxsize



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


if __name__ == '__main__':
    main()

Solution (Python):
s,w = map(int,input().split())
print('safe' if s>w else '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 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,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('unsafe')
else:
    print('safe')

Solution (Python):

import sys
input = sys.stdin.buffer.readline


from collections import defaultdict

con = 10 ** 9 + 7

def getlist():
	return list(map(int, input().split()))


def main():
	S, W = getlist()
	if S > W:
		print("safe")
	else:
		print("unsafe")
	


if __name__ == '__main__':
	main()

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('safe')
else:
  print('unsafe')

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):
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 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):
from math import gcd

from math import factorial as f

from math import ceil,floor,sqrt


import bisect
import re
import heapq


from copy import deepcopy
import itertools

from sys import exit

ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

yes = "unsafe"
no = "safe"

def main():
    s,w = mi()
    if w>=s:
        print(yes)
    else:
        print(no)




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('safe' if s>w else 'unsafe')

Solution (Python):
import sys
import re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce


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


def INT(): return int(input())


def MAP(): return map(int, input().split())


def LIST(): return list(map(int, input().split()))


def ZIP(n): return zip(*(MAP() for _ in range(n)))


sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7


def main():
    s, w = MAP()
    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):
import sys
input=sys.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 = map(int, input().split())
if w >= s:
    print("unsafe")
else:
    print("safe")

Solution (Python):
s=input().rstrip().split(' ')
if int(s[1]) >= int(s[0]):
  print("unsafe")
else:
  print("safe")

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

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

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

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline
from collections import defaultdict
from heapq import heappop, heappush

from decimal import *




























def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))

inf = float('inf')
mod = 1000000007




def main():
	S,W = inputMap()

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





def combination(n, r, mod=10**9+7):
    r = min(r, n-r)
    res = 1
    for i in range(r):
        res = res * (n - i) * modinv(i+1, mod) % mod
    return res


def modinv(a, mod=10**9+7):
    return pow(a, mod-2, mod)

def egcd(a, b):
    if a == 0:
        return b, 0, 1
    else:
        g, y, x = egcd(b % a, a)
        return g, x - (b // a) * y, y



def H(n, r, mod=10**9+7):
	
	
    return combination(n+r-1, r, mod)

class Combination:
    """
    O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
    n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
    使用例：
    comb = Combination(1000000)
    print(comb(5, 3))  
    """
    def __init__(self, n_max, mod=10**9+7):
        self.mod = mod
        self.modinv = self.make_modinv_list(n_max)
        self.fac, self.facinv = self.make_factorial_list(n_max)

    def __call__(self, n, r):
        return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod

    def make_factorial_list(self, n):
        
        
        fac = [1]
        facinv = [1]
        for i in range(1, n+1):
            fac.append(fac[i-1] * i % self.mod)
            facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
        return fac, facinv

    def make_modinv_list(self, n):
        
        modinv = [0] * (n+1)
        modinv[1] = 1
        for i in range(2, n+1):
            modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
        return modinv

if __name__ == "__main__":
	main()

Solution (Python):
s,w=map(int,input().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):
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 = (int(x) for x in input().split())
if W >= S:
    print('unsafe')
else:
    print('safe')

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline

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 "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 S <= W else 'safe')

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

Solution (Python):
import sys
from random import choice,randint
inp=sys.stdin.readline
out=sys.stdout.write
flsh=sys.stdout.flush
 
sys.setrecursionlimit(10**9)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
 
def MI(): return map(int, inp().strip().split())
def LI(): return list(map(int, inp().strip().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines().strip()]
def LI_(): return [int(x)-1 for x in inp().strip().split()]
def LF(): return [float(x) for x in inp().strip().split()]
def LS(): return inp().strip().split()
def I(): return int(inp().strip())
def F(): return float(inp().strip())
def S(): return inp().strip()
def pf(s): return out(s+'\n')
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)

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

if __name__ == "__main__":
    main()

Solution (Python):
import math
from collections import defaultdict
ml=lambda:map(int,input().split())
ll=lambda:list(map(int,input().split()))
ii=lambda:int(input())
ip=lambda:(input())

"""========main code==============="""

x,y=ml()
if(y>=x):
    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):
x,y=map(int,input().split())

if x > y:
    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 = map(int, input().split())

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

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from itertools import accumulate, permutations, combinations, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

S, W = MAP()
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):
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):

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 W >= S:
        return 'unsafe'
    else:
        return 'safe'
print(main())

Solution (Python):
S,W=map(int,input().split())
if S>W:
  print("safe")
else:
  print("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('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())
print('unsafe' if W>=S else 'safe')

Solution (Python):
import sys

stdin = sys.stdin

ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))

s, w = nm()
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("safe")
else:
    print("unsafe")

Solution (Python):

import sys


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



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    S = int(next(tokens))  
    W = int(next(tokens))  
    solve(S, W)

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 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):
def main():

    from bisect import bisect_left as bl, bisect_right as br, insort
    import sys
    import heapq
    
    from collections import defaultdict as dd, deque
    def data(): return sys.stdin.readline().strip()
    def mdata(): return map(int, data().split())
    out = sys.stdout.write
    

    s,w=mdata()
    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())

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 s<=w:
    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('safe')
else:
    print('unsafe')

Solution (Python):



 
import sys
import math



 

fileoperation=0
if(fileoperation):
    orig_stdout = sys.stdout
    orig_stdin = sys.stdin
    inputfile = open('W:/Competitive Programming/input.txt', 'r')
    outputfile = open('W:/Competitive Programming/output.txt', 'w')
    sys.stdin = inputfile
    sys.stdout = outputfile


mod=1000000007
 

def nospace(l):
    ans=''.join(str(i) for i in l)
    return ans
 
 
 

t=1
for tt in range(t):
    
    s,w= map(int, sys.stdin.readline().split(' '))
    if s>w:
        print("safe")
    else:
        print("unsafe")
    
    
    

if(fileoperation):
    sys.stdout = orig_stdout
    sys.stdin = orig_stdin
    inputfile.close()
    outputfile.close()

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')

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):
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
def ism():return map(str,input().split())

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

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

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):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from heapq import heapify, heappop, heappush

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
 
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

s, w = MAP()


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 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):
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())
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):
n, k = map(int, input().split())
if n<=k:
  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())
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(v) for v in input().split()]
if W >= S:
    print("unsafe")
else:
    print("safe")

Solution (Python):
import sys, bisect, math, itertools, string, queue, copy


from collections import Counter,defaultdict,deque
from itertools import permutations, combinations
from heapq import heappop, heappush
from fractions import gcd

sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

def main():
    s,w = inpm()
    if s <= w:
        print('unsafe')
    else:
        print('safe')
    
if __name__ == "__main__":
    main()

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

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()

def resolve():

    s,w=map(int,input().split())
    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")