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
from math import ceil, floor, sqrt, sin, cos, pi
from itertools import accumulate, permutations, combinations
from fractions import gcd 
from collections import deque, Counter
from operator import itemgetter
from heapq import heappop,heappush
sys.setrecursionlimit(10**7)
def lcm(x, y): return ((x * y) // gcd(x, y)) 


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

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

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

Solution (Python):
def a164(s, w):

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

Solution (Python):
"""
    Template written to be used by Python Programmers.
    Use at your own risk!!!!
    Owned by enraged(rating - 5 star at CodeChef and Specialist at Codeforces).
"""
import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush, nlargest, nsmallest, _heapify_max, _heapreplace_max
from math import ceil, floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque, Counter as c
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from fractions import Fraction



mod = pow(10, 9) + 7
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(var): sys.stdout.write(str(var))
def outln(var): sys.stdout.write(str(var)+"\n")
def l(): return list(sp())
def sl(): return list(ssp())
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]


s, w = sp()
if s > w:
    outln("safe")
    exit()
outln("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):


a, b = map(int, input().split())

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

Solution (Python):
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do(): 
    s,w=INTM()
    if s<=w:
        print('unsafe')
    else:
        print('safe')
if __name__ == '__main__':
    do()

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

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

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




N, M = map(int, input().split())






if N <= M: print("unsafe")
else: print("safe")

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

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

Solution (Python):

import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub


input = sys.stdin.buffer.readline
INF = 2**62-1

def read_int():
    return int(input())


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


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(S, W):
    return 'safe' if S > W else 'unsafe'


def main():
    S, W = read_int_n()
    print(slv(S, W))


if __name__ == '__main__':
    main()

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):
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 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
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
INF = 10**10
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 = 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 resolve():
    s,w=map(int, input().split())
    if w>=s:
        print('unsafe')
    else:
        print('safe')
resolve()

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

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):
s, w = [int(i) for i in 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):
a,b = map(int,input().split())
if b >= a:
    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):
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 heapq
from collections import defaultdict, deque
from math import ceil, factorial, gcd
from itertools import accumulate
import sys
import bisect

sys.setrecursionlimit(10 ** 7)
INF = float("inf")
MOD = 10 ** 9 + 7

si = lambda: input().strip()
ii = lambda: int(input())
mii = lambda: map(int, input().split())
lmii = lambda: list(map(int, input().split()))
lmsi = lambda: list(map(str, input().split()))
smii = lambda: sorted(map(int, input().split()))



S, W = mii()

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():
    from builtins import int, map, list, print
    import sys
    sys.setrecursionlimit(10 ** 6)

    input = sys.stdin.readline
    input_list = (lambda: input().rstrip().split())
    input_number = (lambda: int(input()))
    input_number_list = (lambda: list(map(int, input_list())))

    S,W = input_number_list()
    print(['unsafe','safe'][S>W])

if __name__ == '__main__':
    main()

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

Solution (Python):




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


if s <= w :
    ans = 'unsafe'
else:
    ans = 'safe'


print(ans)

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline
from itertools import permutations,  combinations, accumulate
from functools import *
from collections import deque, defaultdict, Counter
from heapq import heapify, heappop, heappush, heappushpop

INF = float('inf')
NIL = - 1

""" Input
A = list(map(int, input().split()))
A = np.array(input().split(), dtype=np.float64)
D = [int(input()) for _ in range(N)]
AB = [[int(x) for x in input().split()] for _ in range(N)]
PX = [[int(x) for x in input().split()] for _ in range(Q)]
"""

A, B = map(int, input().split())
print('unsafe' if A <= B else 'safe')

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

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

Solution (Python):
import math
import keyword

def Next(): return input()
def NextInt(): return int(Next())
def NextInts(): return map(int,input().split())
def Nexts(): return map(str,input().split())
def NextIntList(): return list(map(int,input().split()))
def RowInts(n): return [input() for i in range(n)]

s,w = NextInts()

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

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 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().strip().split())
if w>=s:
    print("unsafe")
else:
    print("safe")

Solution (Python):
"""
import random
import functools
import copy
import bisect
import array
import re
import collections
import heapq
import fractions
import itertools
import string
import math
from operator import itemgetter as ig
from bisect import bisect_left, bisect_right, insort_left, insort_right
from itertools import permutations, combinations, product, accumulate, groupby
from heapq import heappush, heappop
from collections import deque, defaultdict, Counter
import sys
sys.setrecursionlimit(10 ** 7)


inf = 10 ** 20
INF = float("INF")
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = dd + [(-1, 1), (1, 1), (1, -1), (-1, -1)]
ddn9 = ddn + [(0, 0)]
'''for dx, dy in dd:
        nx = j + dx; ny = i + dy
            if 0 <= nx < w and 0 <= ny < h:'''
"""
from collections import deque, defaultdict, Counter
import math
import sys
sys.setrecursionlimit(10 ** 7)


def wi(): return list(map(int, sys.stdin.readline().split()))



def wip(): return [int(x) - 1 for x in sys.stdin.readline().split()]


def ws(): return sys.stdin.readline().split()


def si(): return int(sys.stdin.readline())  


def ss(): return input()


def hi(n): return [si() for _ in range(n)]


def hs(n): return [ss() for _ in range(n)]  


def s_list(): return list(input())


def mi(n): return [wi() for _ in range(n)]  


def mip(n): return [wip() for _ in range(n)]


def ms(n): return [ws() for _ in range(n)]


def num_grid(n): return [[int(i) for i in sys.stdin.readline().split()[
    0]] for _ in range(n)]  


def grid(n): return [s_list() for _ in range(n)]


def gcd(a, b):
    while b:
        a, b = b, a % b
    return a


def lcm(a, b):
    """a,bの最小公倍数"""
    return a * b // gcd(a, b)


def main():
    s,w = wi()
    if s <= w:
        print('unsafe')
    else:
        print('safe')

if __name__ == '__main__':
    main()

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

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()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

S, W = MAP()

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

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

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

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

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

def makelist(n, m):
    return [[0 for _ in range(m)] for _ in range(n)]





u = "unsafe"
s = "safe"
S, W = list(map(int, input().split()))

if W >= S:
    print(u)
else:
    print(s)

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

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 = 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):
import sys
from collections import deque
def input(): return sys.stdin.readline().strip()


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

if __name__ == "__main__":
    main()

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

s, w = map(int, input().replace("\n","").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())
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):


from queue import Queue
from queue import LifoQueue as Stack
from math import sqrt, floor, ceil, log2, log10, pi
from fractions import gcd
from itertools import permutations, combinations
from operator import itemgetter
from functools import cmp_to_key


INF=1001001001
__MOD__=(10**9)+7
yn = 'YNeos'
judge = False
cnt = 0
ans = None


def lcm(a, b):
    return (a*b) // gcd(a,b)

def intinput():
    return int(input())

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

def lineinputs(func=intinput):
    datas = []
    while True:
        try:
            datas.append(func())
        except EOFError:
            break
    return datas

class ModInt():
    def __init__(self, x):
        self.__x = (x % __MOD__)
    def __add__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x + other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x + other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __radd__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x + self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x + self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __sub__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x - other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x - other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rsub__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x - self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x - self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __mul__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x * other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x * other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rmul__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x * self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x * self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __truediv__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x * other.__modinv())%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x * other.__modinv())%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rtruediv__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x * self.__modinv())%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x * self.__modinv())%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __pow__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__(pow(self.__x, other.__x, __MOD__)))
        elif type(other) == ModInt:
            return self.__class__(pow(self.__x, other.__x, __MOD__))
        else:
            raise Exception("Not Int or Not ModInt")
    def __rpow__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__(pow(other.__x, self.__x, __MOD__)))
        elif type(other) == ModInt:
            return self.__class__(pow(other.__x, self.__x, __MOD__))
        else:
            raise Exception("Not Int or Not ModInt")

    def __modinv(self, m=__MOD__):
        a = self.__x
        if a == 0:
            raise ZeroDivisionError()
        if gcd(a, m) != 1:
            raise Exception("%sの逆数は求まりません。" % a)
        b, u, v = m, 1, 0
        while b != 0:
            t = a//b;
            a -= t*b
            a, b = b, a
            u -= t * v
            u, v = v, u
        u %= m
        if u < 0:
            u += m
        return u
    def __int__(self):
        return self.__x
    def __str__(self):
        return str(self.__x)



if __name__ == '__main__':
    S, W = mulinputs()

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

Solution (Python):
import sys
range = xrange
input = raw_input

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

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

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


if __name__ == '__main__':
    solve()

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(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())
ans = "unsafe" if s <= w else "safe"
print(ans)

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

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

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


if __name__ == '__main__':
    solve()

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 7)

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

if W >= S:
    ans = "unsafe"
else:
    ans = 'safe'

print(ans)

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

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


def solve(S: int, W: int):
    print('safe' if S > W else 'unsafe')
    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 = 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 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 resolve():
    '''
    code here
    '''
    S, W = [int(item) for item in input().split()]

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

if __name__ == "__main__":
    resolve()

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):
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):
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 = list(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=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 S <= W:
    print("unsafe")
else:
    print("safe")

Solution (Python):
if __name__ == '__main__':
    s = input().rstrip().split(' ')
    S,W = int(s[0]), int(s[1])
    print('unsafe' if S <= W else 'safe')

Solution (Python):

def YesNo(T):
    if T:
        print('unsafe')
    else:
        print('safe')

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

Solution (Python):















mod = int(1e9+7)
INF = 1<<29
lINF = 1<<35

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

def main():
    s,w = readInt()
    if s>w:
        print('safe')
    else:
        print('unsafe')
    return

if __name__=='__main__':
    main()

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

Solution (Python):
printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
ins = lambda : input().strip()
DBG = True 
BIG = 10**18
R = 10**9 + 7

def ddprint(x):
  if DBG:
    print(x)

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

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

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

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

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



'''
A=[]
B=[]
for i in range():
    a, b = map(int, input().split())
    A.append(a)
    B.append(b)'''

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

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

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