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

sys.setrecursionlimit(10**6)
readline = sys.stdin.readline

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

if __name__ == "__main__":
    main()

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

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

Solution (Python):
import sys, re
import math
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

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

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


S, W = [int(x) for x in stdin.readline().rstrip().split()]


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

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
    s,w=map(int,input().split())
    if s<=w:
        print("unsafe")
    else:
        print("safe")

if __name__=='__main__':
    main()

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):
a =list(map(int, input().split()))
s = a[0]
w = a[1]
if s > w:
    print("safe")
else:
    print("unsafe")

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 6)  
to_index = lambda x: int(x) - 1  
print_list_in_2D = lambda x: print(*x, sep="\n")  


def input_int(): return int(input())

def map_int_input(): return map(int, input())

MII = map_int_input

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

def MII_to_index(): return map(to_index, input())

def MII_split_to_index(): return map(to_index, input().split())


def list_int_inputs(): return list(map(int, input()))

LII = list_int_inputs

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


def LII_2D(rows_number): return [LII() for _ in range(rows_number)]

def LII_split_2D(rows_number): return [LII_split() for _ in range(rows_number)]

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

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

Solution (Python):
print('safe' if eval(input().replace(' ','>')) 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())
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()))

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

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

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

Solution (Python):
import sys

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

def main():
    n,m = na()
    if n > m:
        print("safe")
    else:
        print("unsafe")
    return

if __name__ == '__main__':
  main()

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

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

Solution (Python):
import sys
import math

input = sys.stdin.readline

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

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

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

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

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

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

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

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

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

Solution (Python):
import math

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



if n<=k:
    print("unsafe")
    exit()
print("safe")

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

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

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

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

if __name__ == '__main__':
    resolve()

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

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

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

def read_int_map():
    return map(int,input().split(' '))

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

S,W = read_int_map()

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

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

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

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

Solution (Python):

import sys


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

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

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

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

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

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

Solution (Python):

import numpy as np
from collections import deque
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('safe')
else:
    print('unsafe')

Solution (Python):
S, W = [int(n) for n in 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):
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)
from collections import Counter, deque

from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush


def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]



s,w=MI()
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 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 = list(map(int, input().split()))
print('unsafe' if S <= W else 'safe')

Solution (Python):
if __name__ == '__main__':
    from sys import stdin
    input = 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 W >= S:
    print('unsafe')
else:
    print('safe')

Solution (Python):
mod = 10**9+7
import sys
from collections import Counter, defaultdict, deque
from itertools import product, permutations, combinations
from itertools import accumulate
from operator import itemgetter
from bisect import bisect_left,bisect
from heapq import heappop,heappush
from math import ceil,floor
from copy import deepcopy
from heapq import heappop,heappush,heapify
import heapq





sys.setrecursionlimit(10 ** 6)

int1 = lambda x: int(x) - 1


p2D = lambda x: print(*x, sep="\n")

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

def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())




def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LI(): return list(map(lambda x:int(x), sys.stdin.readline().split()))
def HI(): return list(map(lambda x:int(x)*(-1), sys.stdin.readline().split()))


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

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

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

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

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

















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

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

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

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

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

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

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

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

Solution (Python):
(s, w) = tuple(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
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7


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


if __name__ == '__main__':
    main()

Solution (Python):

import re
import math
from collections import defaultdict
import itertools
from copy import deepcopy
import random
from heapq import heappop,heappush
import time
import os
import queue
import sys
import datetime
from functools import lru_cache
readline=sys.stdin.readline
sys.setrecursionlimit(2000)

alphabet="abcdefghijklmnopqrstuvwxyz"
mod=int(10**9+7)
inf=int(10**20)
def yn(b):
    if b:
        print("yes")
    else:
        print("no")
def Yn(b):
    if b:
        print("Yes")
    else:
        print("No")
def YN(b):
    if b:
        print("YES")
    else:
        print("NO")
class union_find():
    def __init__(self,n):
        self.n=n
        self.P=[a for a in range(N)]
        self.rank=[0]*n
 
    def find(self,x):
        if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
        return self.P[x]
 
    def same(self,x,y):
        return self.find(x)==self.find(y)
 
    def link(self,x,y):
        if self.rank[x]<self.rank[y]:
            self.P[x]=y
        elif self.rank[y]<self.rank[x]:
            self.P[y]=x
        else:
            self.P[x]=y
            self.rank[y]+=1
 
    def unite(self,x,y):
        self.link(self.find(x),self.find(y))
 
    def size(self):
        S=set()
        for a in range(self.n):
            S.add(self.find(a))
        return len(S)
def is_power(a,b):
    now=b
    while now<a:
        now*=b
    if now==a:return True
    else:return False
def bin_(num,size):
    A=[0]*size
    for a in range(size):
        if (num>>(size-a-1))&1==1:
            A[a]=1
        else:
            A[a]=0
    return A
def get_facs(n,mod_=0):
    A=[1]*(n+1)
    for a in range(2,len(A)):
        A[a]=A[a-1]*a
        if(mod>0):A[a]%=mod_
    return A
def comb(n,r,mod,fac):
    if(n-r<0):return 0
    return (fac[n]*pow(fac[n-r],mod-2,mod)*pow(fac[r],mod-2,mod))%mod
def next_comb(num,size):
    x=num&(-num)
    y=num+x
    z=num&(~y)
    z//=x
    z=z>>1
    num=(y|z)
    if(num>=(1<<size)):return False
    else:
        return num
def get_primes(n,type="int"):
    A=[True]*(n+1)
    A[0]=False
    A[1]=False
    for a in range(2,n+1):
        if A[a]:
            for b in range(a*2,n+1,a):
                A[b]=False
    if(type=="bool"):return A
    B=[]
    for a in range(n+1):
        if(A[a]):B.append(a)
    return B
def is_prime(num):
    if(num<=2):return False
    i=2
    while i*i<=num:
       if(num%i==0):return False
       i+=1
    return True
def ifelse(a,b,c):
    if a:return b
    else:return  c
def join(A,c=" "):
    n=len(A)
    A=list(map(str,A))
    s=""
    for a in range(n):
        s+=A[a]
        if(a<n-1):s+=c
    return s
def factorize(n,type_="dict"):
    b = 2
    list_ = []
    while b * b <= n:
        while n % b == 0:
            n //= b
            list_.append(b)
        b+=1
    if n > 1:list_.append(n)
    if type_=="dict":
        dic={}
        for a in list_:
            if a in dic:
                dic[a]+=1
            else:
                dic[a]=1
        return dic
    elif type_=="list":
        return list_
    else:
        return None
def floor_(n,x=1):
    return x*(n//x)
def ceil_(n,x=1):
    return x*((n+x-1)//x)
def hani(x,min_,max_):
    ret=x
    if x<min_:ret=min_
    if x>max_:ret=max_
    return ret
def seifu(x):
    return x//abs(x)


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

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

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


def check():
    if S<=W:
        return True
if check():
    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):
s, w = map(int, input().split())

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

Solution (Python):
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))

S, W = MAP()

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

Solution (Python):
from functools import reduce
from fractions import gcd
import math
import bisect
import itertools
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
INF = float("inf")


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

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

Solution (Python):
import sys, math
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mod = 10**9 + 7

S, W = rl()

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

Solution (Python):
if __name__ == '__main__':
    b, c = map(int, input().split())

    if b > c:
        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 =  [int(i) for i in input().split()]

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

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

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

if __name__ == '__main__':
    main()

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

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

Solution (Python):
import math

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

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

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

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

Solution (Python):
import numpy as np
import sys
import math

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


if __name__ == "__main__":
    resolve()

Solution (Python):


def main():
    SW = list(map(int, input().split()))

    if SW[0] > SW[1]:
        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] = 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' if s > w else 'unsafe')

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

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):
import sys
import itertools
if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
    
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 w >= s:
  print("unsafe")
else:
  print("safe")

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

Solution (Python):
import sys, 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 functools import reduce
from bisect import bisect_left, insort_left
from heapq import heapify, heappush, heappop

INPUT = lambda: sys.stdin.readline().rstrip()
INT = lambda: int(INPUT())
MAP = lambda: map(int, INPUT().split())
S_MAP = lambda: map(str, INPUT().split())
LIST = lambda: list(map(int, INPUT().split()))
S_LIST = lambda: list(map(str, INPUT().split()))

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):











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

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

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

Solution (Python):


MOD = 10**9
def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)
    return divisors

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

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

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

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

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

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

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

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

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

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

Solution (Python):

import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from decimal import *
from collections import deque
from math import gcd
sys.setrecursionlimit(10**7)
MOD = 10**9+7
INF = float('inf') 
def lcm(a,b):return (a*b) // gcd(a,b) 
def iin(): return int(sys.stdin.readline()) 
def ifn(): return float(sys.stdin.readline()) 
def isn(): return sys.stdin.readline().split() 
def imn(): return map(int, sys.stdin.readline().split()) 
def imnn(): return map(lambda x:int(x)-1, sys.stdin.readline().split()) 
def fmn(): return map(float, sys.stdin.readline().split()) 
def iln(): return list(map(int, sys.stdin.readline().split())) 
def iln_s(): return sorted(iln()) 
def iln_r(): return sorted(iln(), reverse=True) 
def fln(): return list(map(float, sys.stdin.readline().split())) 
def join(l, s=''): return s.join(l) 
def perm(l, n): return itertools.permutations(l, n) 
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) 
def comb(l, n): return itertools.combinations(l, n) 
def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 
def m_add(a,b): return (a+b) % MOD
def lprint(l): print(*l, sep='\n')

S,W = imn()

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

Solution (Python):
a=input().split()
if int(a[0])<=int(a[1]) :
  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 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())
print("safe" if s>w else "unsafe")

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