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 = list(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
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1

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

if __name__ == '__main__':
    main()

Solution (Python):
import collections
import sys
import numpy as np
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
MOD = 10**9+7
import itertools
import math

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

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

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

Solution (Python):
S, W = [int(_n) for _n in 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):
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**6)
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

s,w = na()

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

Solution (Python):
import sys
import math
import fractions
from collections import deque
from collections import defaultdict
sys.setrecursionlimit(10**7)

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

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

Solution (Python):
def solve():
    if w >= s:
        print("unsafe")
    else:
        print("safe")
    return



s, w = [int(s) for s in input().split(" ")]
solve()

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

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

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

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

Solution (Python):
MOD = 10 ** 9 + 7
INF = 10 ** 10
import sys
sys.setrecursionlimit(100000000)
dy = (-1,0,1,0)
dx = (0,1,0,-1)

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

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

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

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

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

if n>=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("unsafe" if w >= s else "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):
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
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 LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

def main():
  s,w=LI()
  if w>=s:
    return 'unsafe'
  return 'safe'


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

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

Solution (Python):
import sys 
try:
	sys.stdin = open('input.txt', 'r') 
	sys.stdout = open('output.txt', 'w')
except:
	pass
input = sys.stdin.readline
for tt in range(1):
	
	s,w = map(int,input().split())
	if w>=s:
		print("unsafe")
	else:
		print("safe")

Solution (Python):
import sys
import math

from collections import defaultdict
from collections import deque
def load(vtype=int):
    return vtype(input().strip())
def load_list(seplator=" ", vtype=int):
    return [vtype(v) for v in input().strip().split(seplator)]
def exit():
    import sys
    sys.exit(0)
def perm_sub(li, used):
    if len(li) == len(used):
        return [deque()]
    k = []
    for i in range(len(li)):
        if i in used:
            continue
        used.add(i)
        sub_list = perm_sub(li, used)
        for sub in sub_list:
            sub.appendleft(li[i])
        k.extend(sub_list)
        used.discard(i)
    return k
def perm_li(li):
    return perm_sub(li, set())
def perm_n(n):
    return perm_sub(list(range(n)), set())
def join_i(li, sep=""):
    return sep.join([str(e) for e in li])
def li2n(li):
    n, base = 0, 1
    for i in range(len(li)-1, -1, -1):
        n += li[i] * base
        base *= 10
    return n
def sli2ili(li):
    return [int(s) for s in li] 
def prime_list(n):
    li = [i for i in range(2, n+1)]
    for i in range(len(li)):
        if li[i] >= int(math.sqrt(n)):
            break
        if li[i] == -1:
            continue
        for j in range(i+1, len(li)):
            if li[j] % li[i] == 0:
                li[j] = -1
    return [n for n in li if n != -1]
def gcd(a, b):
    a, b = max(a, b), min(a, b)
    while True:
        r = a % b
        if r == 0: return b
        a, b = b, r
def lcm(a, b):
    return int(a * b / gcd(a,b))
def all_subset(li):
    s = []
    n = len(li)
    for bit in range(0, (1<<(n+1))):
        ss = set()
        for i in range(0, n):
            if (bit & (1 << i)):
                ss.add(li[i])
        s.append(ss)
    return s
def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n-1)
def mCn(m, n):
    def factorial_ntimes(m, n):
        r = 1
        while n:
            r *= m
            m -= 1
            n -= 1
        return r
    return int(factorial_ntimes(m, n) / factorial(n))

s, w = load_list()

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('unsafe' if w >= s else '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):
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 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):
import sys

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

    return 0

if __name__ == "__main__":
    solve()

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

Solution (Python):
n,k = [int(i) for i in input().split()]

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

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

Solution (Python):
import sys
input = sys.stdin.readline
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
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue
from decimal import *


class Scanner():
    @staticmethod
    def int():
        return int(sys.stdin.readline().rstrip())

    @staticmethod
    def string():
        return sys.stdin.readline().rstrip()

    @staticmethod
    def map_int():
        return [int(x) for x in Scanner.string().split()]

    @staticmethod
    def string_list(n):
        return [Scanner.string() for i in range(n)]

    @staticmethod
    def int_list_list(n):
        return [Scanner.map_int() for i in range(n)]

    @staticmethod
    def int_cols_list(n):
        return [Scanner.int() for i in range(n)]


class Math():
    @staticmethod
    def gcd(a, b):
        if b == 0:
            return a
        return Math.gcd(b, a % b)

    @staticmethod
    def lcm(a, b):
        return (a * b) // Math.gcd(a, b)

    @staticmethod
    def divisor(n):
        res = []
        i = 1
        for i in range(1, int(n ** 0.5) + 1):
            if n % i == 0:
                res.append(i)
                if i != n // i:
                    res.append(n // i)
        return res

    @staticmethod
    def round_up(a, b):
        return -(-a // b)

    @staticmethod
    def is_prime(n):
        if n < 2:
            return False
        if n == 2:
            return True
        if n % 2 == 0:
            return False
        d = int(n ** 0.5) + 1
        for i in range(3, d + 1, 2):
            if n % i == 0:
                return False
        return True


def pop_count(x):
    x = x - ((x >> 1) & 0x5555555555555555)
    x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
    x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
    x = x + (x >> 8)
    x = x + (x >> 16)
    x = x + (x >> 32)
    return x & 0x0000007f


MOD = int(1e09) + 7
INF = int(1e15)


def solve():
    S, W = Scanner.map_int()
    if W >= S:
        print('unsafe')
    else:
        print('safe')


def main():
    
    solve()


if __name__ == "__main__":
    main()

Solution (Python):
import sys
from collections import defaultdict, Counter, deque
from itertools import accumulate, permutations, combinations
from operator import itemgetter
from bisect import bisect_left, bisect_right, bisect
from heapq import heappop, heappush
from fractions import gcd
from math import ceil, floor, sqrt, cos, sin, pi
from copy import deepcopy




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

if __name__ == '__main__':
    main()

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

stdin = sys.stdin
inf = 1 << 60
mod = 1000000007

ni      = lambda: int(ns())
nin     = lambda y: [ni() for _ in range(y)]
na      = lambda: list(map(int, stdin.readline().split()))
nan     = lambda y: [na() for _ in range(y)]
nf      = lambda: float(ns())
nfn     = lambda y: [nf() for _ in range(y)]
nfa     = lambda: list(map(float, stdin.readline().split()))
nfan    = lambda y: [nfa() for _ in range(y)]
ns      = lambda: stdin.readline().rstrip()
nsn     = lambda y: [ns() for _ in range(y)]
ncl     = lambda y: [list(ns()) for _ in range(y)]
nas     = lambda: stdin.readline().split()

s, w = na()

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

Solution (Python):
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate, product
import sys
import bisect
import string
import math
import time


def I(): return int(input())


def S(): return input()


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


def MS(): return map(str, input().split())


def LI(): return [int(i) for i in input().split()]


def LI_(): return [int(i)-1 for i in input().split()]


def StoI(): return [ord(i)-97 for i in input()]


def ItoS(nn): return chr(nn+97)


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


def debug(table, *args):
    ret = []
    for name, val in table.items():
        if val in args:
            ret.append('{}: {}'.format(name, val))
    print(' | '.join(ret), file=sys.stderr)


yn = {False: 'No', True: 'Yes'}
YN = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']

show_flg = False



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

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


if __name__ == '__main__':
    main()

Solution (Python):
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):

"""
Created on Sun Apr 26 20:56:09 2020

@author: Kanaru Sato
"""

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

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

Solution (Python):
S, W = [int(i) for i in 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):
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)


def get_nums_l():
    return [ int(s) for s in input().split(" ")]


def get_nums_n(n):
    return [ int(input()) for _ in range(n)]


def get_all_int():
    return map(int, open(0).read().split())

def log(*args):
    print("DEBUG:", *args, file=sys.stderr)

s,w = get_all_int()

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

Solution (Python):
import bisect
import collections
import sys

sys.setrecursionlimit(100000)
input = sys.stdin.readline
ACMOD = 1000000007
INF = 1 << 62


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


def llmi(n):
    return [lmi() for _ in range(n)]


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

Solution (Python):
import numpy as np
import math
s,w = map(int,input().split())

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

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

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

Solution (Python):
N, M = map(int, input().split())

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

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

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

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

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

Solution (Python):
import itertools

def solve():
  s, w = map(int, input().split())
  if s > w:
    print("safe")
  else:
    print("unsafe")
  return 0
 
if __name__ == "__main__":
  solve()

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

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):
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 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):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque

sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
     
def main():
    s, w = LI()
    if w >= s:
        print("unsafe")
    else:
        print("safe")

main()

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

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


if __name__ == '__main__':
    main()

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin, log, log10, gcd
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits

def debug(*args):
    if debugmode:
        print(*args)
def input(): return sys.stdin.readline().strip()
def STR(): return input()
def INT(): return int(input())
def FLOAT(): return float(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()))
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7
dx = [0, 1, 0, -1, 1, -1, -1, 1]
dy = [1, 0, -1, 0, 1, -1, 1, -1]
debugmode = True

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

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

if __name__ == '__main__':
    main()

Solution (Python):
def get_ints():
    return list(map(int, input().split()))

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

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

Solution (Python):

import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1

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

Solution (Python):
import sys
sys.setrecursionlimit(10**6)
from math import floor,ceil,sqrt,factorial,log
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from operator import itemgetter
from fractions import gcd
mod = 10 ** 9 + 7
inf = float('inf')
ninf = -float('inf')
 

def ii(): return int(sys.stdin.readline().rstrip()) 
def mii(): return map(int,sys.stdin.readline().rstrip().split())
def limii(): return list(mii()) 
def lin(n:int): return [ii() for _ in range(n)]
def llint(n: int): return [limii() for _ in range(n)]

def ss(): return sys.stdin.readline().rstrip() 
def mss(): return sys.stdin.readline().rstrip().split()
def limss(): return list(mss()) 
def lst(n:int): return [ss() for _ in range(n)]
def llstr(n: int): return [limss() for _ in range(n)]






s,w=mii()
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):
import math

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

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

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

Solution (Python):


import sys
import math
import collections
import itertools
INF = 10 ** 13
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def lcm(x, y) : return (x * y) // math.gcd(x, y)
def I() : return int(input())
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(input()) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]
def LS() : return input().split()
def RS(N) : return [input() for _ in range(N)]
def LRS(N) : return [input().split() for _ in range(N)]
def PL(L) : print(*L, sep="\n")
def YesNo(B) : print("Yes" if B else "No")
def YESNO(B) : print("YES" if B else "NO")

S, W = LI()

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 s<=w else "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):

def inputlist(): return [int(k) for k in input().split()]

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

Solution (Python):
from sys import stdin
from sys import setrecursionlimit
from collections import Counter, deque, defaultdict
from bisect import bisect_left
setrecursionlimit(1000000)

INF = int(1e10)
MOD = int(1e9 + 7)

def input():
    return stdin.readline()[:-1]


def main():
    from builtins import int, map
    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('safe')
else:
    print('unsafe')

Solution (Python):

import sys
sys.setrecursionlimit(10**8)
INF = float("inf")


def solve(S: int, W: int):
    if W >= S:
        print("unsafe")
    else:
        print("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):



def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**6)
    

    def dump(*args):
        sys.stderr.write(str(args))

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


if __name__ == '__main__':
    main()

Solution (Python):
import bisect
import cmath
import heapq
import itertools
import math
import operator
import os
import random
import re
import string
import sys
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from functools import lru_cache, reduce
from math import gcd
from operator import add, itemgetter, mul, xor

import numpy as np

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

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


S, W = list(map(int, sys.stdin.buffer.readline().split()))
if S <= W:
    print('unsafe')
else:
    print('safe')

Solution (Python):
from statistics import median


from fractions import gcd
from itertools import combinations 
from collections import deque
from collections import defaultdict
import bisect










import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7

def readInts():
  return list(map(int,input().split()))
def main():
    s,w = readInts()
    if w >= s:
        print('unsafe')
    else:
        print('safe')
if __name__ == '__main__':
  main()

Solution (Python):

from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.buffer.readline().split()]
def I(): return int(sys.stdin.buffer.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007

def solve():
    s,w = LI()
    if s <= w:
        print("unsafe")
    else:
        print("safe")
    return


if __name__ == "__main__":
    solve()

Solution (Python):
"""
じょえチャンネルおもしろいよ～～～
https://www.youtube.com/channel/UCRXsI3FL_kvaVL9zoolBfbQ
"""

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