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


if __name__ == "__main__":
    _in = [_.rstrip() for _ in stdin.readlines()]
    S, W = list(map(int,_in[0].split(' ')))  # type:list(int)
    # vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
    TF = 'unsafe' if W>=S else 'safe'
    # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    print(TF)

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 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:
import sys
from io import StringIO
import unittest

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

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

class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)
    def test_入力例_1(self):
        input = """4 5"""
        output = """unsafe"""
        self.assertIO(input, output)
    def test_入力例_2(self):
        input = """100 2"""
        output = """safe"""
        self.assertIO(input, output)
    def test_入力例_3(self):
        input = """10 10"""
        output = """unsafe"""
        self.assertIO(input, output)

if __name__ == "__main__":
    # unittest.main()
    resolve()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# int(input()) # 入力が1つ
s, w = map(int, input().split()) # 入力が複数
# [int(i) for i in 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:
#n = int(input())
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())
    if W >= S:
        print('unsafe')
    else:
        print('safe')


if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(1000000000)
import math
from math import gcd
def lcm(a, b): return a * b // gcd(a, b)
from itertools import count, permutations, chain
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7

def meg(f, ok, ng):
    while abs(ok-ng)>1:
        mid = (ok+ng)//2
        if f(mid):
            ok=mid
        else:
            ng=mid
    return ok

def get_inv(n, modp):
    return pow(n, modp-2, modp)

def factorials_list(n, modp):    # 10**6
    fs = [1]
    for i in range(1, n+1):
        fs.append(fs[-1] * i % modp)
    return fs

def invs_list(n, fs, modp):     # 10**6
    invs = [get_inv(fs[-1], modp)]
    for i in range(n, 1-1, -1):
        invs.append(invs[-1] * i % modp)
    invs.reverse()
    return invs

def comb(n, k, modp):
    num = 1
    for i in range(n, n-k, -1):
        num = num * i % modp
    den = 1
    for i in range(2, k+1):
        den = den * i % modp
    return num * get_inv(den, modp) % modp

def comb_from_list(n, k, modp, fs, invs):   
    return fs[n] * invs[n-k] * invs[k] % modp

#

class UnionFindEx:
    def __init__(self, size):
        #正なら根の番号、負ならグループサイズ
        self.roots = [-1] * size
    def getRootID(self, i):
        r = self.roots[i]
        if r < 0:   #負なら根
            return i
        else:
            r = self.getRootID(r)
            self.roots[i] = r
            return r
    def getGroupSize(self, i):
        return -self.roots[self.getRootID(i)]
    def connect(self, i, j):
        r1, r2 = self.getRootID(i), self.getRootID(j)
        if r1 == r2:
            return False
        if self.getGroupSize(r1) < self.getGroupSize(r2):
            r1, r2 = r2, r1
        self.roots[r1] += self.roots[r2]    #サイズ更新
        self.roots[r2] = r1
        return True

Yes = 'Yes'
No = 'No'


def main():
    S,W=mis()
    print('unsafe' if W>=S else 'safe')



main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
printV = lambda x: print(*x, sep="\n")
printH = lambda x: print(" ".join(map(str,x)))
def IS(): return sys.stdin.readline()[:-1]
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 LI1(): return list(map(int1, sys.stdin.readline().split()))
def LII(rows_number): return [II() for _ in range(rows_number)]
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]
mo = 10**9+7

def main():
	s,w = MI()
	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:
S,W=map(int,input().split())
if W>=S:
  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:
import sys
import math
import queue
import copy
import bisect#2分探索
from collections import deque #popleft(), appendleft(x)
##listでqueの代用をするとO(N)の計算量がかかってしまうので注意

def input(): return sys.stdin.readline()[:-1]
def printl(li): print(*li, sep="\n")
def argsort(s): return sorted(range(len(s)), key=lambda k: s[k])

#mod = 10**9+7

#N = int(input())
S,W = map(int, input().split())
#L = [int(input()) for i in range(N)]
#A = list(map(int, input().split()))
#S = [inputl() for i in range(H)]
#q = queue.Queue() #q.put(i) #q.get() 
#q = queue.LifoQueue() #q.put(i) #q.get() 

#a= [[0]*3 for i in range(5)] #2次元配列はこう準備、[[0]*3]*5だとだめ
#b=copy.deepcopy(a)  #2次元配列はこうコピーする
#w.sort(key=lambda x:x[1],reverse=True)  #二個目の要素で降順並び替え

#素数リスト
# n = 100
# primes = set(range(2, n+1))
# for i in range(2, int(n**0.5+1)):
#     primes.difference_update(range(i*2, n+1, i))
# primes=list(primes)

#bisect.bisect_left(a, 4)#aはソート済みである必要あり。aの中から4未満の位置を返す。rightだと以下
#bisect.insort_left(a, 4)#挿入

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

Submission status: Accepted

Solution code:
import sys

input = sys.stdin.readline


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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

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

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
readline = sys.stdin.readline

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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
import math
import collections
from collections import deque
from functools import reduce
import heapq
#n = int(input())
s, w = map(int, sys.stdin.readline().split())
#s = input()
#a = list(map(int, sys.stdin.readline().split()))

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

Submission status: Accepted

Solution code:
# ANSHUL GAUTAM
# IIIT-D

from math import *
from copy import *					# ll = deepcopy(l)
from heapq import *					# heappush(hp,x)
from string import *				# alpha = ascii_lowercase
from random import *				# l.sort(key=lambda l1:l1[0]-l1[1]) => ex: sort on the basis difference
from bisect import *				# bisect_left(arr,x,start,end)  => start and end parameters are temporary
from sys import stdin				# bisect_left return leftmost position where x should be inserted to keep sorted
from sys import maxsize				# minn = -maxsize
from operator import *				# d = sorted(d.items(), key=itemgetter(1))
from itertools import *				# pre = [0] + list(accumulate(l))
from collections import Counter		# d = dict(Counter(l))
from collections import defaultdict # d = defaultdict(list)

'''

'''

def solve(l):
	s,w = l
	f = 1
	if(w < s):
		f = 0
	if(f):
		return 'unsafe'
	else:
		return 'safe'

l = list(map(int, stdin.readline().rstrip().split()))
ans = solve(l)
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math

#n = int(input())
n, k = map(int, input().split())
#a, b, c = map(int, input().split())
#arr - list(map(int, input().split()))
#s = input()

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

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

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

Submission status: Accepted

Solution code:
from __future__ import print_function

import sys
sys.setrecursionlimit(500000)

import re
import array
import copy
import functools
import operator

import math
import string
import fractions
from fractions import Fraction

import collections
import itertools
import bisect

import random
import time

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

from itertools import accumulate

from collections import deque
from collections import Counter

from operator import mul
from functools import reduce

input = sys.stdin.readline


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

# from fractions import gcd
# from math import gcd

# def lcm(n, m):
#     return int(n * m / gcd(n, m))


# def coprimize(p, q):
#     common = gcd(p, q)
#     return (p // common, q // common)


# def find_gcd(list_l):
#     x = reduce(gcd, list_l)
#     return x


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


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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

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

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:
def main():
    # S = input()
    # N = int(input())
    S, W = list(map(int, input().split(' ')))
    # print(S, W)
    
    if W >= S:
        print('unsafe')
    else:
        print('safe')
    

main()

Submission status: Accepted

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

MOD = 1000000007

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


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


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



if __name__ == '__main__':
    main()

Submission status: Accepted

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

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

Submission status: Accepted

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

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

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# This was written by chizuchizu
import numpy as np
import sys
# import collections

# import bisect
# import math
import numpy as np

"""Template"""


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

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

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

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

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

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

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

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

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

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


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


def main():
    # 1文字に省略
    r, e = range, enumerate
    ip = IP()

    """この下から書いてね"""
    # n, m = ip.IL()
    # a = np.array(ip.IL())
    # for _ in range(m):
    #     a[np.argmax(a)] //= 2
    # print(np.sum(a))
    s, w = ip.IL()
    if s <= w:
        print("unsafe")
    else:
        print("safe")



main()

Submission status: Accepted

Solution code:
def main():

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

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

if __name__ == '__main__':
	main()

Submission status: Accepted

Solution code:
s,w = map(int, input().split())
print('unsafe' if s <= w 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:
l = [int(x) for x in input().split(' ')]
if l[0]>l[1]:
  print("safe")
else:
  print('unsafe')

Submission status: Accepted

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

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


main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
import heapq
from collections import deque

# sys.setrecursionlimit(100001)
INF = sys.maxsize


# ===CODE===
def main():
    s, w = map(int, input().split())
    if s>w:
        print("safe")
    else:
        print("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:
#スペース区切りの整数の入力
A, B = map(int, input().split())

if(A>B):
  print("safe")
else:
  print("unsafe")

Submission status: Accepted

Solution code:
#設定
import sys
input = sys.stdin.buffer.readline

#ライブラリインポート
from collections import defaultdict

con = 10 ** 9 + 7
#入力受け取り
def getlist():
	return list(map(int, input().split()))

#処理内容
def main():
	S, W = getlist()
	if S > W:
		print("safe")
	else:
		print("unsafe")
	


if __name__ == '__main__':
	main()

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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


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


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


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


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


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


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


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


if __name__ == '__main__':
    main()

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

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

if __name__ == "__main__":
    main()

Submission status: Accepted

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

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

x,y=ml()
if(y>=x):
    print("unsafe")
else:
    print("safe")

Submission status: Accepted

Solution code:
x,y=map(int,input().split())

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

stdin = sys.stdin

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

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

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

Submission status: Accepted

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

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

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#JMD
#Nagendra Jha-4096

 
import sys
import math

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

###Defines...###
mod=1000000007
 
###FUF's...###
def nospace(l):
    ans=''.join(str(i) for i in l)
    return ans
 
 
 
##### Main ####
t=1
for tt in range(t):
    #n=int(input())
    s,w= map(int, sys.stdin.readline().split(' '))
    if s>w:
        print("safe")
    else:
        print("unsafe")
    #a=list(map(int,sys.stdin.readline().split(' ')))
    
    
#####File Operations#####
if(fileoperation):
    sys.stdout = orig_stdout
    sys.stdin = orig_stdin
    inputfile.close()
    outputfile.close()

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
def ism():return map(str,input().split())

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
from collections import *

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

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