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



Sample input:
4 5


Sample output:
unsafe

Submission status: Accepted

Solution code:
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from heapq import heapify, heappop, heappush

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

s, w = MAP()


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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:

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

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
def main():
    S,W = map(int,input().split())
    if W >= S:
        print('unsafe')
    else:print('safe')
if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys, bisect, math, itertools, string, queue, copy
# import numpy as np
# import scipy
from collections import Counter,defaultdict,deque
from itertools import permutations, combinations
from heapq import heappop, heappush
from fractions import gcd
# input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

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

Submission status: Accepted

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

Submission status: Accepted

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

def resolve():

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

resolve()

Submission status: Accepted

Solution code:
def main():
    import sys
    sys.setrecursionlimit(10 ** 6)
    input = sys.stdin.readline
    s, w = [int(x) for x in input().strip().split()]
    if s <= w:
        print('unsafe')
    else:
        print('safe')


if __name__ == '__main__':
    main()

Submission status: Accepted

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

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

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
#A

#デバッグ
debug=1
def pront(*n):
    if debug==1:
        print(n)
        
#10**9+7を底とした処理

base=10**9+7

def add(a,b):#a+b
    return (a+b)%base

def sub(a,b):#a-b
    return (a-b)%base

def multi(a,b):#a*b
    return (a*b)%base

def exp(a,b):#a**b
    x=1
    c=a
    d=b
    while d!=0:
        if d%2==1:
            x=multi(x,c)
        c=(c**2)%base
        d=d//2
    return x

def div(a,b):#a/b
    return(multi(a,exp(b,base-2)))

#入力

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


#処理


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

Submission status: Accepted

Solution code:
import bisect
import copy
import heapq
import math
import sys
from collections import *
from itertools import accumulate, combinations, permutations, product
from math import gcd
def input():
    return sys.stdin.readline()[:-1]
def ruiseki(lst):
    return [0]+list(accumulate(lst))
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]
direction=[[1,0],[0,1],[-1,0],[0,-1]]

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

Submission status: Accepted

Solution code:
n,w = list(map(int,input().split()))
if w >= n :
  print('unsafe')
else:
  print('safe')

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
# coding: utf-8
import sys

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import sys

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


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

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


if __name__ == '__main__':
    resolve()

Submission status: Accepted

Solution code:
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): #intのlist
    return list(map(int,input().split()))
def m(): #複数文字
    return map(int,input().split())
def onem(): #Nとかの取得
    return int(input())
def s(x): #圧縮
    a = []
    if len(x) == 0:
        return []
    aa = x[0]
    su = 1
    for i in range(len(x)-1):
        if aa != x[i+1]:
            a.append([aa,su])
            aa = x[i+1]
            su = 1
        else:
            su += 1
    a.append([aa,su])
    return a
def jo(x): #listをスペースごとに分ける
    return " ".join(map(str,x))
def max2(x): #他のときもどうように作成可能
    return max(map(max,x))
def In(x,a): #aがリスト(sorted)
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False

def pow_k(x, n):
    ans = 1
    while n:
        if n % 2:
            ans *= x
        x *= x
        n >>= 1
    return ans

"""
def nibu(x,n,r):
    ll = 0
    rr = r
    while True:
        mid = (ll+rr)//2

    if rr == mid:
        return ll
    if (ここに評価入れる):
        rr = mid
    else:
        ll = mid+1
"""

a,b = m()

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

Submission status: Accepted

Solution code:
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
def main():
    S, W = map(int, input().split())

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


if __name__ == '__main__':
    main()

# import sys
# input = sys.stdin.readline
# 
# sys.setrecursionlimit(10 ** 7)
# 
# (int(x)-1 for x in input().split())
# rstrip()
#
# def binary_search(*, ok, ng, func):
#     while abs(ok - ng) > 1:
#         mid = (ok + ng) // 2
#         if func(mid):
#             ok = mid
#         else:
#             ng = mid
#     return ok

Submission status: Accepted

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

Submission status: Accepted

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

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
ma = lambda : map(int,input().split())
ni = lambda : int(input())
s,w = ma()

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys
input = sys.stdin.readline

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

Submission status: Accepted

Solution code:
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial, gcd
from bisect import bisect_left #bisect_left(list, value)
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
def pri(x): print('\n'.join(map(str, x)))

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

if N<=K:
    print('unsafe')
else:
    print('safe')

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
k = list(map(int,input().split()))
if k[0] > k[1]:
  print("safe")
else:
  print("unsafe")

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

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

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

Submission status: Accepted

Solution code:
import sys
import math  # noqa
import bisect  # noqa
import queue  # noqa


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


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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
input = raw_input

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

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

Submission status: Accepted

Solution code:
# coding: utf-8


def solve(*args: str) -> str:
    s, w = map(int, args[0].split())

    return 'unsafe' if s <= w else 'safe'


if __name__ == "__main__":
    print(solve(*(open(0).read().splitlines())))

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

main()

Submission status: Accepted

Solution code:
from sys import stdin
def main():
    #入力
    readline=stdin.readline
    S,W=map(int,readline().split())

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

if __name__=="__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

else:
    print('safe')

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

#############
# Libraries #
#############

import sys
input = sys.stdin.readline

import math
from collections import deque
from fractions import gcd
from functools import lru_cache


#############
# Constants #
#############

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

#############
# Functions #
#############

######INPUT######
def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]

#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)

######Combination######
kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret

######Factorization######
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])
    return arr

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

#############
# Main Code #
#############

S,W = inputIL()

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
S, W = [int(n) for n in input().split()]
if W >= S:
    print('unsafe')
else:
    print('safe')

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline


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


if __name__ == '__main__':
    solve()

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
#a
x = [int(x) for x in input().split()]

if x[0] > x[1]:
    print("safe")
else:
    print("unsafe")

Submission status: Accepted

Solution code:
from collections import deque
from heapq import heapify,heappop,heappush,heappushpop
from copy import copy,deepcopy
from itertools import permutations,combinations
from collections import defaultdict,Counter
from bisect import bisect_left,bisect_right
# from math import gcd,ceil,floor,factorial
# from fractions import gcd
from functools import reduce
from pprint import pprint

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

def mylistinput(n):
    return [ list(myinput()) for _ in range(n) ]

def mycol(data,col):
    return [ row[col] for row in data ]

def mysort(data,col,reverse_flag):
    data.sort(key=lambda x:x[col],reverse=reverse_flag)
    return data

def mymax(data):
    M = -1*float("inf")
    for i in range(len(data)):
        m = max(data[i])
        M = max(M,m)
    return M

def mymin(data):
    m = float("inf")
    for i in range(len(data)):
        M = min(data[i])
        m = min(m,M)
    return m

def myoutput(ls,space=True):
    if space:
        if len(ls)==0:
            print(" ")
        elif type(ls[0])==str:
            print(" ".join(ls))
        elif type(ls[0])==int:
            print(" ".join(map(str,ls)))
        else:
            print("Output Error")
    else:
        if len(ls)==0:
            print("")
        elif type(ls[0])==str:
            print("".join(ls))
        elif type(ls[0])==int:
            print("".join(map(str,ls)))
        else:
            print("Output Error")

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

Submission status: Accepted

Solution code:
#n = int(input())
a,b = map(int,input().split())
#a_L = list(map(int,input().split()))

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

Submission status: Accepted

Solution code:
s, w = map(int, input().split())
print(['safe', 'unsafe'][s<=w])

Submission status: Accepted

Solution code:
import sys
from collections import deque
input = lambda: sys.stdin.readline().rstrip()
safe = lambda boolean: print('safe') if boolean else print('unsafe')
YES = lambda boolean: print('YES') if boolean else print('NO')
aint = lambda: int(input())
ints = lambda: list(map(int, input().split()))
is_even = lambda x: True if x%2==0 else False

s,w = ints()
safe(s>w)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(int, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from itertools import accumulate #list(accumulate(A))

S, W = mi()

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

Submission status: Accepted

Solution code:
import sys

read = sys.stdin.read
readline = sys.stdin.readline

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

Submission status: Accepted

Solution code:
#create date: 2020-04-26 21:00

import sys
stdin = sys.stdin

def ns(): return stdin.readline().rstrip()
def ni(): return int(ns())
def na(): return list(map(int, stdin.readline().split()))

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

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
#
# 　　  ⋀_⋀　 
#　　  (･ω･)  
# .／ Ｕ ∽ Ｕ＼
#  │＊　合　＊│
#  │＊　格　＊│ 
#  │＊　祈　＊│ 
#  │＊　願　＊│ 
#  │＊　　　＊│ 
#      ￣
#
import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,sqrt,factorial,hypot,log #log2ないｙｐ
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 fractions import gcd
from random import randint
def ceil(a,b): return (a+b-1)//b
inf=float('inf')
mod = 10**9+7
def pprint(*A): 
    for a in A:     print(*a,sep='\n')
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    A,B=MI()
    if(A<=B):
        print("unsafe")
    else:
        print("safe")
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10 ** 8)

input = sys.stdin.readline


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

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
s,w=[int(j) for j in input().split()]
if s<=w:
    print("unsafe")
else:
    print("safe")

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():
    K, N = map(int,input().split())
    if K<=N:
        print('unsafe')
    else:
        print('safe')


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#MLE注意！ not は使わず !=
#0や1のケースに注意

def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    #from collections import defaultdict
    from itertools import combinations, permutations, accumulate, groupby, product
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    import math

    #inf = 10**17
    #mod = 10**9 + 7

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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# coding: utf-8
S, W = map(int, input().split())
print("safe" if S > W else "unsafe")

Submission status: Accepted

Solution code:
#A
s,w = map(int,input().split())

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

Submission status: Accepted

Solution code:
import time
startTimeProblem=time.time()

import fileinput, sys, itertools, functools
from math import *
from bisect import *
from heapq import *
from collections import *

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

class InputHelper:
    def __init__(self):
        self.myinput = fileinput.input()

    def isLocal(self):
        return not fileinput.isstdin()

    def int(self):
        return int(self.myinput.readline().rstrip())

    def ints(self):
        return [int(_) for _ in self.myinput.readline().rstrip().split()]

    def str(self):
        return self.myinput.readline().rstrip()

    def strs(self):
        return [_ for _ in self.myinput.readline().rstrip().split()]

class OutputHelper:
    def int(self, a):
        print(a)    

    def ints(self, a):  
        print(" ".join([str(_) for _ in a]))
    
    def intsNL(self, a):
        for _ in a:
            print(_)
    
    def str(self, s):
        print(s)

    def strs(self, s):
        print(" ".join([_ for _ in s]))

    def strsNL(self, s):
        for st in s:
            print(st)

class ListNode:
    def __init__(self, val):
        self.val = val
        self.next = None
        self.prev = None

In = InputHelper()
Out = OutputHelper()

######################################

S, W = In.ints()

if W>=S:
    Out.str("unsafe")
else:
    Out.str("safe")

######################################

if len(sys.argv)>2 and sys.argv[2]=="TIMEIT":
    fin = (time.time()-startTimeProblem)*1000
    print("{:.2f}".format(fin) + "ms")

Submission status: Accepted

Solution code:
#!/usr/bin/env python3

from pprint import pprint
from collections import deque, defaultdict
import sys

sys.setrecursionlimit(10 ** 6)
inf = float("inf")

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N,K=[int(s) for s in input().split()]
if N>K:
  print('safe')
else:
  print('unsafe')

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A, B = map(int, input().split())

if A <= B:
    print("unsafe")
else:
    print("safe")

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
a=[int(i) for i in input().split()]
if a[0]>a[1]:
    print("safe")
else:
    print("unsafe")

Submission status: Accepted

Solution code:
#!/usr/bin/env python3

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

if __name__ == "__main__":
    main()

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import sys
## io
IS = lambda: sys.stdin.readline().rstrip()
II = lambda: int(IS())
MII = lambda: list(map(int, IS().split()))
MIIZ = lambda: list(map(lambda x: x-1, MII()))
## dp
INIT_VAL = 0
MD2 = lambda d1,d2: [[INIT_VAL]*d2 for _ in range(d1)]
MD3 = lambda d1,d2,d3: [MD2(d2,d3) for _ in range(d1)]
## math
DIVC = lambda x,y: -(-x//y)
DIVF = lambda x,y: x//y

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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# ABC164 A

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

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

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

input = sys.stdin.readline


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

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


if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
S,W=map(int,input().split())
print(['safe','unsafe'][S<=W])

Submission status: Accepted

Solution code:
LI = lambda: list(map(int,input().split()))
MI = lambda: map(int,input().split())
yes = lambda: print("YES")
no = lambda: print("NO")
I = lambda: list(input())
J = lambda x: "".join(x)
II = lambda: int(input())
SI = lambda: input()
#---khan17---template
n,w = MI()
if w>=n:
	print("unsafe")
else:
	print("safe")

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
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()

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
s,w = list(map(int,input().split()))
if w >= s:
    print("unsafe")
else:
    print("safe")

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:
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')