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


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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# coding: utf-8
import re
import math
from collections import defaultdict
import itertools
from copy import deepcopy
import random
from heapq import heappop,heappush
import time
import os
import queue
import sys
import datetime
from functools import lru_cache
readline=sys.stdin.readline
sys.setrecursionlimit(2000)
#import numpy as np
alphabet="abcdefghijklmnopqrstuvwxyz"
mod=int(10**9+7)
inf=int(10**20)
def yn(b):
    if b:
        print("yes")
    else:
        print("no")
def Yn(b):
    if b:
        print("Yes")
    else:
        print("No")
def YN(b):
    if b:
        print("YES")
    else:
        print("NO")
class union_find():
    def __init__(self,n):
        self.n=n
        self.P=[a for a in range(N)]
        self.rank=[0]*n
 
    def find(self,x):
        if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
        return self.P[x]
 
    def same(self,x,y):
        return self.find(x)==self.find(y)
 
    def link(self,x,y):
        if self.rank[x]<self.rank[y]:
            self.P[x]=y
        elif self.rank[y]<self.rank[x]:
            self.P[y]=x
        else:
            self.P[x]=y
            self.rank[y]+=1
 
    def unite(self,x,y):
        self.link(self.find(x),self.find(y))
 
    def size(self):
        S=set()
        for a in range(self.n):
            S.add(self.find(a))
        return len(S)
def is_power(a,b):#aはbの累乗数か
    now=b
    while now<a:
        now*=b
    if now==a:return True
    else:return False
def bin_(num,size):
    A=[0]*size
    for a in range(size):
        if (num>>(size-a-1))&1==1:
            A[a]=1
        else:
            A[a]=0
    return A
def get_facs(n,mod_=0):
    A=[1]*(n+1)
    for a in range(2,len(A)):
        A[a]=A[a-1]*a
        if(mod>0):A[a]%=mod_
    return A
def comb(n,r,mod,fac):
    if(n-r<0):return 0
    return (fac[n]*pow(fac[n-r],mod-2,mod)*pow(fac[r],mod-2,mod))%mod
def next_comb(num,size):
    x=num&(-num)
    y=num+x
    z=num&(~y)
    z//=x
    z=z>>1
    num=(y|z)
    if(num>=(1<<size)):return False
    else:
        return num
def get_primes(n,type="int"):
    A=[True]*(n+1)
    A[0]=False
    A[1]=False
    for a in range(2,n+1):
        if A[a]:
            for b in range(a*2,n+1,a):
                A[b]=False
    if(type=="bool"):return A
    B=[]
    for a in range(n+1):
        if(A[a]):B.append(a)
    return B
def is_prime(num):
    if(num<=2):return False
    i=2
    while i*i<=num:
       if(num%i==0):return False
       i+=1
    return True
def ifelse(a,b,c):
    if a:return b
    else:return  c
def join(A,c=" "):
    n=len(A)
    A=list(map(str,A))
    s=""
    for a in range(n):
        s+=A[a]
        if(a<n-1):s+=c
    return s
def factorize(n,type_="dict"):
    b = 2
    list_ = []
    while b * b <= n:
        while n % b == 0:
            n //= b
            list_.append(b)
        b+=1
    if n > 1:list_.append(n)
    if type_=="dict":
        dic={}
        for a in list_:
            if a in dic:
                dic[a]+=1
            else:
                dic[a]=1
        return dic
    elif type_=="list":
        return list_
    else:
        return None
def floor_(n,x=1):
    return x*(n//x)
def ceil_(n,x=1):
    return x*((n+x-1)//x)
def hani(x,min_,max_):
    ret=x
    if x<min_:ret=min_
    if x>max_:ret=max_
    return ret
def seifu(x):
    return x//abs(x)

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

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


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

S, W = MAP()

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

Submission status: Accepted

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


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


if __name__ == '__main__':
    main()

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, math
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mod = 10**9 + 7

S, W = rl()

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

Submission status: Accepted

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

Submission status: Accepted

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

    if b > c:
        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:
# -*- coding: utf-8 -*-

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

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

Submission status: Accepted

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

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

if __name__ == '__main__':
    main()

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import numpy as np
import sys
import math

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

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

Submission status: Accepted

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


if __name__ == "__main__":
    resolve()

Submission status: Accepted

Solution code:


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

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


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

Submission status: Accepted

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

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:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
s, w = map(int, input().split())

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

Submission status: Accepted

Solution code:
import sys
import itertools
if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
    
s,w=map(int,input().split())

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

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, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
# from fractions import gcd
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from functools import reduce
from bisect import bisect_left, insort_left
from heapq import heapify, heappush, heappop

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

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


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

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import sys
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
#!/usr/bin/python3
# -*- coding: utf-8 -*-

# import numpy as np
# from itertools import *
# from collections import *

# S = input().split()
# N = int(input().split())
# K, N = [int(x) for x in input().split()]

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

if S <= W:
    print("unsafe")
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:
#!/usr/bin/env python3

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

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

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

Submission status: Accepted

Solution code:
# python 3.8.2用
import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from decimal import *
from collections import deque
from math import gcd
sys.setrecursionlimit(10**7)
MOD = 10**9+7
INF = float('inf') #無限大
def lcm(a,b):return (a*b) // gcd(a,b) #最小公倍数
def iin(): return int(sys.stdin.readline()) #整数読み込み
def ifn(): return float(sys.stdin.readline()) #浮動小数点読み込み
def isn(): return sys.stdin.readline().split() #文字列読み込み
def imn(): return map(int, sys.stdin.readline().split()) #整数map取得
def imnn(): return map(lambda x:int(x)-1, sys.stdin.readline().split()) #整数-1map取得
def fmn(): return map(float, sys.stdin.readline().split()) #浮動小数点map取得
def iln(): return list(map(int, sys.stdin.readline().split())) #整数リスト取得
def iln_s(): return sorted(iln()) # 昇順の整数リスト取得
def iln_r(): return sorted(iln(), reverse=True) # 降順の整数リスト取得
def fln(): return list(map(float, sys.stdin.readline().split())) # 浮動小数点リスト取得
def join(l, s=''): return s.join(l) #リストを文字列に変換
def perm(l, n): return itertools.permutations(l, n) # 順列取得
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) # 順列の総数
def comb(l, n): return itertools.combinations(l, n) # 組み合わせ取得
def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 # 2点間の距離
def m_add(a,b): return (a+b) % MOD
def lprint(l): print(*l, sep='\n')

S,W = imn()

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

Submission status: Accepted

Solution code:
a=input().split()
if int(a[0])<=int(a[1]) :
  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
import math
from collections import deque
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
def I(): 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 S(): return sys.stdin.readline()
def LS(): return sys.stdin.readline().split()
def LS2(N): return [sys.stdin.readline().split() for i in range(N)]
def FILL(i,h,w): return [[i for j in range(w)] for k in range(h)]
def sisha(num,digit): return Decimal(str(num)).quantize(Decimal(digit),rounding=ROUND_HALF_UP)
#'0.01'や'1E1'などで指定、整数に戻すならintをかます
MOD = 1000000007
INF = float("inf")
sys.setrecursionlimit(10**6+10)

input = sys.stdin.readline
S,W = MI()
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:
a,b = list(map(int, input().split()))
if a <= b:
    print("unsafe")
else:
    print("safe")

Submission status: Accepted

Solution code:
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
def resolve():
    S, W = lr()
    if S <= W:
        print('unsafe')
    else:
        print('safe')
resolve()

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

Submission status: Accepted

Solution code:
## coding: UTF-8
from decimal import *
from itertools import permutations, combinations,combinations_with_replacement,product
import math

s = input().split()
p = [int(w) for w in s] #これで勝手にNまで拾ってくれます
S = p[0]
W = p[1]
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 = [int(elem) for elem in input().split()]

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

Submission status: Accepted

Solution code:
import sys
import os
import math
import string

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: x * y / math.gcd(x, y)

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


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

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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# A - Sheep and Wolves

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
data = input().split()
s = int(data[0])
w = int(data[1])

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

Submission status: Accepted

Solution code:
#import sys
MOD = 10 ** 9 + 7
INFI = 10**10
#input = sys.stdin.readline
import math

import itertools
import heapq
#import bisect

import copy
from functools import lru_cache

def sosuhante(n):
    for k in range(2, int(math.sqrt(n))+1):
        if n% k ==0:
            return False
    return True
def cmb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result

def kingaku(a,b,n):
    keta=len(str(n))
    return a*n+b*keta

def my_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default

#    h,w,a,b = map(int, input().split())
#    c = [[0 for j in range(n)] for i in range(n)]

def ret(a):
    c=[None]*(len(a)-1)
    if len(a)==1:
        return a[0]
    elif len(a)==0:
        return 0
    for i in range(1,len(a)):
        c[i-1]=abs(a[i]-a[i-1])
    return ret(c)


def main():

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



if __name__ == "__main__":

    main()

Submission status: Accepted

Solution code:
import sys
import math
from collections import deque
import heapq
MAX_INT = int(10e10)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

s, w = IL()

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

Submission status: Accepted

Solution code:
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush,heapify
import math
from copy import deepcopy
import queue
#import sympy as syp(素因数分解とか)
Mod = 1000000007
  
def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))+1):
        if prime[i] == 1:
            for j in range(2*i,n+1):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n+1):
        if prime[i] == 1:
            res.append(i)
    return res

 
class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[py] = px
        else:
            self.parent[px] = py
 
    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)

def main():  #startline-------------------------------------------
    s, w = map(int, input().split())
    print("unsafe" if s <= w else "safe")
if __name__ == "__main__":
    main() #endline===============================================

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(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:
from sys import stdin
input = stdin.readline

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

A()

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

Submission status: Accepted

Solution code:
from sys import stdin
S,W = [int(x) for x in stdin.readline().rstrip().split()]
if W >= S:
    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:
def main():
    s, w = map(int, input().split())
    if s <= w:
        print("unsafe")
    else:
        print("safe")


main()

Submission status: Accepted

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


if __name__ == '__main__':
    print(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:
import sys


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


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

Submission status: Accepted

Solution code:
import sys

s, w = map(int, sys.stdin.readline().split())

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

if __name__ == '__main__':
    main()

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#N = int(input())
l = [int(x) for x in input().split()]
if l[1] >= l[0]:
    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:
# -*- coding: utf-8 -*-
# A

import sys
# 再起回数上限変更
# sys.setrecursionlimit(1000000)

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

print("unsafe" if n<=k else "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:
a, b = map(int,input().split())
if a <= b:
    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:
import sys
sys.setrecursionlimit(1000000)

def solve(S, W):
    if S <= W:
        return "unsafe"
    return "safe"

if __name__ == "__main__":
    S, W = tuple(map(int, input().split(" ")))

    print(solve(S, W))

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
from math import log2,floor,ceil,sqrt
# import bisect
# from collections import deque
sys.setrecursionlimit(7*10**4)

Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
 
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 18
MOD =  998244353

# for _ in range(int(ri())):
s,w = Ri()
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:
import sys
import heapq, math
from itertools import zip_longest, permutations, combinations, combinations_with_replacement
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache
from copy import deepcopy

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

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

Submission status: Accepted

Solution code:
import math
import fractions
import collections
import itertools
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:
n, m = list(map(int, input().split()))

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

Submission status: Accepted

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

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

Submission status: Accepted

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

    if W >= S:
        print('unsafe')
        return

    print('safe')


resolve()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
S, W = [int(str) for str in input().strip().split()]

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# -*- 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())
ans = "safe" if w < s else "unsafe"
print(ans)