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

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

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

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

Submission status: Accepted

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

Submission status: Accepted

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

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


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


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


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


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


def ss(): return input()


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


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


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


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


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


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


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


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


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


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


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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
n,k = [int(s) for s in input().split()]
if k>=n:
    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()))
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:
N, M = map(int, input().split())
if N <= M:
  print('unsafe')
else:
  print('safe')

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N = [int(e) for e in input().split()]
if(N[0] > N[1]):
  print('safe')
else:
  print('unsafe')

Submission status: Accepted

Solution code:

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

print("unsafe" if n<=k else "safe")

Submission status: Accepted

Solution code:
import math

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

# n = int(input())
# 
# s = input()

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
from collections import deque
def input(): return sys.stdin.readline().strip()


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

if __name__ == "__main__":
    main()

Submission status: Accepted

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

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

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

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:
# /usr/bin/python3
# -*- coding: utf-8 -*-
from queue import Queue
from queue import LifoQueue as Stack
from math import sqrt, floor, ceil, log2, log10, pi
from fractions import gcd
from itertools import permutations, combinations
from operator import itemgetter
from functools import cmp_to_key


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


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

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

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

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

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

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

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

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

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

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



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

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

Submission status: Accepted

Solution code:
import sys
range = xrange
input = raw_input

s,w = [int(x) for x 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:
# coding:utf-8
s, w = map(int, input().split())

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

Submission status: Accepted

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


if __name__ == '__main__':
    solve()

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

Submission status: Accepted

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

Submission status: Accepted

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


if __name__ == '__main__':
    solve()

Submission status: Accepted

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

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

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

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

print(ans)

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

Submission status: Accepted

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


def solve(S: int, W: int):
    print('safe' if S > W else 'unsafe')
    return


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    S = int(next(tokens))  # type: int
    W = int(next(tokens))  # type: int
    solve(S, W)

if __name__ == '__main__':
    main()

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

Submission status: Accepted

Solution code:
def resolve():
    '''
    code here
    '''
    S, W = [int(item) for item in input().split()]

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

if __name__ == "__main__":
    resolve()

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

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
def YesNo(T):
    if T:
        print('unsafe')
    else:
        print('safe')

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

Submission status: Accepted

Solution code:
# import sys
# import math #sqrt,gcd,pi
# import decimal
# import queue # queue
# import bisect
# import heapq # priolity-queue
# import time
# from itertools import product,permutations,\
#     combinations,combinations_with_replacement
# 重複あり順列、順列、組み合わせ、重複あり組み合わせ
# import collections # deque
# from operator import itemgetter,mul
# from fractions import Fraction
# from functools import reduce

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

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

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

if __name__=='__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

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

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

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

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

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

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

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

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

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

Submission status: Accepted

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

Submission status: Accepted

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

# -*- coding: utf-8 -*-
s, w = LIST()

if s <= w:
    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:
from sys import stdin
import sys
import math

# A, B, C = [int(x) for x in stdin.readline().rstrip().split()]
S, W = [int(x) for x in stdin.readline().rstrip().split()]
# U = input().split()
# A, B = [str(x) for x in stdin.readline().rstrip().split()]
if S <= W:
    print("unsafe")
else:
    print("safe")
# print("YES")
# print("NO")

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 =list(map(int, input().split()))
s = a[0]
w = a[1]
if s > w:
    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
sys.setrecursionlimit(10 ** 6)  # 再帰関数の再帰の深さを設定
to_index = lambda x: int(x) - 1  # 入力した数字に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()))

# 2次元リスト化
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')

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 "unsafe")

Submission status: Accepted

Solution code:
#a
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:
# N = int(input())
S, W = list(map(int, input().split()))

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

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

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

if __name__ == '__main__':
  main()

Submission status: Accepted

Solution code:
s, w = map(int, input().strip().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:
import sys
import math
# input処理を高速化する
input = sys.stdin.readline

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a, b  = map(int, input().split())
if a<=b:
    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:
n, m = map(int, input().split())
if n <= m:
  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:
import math

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

#items=[int(i) for i in input().split()]

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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:
#!/usr/bin/env python3
import sys


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


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    S = int(next(tokens))  # type: int
    W = int(next(tokens))  # type: int
    solve(S, W)


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

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

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import numpy as np
from collections import deque
s, w = list(map(int, input().split()))
if (w >= s):
    print('unsafe')
else:
    print('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:
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
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
#from math import floor, ceil
#from operator import itemgetter
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)]
#inf = 10**17
#mod = 10**9 + 7

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

Submission status: Accepted

Solution code:
if __name__ == '__main__':
    from sys import stdin
    input = stdin.readline

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

Submission status: Accepted

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


# l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
# c = collections.Counter(l)

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 LI(): return list(map(int, sys.stdin.readline().split()))
# 入力全てを整数に変換して1引いたものの配列を受け取る
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')

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!
s,w=map(int,input().split())
if w>=s: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:
import sys
input=sys.stdin.buffer.readline
#from collections import defaultdict
#d = defaultdict(int)
#import fractions
#import math
#import collections
#from collections import deque
#from bisect import bisect_left
#N = int(input())
#A = list(map(int,input().split()))
#S = list(input())
#S.remove("\n")
#N,M = map(int,input().split())
#S,T = map(str,input().split())
#A = [int(input()) for _ in range(N)]
#S = [input() for _ in range(N)]
#A = [list(map(int,input().split())) for _ in range(N)]
#import itertools
S,W = map(int,input().split())
if W >= S:
    print("unsafe")
else:
    print("safe")

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n,m=map(int,input().split())
if n>m:
    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')

if __name__ == "__main__":
    main()

Submission status: Accepted

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

# N = int(input())
# S = input()

S,W = 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) = tuple(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")