TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: 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`.

Submission attempts (in order):
n = input()

m = len(n)

l = list()

c = 0

for i in range(m):
    for j in range(m-i):
        l.append(i)
        l.append(i+j+2)

for k in range(len(l)//2):
    s = n[l[2*k]:l[2*k+1]]
    s = int(s)
    
    if s % 2019 == 0:
        c += 1

print(c)


input().split()
s = int(a[0])
w = int(a[1])
 
if w >= s:
    print('unsafe')
else:
    print('safe')

 input().split()
s = int(a[0])
w = int(a[1])
 
if w >= s:
    print('unsafe')
else:
    print('safe')


 
a = input().split()
s = int(a[0])
w = int(a[1])

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


a = input()
s = int(a[0])
w = int(a[1])

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


a = input().split()
s = int(a[0])
w = int(a[1])
 
if w >= s:
    print('unsafe')
else:
    print('safe')

Verdicts: Runtime Error

Runtime Error

Runtime Error

Wrong Answer

Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
S = int(input())
total = 0
S1 = str(S)
for i in range(0,S,2019):
  j = str(i)
  if j in S1:
    total+=1
print(total)

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

Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
input_line = int(input())
S = input_line[0]
W = input_line[1]
if S > W:
  print("safe")
else:
  print("unsafe")

input_line = input()
S = int(input_line[0])
W = int(input_line[1])
if S > W:
  print("safe")
else:
  print("unsafe")


input_line = input().split(" ")
S = int(input_line[0])
W = int(input_line[1])
if S > W:
  print("safe")
else:
  print("unsafe")

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
nm = list(map(int, input().split()))
if (nm[0] =< nm[1]):
    print("unsafe")
else print("safe")

sw = list(map(int, input().split()))
if sw[0] <= sw[1]:
    print("unsafe")
else:
    print("safe")

Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
s, w = map(int, input().split())
print("unsafe" s <= w else "safe")

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

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

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
# -*- coding: utf-8 -*-
a,b = input().split()
if int(a) <= int(b):
  print("unsafe")
else:
  print("safe)

# -*- coding: utf-8 -*-
a,b = input().split()
if int(a) <= int(b):
  print("unsafe")
else:
  print("safe")

Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
s = input()
count = 0
for i in range(len(s)+1):
    for j in range(i+1, len(s)+1):
        if (int(s[i:j])%3 == 0 and int(s[i:j])%673 == 0):
            count += 1
            #print("ok", s[i:j])
print(count)

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

Verdicts: Runtime Error

Accepted
Problem: 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`.

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

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

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

if s>w:
  return "safe"
else:
  return "unsafe"

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

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

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

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
1 2
a, b= map(int , input().split())
print (a)
print (b)
unsafe
s = input()
print(s)


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

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

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: 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`.

Submission attempts (in order):
S = int(input())
W = int(input())
if W < S:
  print("safe")
else:
  print("unsafe")

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

Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
a,b=map(int,input().split())
if a<=b:
  print(unsafe)
else:
  print(safe)

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

Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
from sys import stdin

s = int(stdin.readline().rstrip())

sl = len(str(s))
cnt = 0

for i in range(sl - 3):
    for j in range(i + 3, sl):
        num = s % (10 ** (sl - i)) // (10 ** (sl - j - 1))
        if num % 2019 == 0 and num > 0:
            cnt += 1

print(cnt)

from sys import stdin

s,w = [int(x) for x in stdin.readline().rstrip().split()]
print("safe" if s > w else "unsafe")

Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
s,w = map(int, input().split())
if s>f:
    print('safe')
else:
    print('unsafe')

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

Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
#A
s, w = map(int, input().split())
if w >= s:
    print('unsefe')
else:
    print('sefe')

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

Verdicts: Wrong Answer

Accepted
Problem: 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`.

Submission attempts (in order):
s, w = map(int, input().strip())
if s > w:
  print("safe")
else:
  print("unsafe)
        

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

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


s, w = map(int, input().strip())
print(s)
print(w)

#  print("safe")
#else:
#  print("unsafe")


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







a,b,c,d = map(int, input().split())

while c > 0:
  c = c-b　
  if c <= 0:
    print("Yes")
  a = a-d
  if a <= 0:
    print("No")
  

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

#  print("safe")
#else:
#  print("unsafe")


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

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


Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Wrong Answer

Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
s, w = map(int, input())
if s<=w:
  print('unsafe')
else:
  print('safe')
  

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

Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
s, w = list(map(int, input().split(" ")))
if s >= w:
  print("unsafe")
else:
  print("safe)

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

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

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

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


Verdicts: Runtime Error

Wrong Answer

Runtime Error

Runtime Error

Accepted
Problem: 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`.

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

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

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


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
s,w=map(int,input().split())
if s>w:
  print('safe')
 else:
  print('unsafe')

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

Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
S, W = map(int, input().split())

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

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

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


Verdicts: Wrong Answer

Accepted
Problem: 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`.

Submission attempts (in order):
import sys
input = sys.stdin.readline
def print_ans(S, W):
    """Test Case
    >>> print_ans(4, 5)
    unsafe
    >>> print_ans(100, 2)
    safe
    """
    if S > W :
         return 'safe'
    else:
        return 'unsafe'
if __name__ == '__main__':
    S, W = map(int, input().rstrip().split())
    print_ans(S, W)



import sys
input = sys.stdin.readline
def print_ans(S, W):
    
    if S > W :
         return 'safe'
    else:
        return 'unsafe'
if __name__ == '__main__':
    S, W = map(int, input().rstrip().split())
    print_ans(S, W)



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



Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: 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`.

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

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


Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
S, W = map(int, input().split())

if W >= S:
    print(undafe)
else:
    print(safe)


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

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


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

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


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
s = int(input())
w = int(input())
if w >= s:
    print("unsafe")
else:
    print("safe")

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

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

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

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
s,w = list(map(int,input().split()))
if w >= S:
    print('unsafe')
else:
    print('safe')

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

Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
A = int(input())
B = int(input())
C = int(input())
D = int(input())
while (A>0 and C>0):
    C = C - B
    if C <= 0:
        break
    A = A - D
print("Yes" if C<=0 else "NO")

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


Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
s = input()
si = int(s)
ans = 0
 
 
for i in range(1,300000//2019):
    d = 0
    while 1:
        if s.find(str(2019*i), d) != -1:
            ans = ans+1
            d = s.find(str(2019*i), d)+1
        else:
            break
 
print(ans)

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

Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
a,b,c,d = map(int, input().split())
i = 1
while a > 0 & c > 0:
    a = a
    c = c - i*b

    if c > 0:
        a = a-i*d
        c = c

        i += 1
if a <= 0:
    print('No')
if c  :
    print('Yes')

a,b,c,d = map(int, input().split())


n = c // b
m = c % b

if m != 0:

    if a - n * d <= 0 | a - (n-1) * d <= 0:
        print('No')

    else:
        print('Yes')


if m == 0:
    if a - (n-2) * d <= 0 | a - (n-1) * d <= 0:
        print('No')

    else:
        print('Yes')

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

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

else :
    print('safe')

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
s, w = map(int, input().split())
if w >= s*2:
    print('unsafe')
else:
    print('safe')

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

Verdicts: Wrong Answer

Accepted
Problem: 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`.

Submission attempts (in order):

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

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


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

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

Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
s,w = map(int,input.split())
if s > w:
  print("saffe")
else:
  print("unsafe")

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

Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
S,W = map(int, input().split())
if S<=W:
  print('safe')
else:
  print('unsafe')

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


Verdicts: Wrong Answer

Accepted
Problem: 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`.

Submission attempts (in order):
s=input()
lens=len(s)
count=0
for i in range(lens):
    for k in range(i,lens):
        num=s[i:k]
        if(len(num)>=4):
            if(int(num)%2019==0):
                count=count+1
print(count)

ABCD=input()
ABCD=ABCD.split()
A=int(ABCD[0])
B=int(ABCD[1])
C=int(ABCD[2])
D=int(ABCD[3])
while(1):
    C=C-B
    if(C<=0):
        print('Yes')
        break
    A=A-D
    if(A<=0):
        print('No')
        break

SW=input()
SW=SW.split()
if(int(SW[1])>=int(SW[0])):
    print('unsafe')
else:
    print('safe')

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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`.

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

input(int())

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

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: 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`.

Submission attempts (in order):
S, W = [int(s) for s in input.split()]
if W >= S:
  print("unsafe")
else:
  print("safe")

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

Verdicts: Runtime Error

Accepted
Problem: 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`.

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

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

Verdicts: Wrong Answer

Accepted
Problem: 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`.

Submission attempts (in order):
s,w = map(int,input().split())
if s <= w:
    print(unsafe)
else:
    print(safe)


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


Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
a,b,c,d=map(int,input().split())
for i in range(100):
    c-=b
    if c<=0:
        print("Yes")
        break
    else:
        a-=d
        if a<=0:
            print("No")
            break

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

Verdicts: Runtime Error

Accepted
Problem: 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`.

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


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


Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
strS = input()
S = int(strS)
lenS = len(strS)
 
ans = 0
for i in range(lenS - 3):
    for j in range(i+3, lenS):
#        print(i,j)
        if int(strS[i:j+1])%2019 == 0:
#            print(int(str(S)[i:j]), i, j)
            ans += 1
print(ans)

S = int(input())
lenS = len(str(S))

ans = 0
for i in range(lenS):
    if i+3 <= lenS:
        for j in range(i+3, lenS):
#            print(i,j)
            if int(str(S)[i:j+1])%2019 == 0:
#                print(int(str(S)[i:j]), i, j)
                ans += 1
print(ans)

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

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
a, b = map(int, input().split())

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

a, b = map(int, input().split())

if a > b:
    print('safe')
else:
    print('unsafe')

Verdicts: Wrong Answer

Accepted
Problem: 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`.

Submission attempts (in order):
a,b,c,d = map(int,input().split())
for i in range(10**2):
  c -= b
  if c <= 0:
    print("Yes")
    break
  a -= d
  if a <= 0:
    print("No")
    break


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

Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
S,W = list(map(int,input()split()))
print("safe" if S>W else "unsafe")

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


Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
  1 SW = list(map(int,input().split()))
SW = list(map(int,input().split()))
if (SW[0] > SW[1]):
  print("safe")
else:
  print("unsafe")

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

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

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):

s, w = (int(x) for x in input("please enter number of sheep and wolves: ").split())

if 1 <= s <= 100 and 1 <= w <= 100:
    if s > w:
        print("safe")
    else:
        print("unsafe")
else:
    print("invaild values...")

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

Verdicts: Wrong Answer

Accepted
Problem: 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`.

Submission attempts (in order):
a,b,c,d=map(int,input().split())
x=(a+d-1)/d
y=(c+b-1)/c
 
if x>=y:
  print("yes")
else:
  print("no")

a,b,c,d=map(int,input().split())
x=float(a/d)
y=float(c/b)

if x>=y:
  print("yes")
else:
  print("no")

a,b,c,d=map(int,input().split())
x=float(a-1/d)
y=float(c-1/b)

if x>=y:
  print("yes")
else:
  print("no")

import math

a,b,c,d=map(int,input().split())
x=int((a+d-1)/d)
y=int((c+b-1)/c)
 
if x>=y:
  print("Yes")
else:
  print("No")


a,b,c,d=map(int,input().split())
x=int((a+d-1)/d)
y=int((c+b-1)/c)
 
if x>=y:
  print("Yes")
else:
  print("No")


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

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
A,B,C,D = map(int,input().split())
while A > 0 and C > 0:
    C -= B
    if C <= 0:
        print("Yes")
    else:
        A -= D
        if A <= 0:
            print("No")

N = int(input())
S = [int(input()) for _ in N]
print(len(set(s)))

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

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
s,w = map(int, input().split())

if s < w:
  print('safe')
else:
  print('unsase')

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

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

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

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

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

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


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

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

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

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

Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: 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`.

Submission attempts (in order):
    import sys
     
    s,w =(int(n) for n in input().split())
     
    if (s <= w):
        print("unsafe")
        sys.exit()
    else:
        print("safe")


import sys
     
s,w =(int(n) for n in input().split())
     
if (s <= w):
        print("unsafe")
        sys.exit()
else:
        print("safe")

Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
100 2

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

Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
S,W=map(int,input().split())

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

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

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

Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
S = int(input())
W = int(input())
if W >= S:
  print('unsafe')
else:
  print('safe')

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

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

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
w, s = map(int, input().split())
if (w >= s):
    print('unsafe')
else:
    print('safe')

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

Verdicts: Wrong Answer

Accepted
Problem: 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`.

Submission attempts (in order):
s, w = int(input().split)

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


s, w = input().split()

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


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

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


s, w = input().split()

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

Verdicts: Runtime Error

Wrong Answer

Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
s,w = map(int,input())
if s < w:
  print('unsafe')
else:
  print('safe')

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

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

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
import re
multiplies = []

for i in range (1, 800):
    multiplies.append(i * 2019)

S = input()

count = 0

for i in multiplies:
    count += len(re.findall('(?=' + str(i) + ')',S))

print(count)


line = [int(s) for s in input().split()]

if line[0] > line[1]:
    print('safe')
else:
    print('unsafe')


Verdicts: Wrong Answer

Accepted
Problem: 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`.

Submission attempts (in order):
n,m =map(int.input().split())

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

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

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


Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
S, W = map(int, input.split())

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

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

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

Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
s = int(input())
w = int(input())

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

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

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


Verdicts: Runtime Error

Accepted
Problem: 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`.

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

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


Verdicts: Wrong Answer

Accepted
Problem: 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`.

Submission attempts (in order):
S = input()
number = [ str(x*2019) for x in range(1000)]
count=0
v = []
for i in range(4, len(S)):
    for k in range(i):
        v =[]
        for l in range(0, len(S)//i):
            if len(S[l*i+k: l*i+k+i])==i:
                v.append(S[l*i+k: l*i+k+i])
        for m in v:
            if m in number:
                count+=1

print(count)

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

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

Verdicts: Wrong Answer

Accepted
Problem: 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`.

Submission attempts (in order):
s,w  =int(input())
if s <= w:
    print("unsafe")
else:
    print("safe")

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

Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
n = str(input())

if n[0]=='7' or n[1]=='7' or n[2]=='7':
  print("Yes")
else:
  print("No")

n = str(input())

if n[0]=='7' or n[1]=='7' or n[2]=='7':
  print("Yes")
else:
  print("No")

n = str(input())

if n[0]=="7" or n[1]=="7" or n[2]=="7":
  print("Yes")
else:
  print("No")
  

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

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

Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: 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`.

Submission attempts (in order):
s = list(map(int, input().split()))
print(s[1],s[0])

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

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

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

Verdicts: Wrong Answer

Accepted
Problem: 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`.

Submission attempts (in order):
from math import factorial as fact
import math
import fractions
import sys
import itertools
import numpy as np
from collections import Counter
import datetime

def input1():
	return int(input())


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


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

def keta(N):
	return len(str(N))


def input_daytime(input_time):
	time,distance=input_time.split()
	t=time.split(":")
	se=str(t[-1]).split(".")
	dt1 = datetime.timedelta(hours=int(t[0]),minutes=int(t[1]),seconds=int(se[0]),milliseconds=int(se[1]))
	return dt1

def combinations(n,r):
	return list(itertools.combinations(n,r))

def all_sets(num_list):
	subsets=[]
	for i in range(2,len(num_list) + 1):
		for c in combinations(num_list, i):
			subsets.append(c) 
	return subsets


def ch(x1):
	cf=[]
	for i in range(2,math.sqrt(x1)+1):
		if x1 % i==0:
			cf.append(i)
	return cf

def CountOneRoots(x,y):
	
	return fact(x+y)/fact(x)/fact(y)


def factorization(n):
	tmp=n
	count=0
	for i in range(2,int(n**0.5)+2):
		if tmp%i==0:
			cnt=0
			while tmp%i==0:
				cnt+=1
				tmp//=i
			count+=1
	if tmp!=1:
		count+=1

	return count
			


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

# a,b,c,d=input2()


# 	if i%2==1:
# 		c-=b
# 		if c<=0:
# 			print("Yes")
# 			break
# 	else:
# 		a-=d
# 		if a<=0:
# 			print("No")
# 			break

	







from math import factorial as fact
import math
import fractions
import sys
import itertools
import numpy as np
from collections import Counter
import datetime

def input1():
	return int(input())


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


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

def keta(N):
	return len(str(N))


def input_daytime(input_time):
	time,distance=input_time.split()
	t=time.split(":")
	se=str(t[-1]).split(".")
	dt1 = datetime.timedelta(hours=int(t[0]),minutes=int(t[1]),seconds=int(se[0]),milliseconds=int(se[1]))
	return dt1

def combinations(n,r):
	return list(itertools.combinations(n,r))

def all_sets(num_list):
	subsets=[]
	for i in range(2,len(num_list) + 1):
		for c in combinations(num_list, i):
			subsets.append(c) 
	return subsets


def ch(x1):
	cf=[]
	for i in range(2,math.sqrt(x1)+1):
		if x1 % i==0:
			cf.append(i)
	return cf

def CountOneRoots(x,y):
	
	return fact(x+y)/fact(x)/fact(y)


def factorization(n):
	tmp=n
	count=0
	for i in range(2,int(n**0.5)+2):
		if tmp%i==0:
			cnt=0
			while tmp%i==0:
				cnt+=1
				tmp//=i
			count+=1
	if tmp!=1:
		count+=1

	return count
			


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

# a,b,c,d=input2()


# 	if i%2==1:
# 		c-=b
# 		if c<=0:
# 			print("Yes")
# 			break
# 	else:
# 		a-=d
# 		if a<=0:
# 			print("No")
# 			break

	







Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
n, m = map(int,input().split())

if n > m:
  print("safe")
else:
  print("ansafe")

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

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

Verdicts: Wrong Answer

Accepted
Problem: 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`.

Submission attempts (in order):
def main(s, w):
    if w >= 2 * s:
        return 'unsafe'
    else:
        return 'safe'


if __name__ == '__main__':
    S, W = map(int, input().split(' '))
    print(main(S, W))


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


if __name__ == '__main__':
    S, W = map(int, input().split(' '))
    print(main(S, W))


Verdicts: Wrong Answer

Accepted
Problem: 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`.

Submission attempts (in order):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

if __name__ == '__main__':
    main()



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

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

if __name__ == '__main__':
    main()



Verdicts: Wrong Answer

Accepted
Problem: 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`.

Submission attempts (in order):
import sys
args = sys.argv

s = int(args[0])
w = int(args[1])

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

inputs = input().split(' ')

s = int(inputs[0])
w = int(inputs[1])

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

Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
s, w = int(input()).split()
if w >= s:
  print("unsafe")
else:
  print("safe")

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

Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
S = input()
n = len(S)
dp = {0:1}
q = 1
p = 0
for i in range(n):
    p += int(S[n-1-i])*q
    q *= 10
    q = q % 2019
    p = p % 2019
    if p not in dp:
        dp[p] = 1
    else:
        dp[p] += 1
print(dp)
print(sum(dp[i]*(dp[i]-1)//2 for i in dp))

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

import collections
s_str = input()
s = [int(s_str[i]) for i in range(len(s_str))] 
n = len(s_str)
s_block = []
for k in range(n):
    a = sum(s[i]*10**(n-i-1) for i in range(k,n)) % 2019
    s_block.append(a)
s_dict = list(dict(collections.Counter(s_block)).values())
ans = sum(s_dict[i]*(s_dict[i]-1)/2 for i in range(len(s_dict)))
print(int(ans))

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

Verdicts: Runtime Error

Wrong Answer

Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
a, b, c, d = map(int, input().split())
while a > 0 and c > 0:
  c -= b
  a -= d
if c <= 0:
  print('Yes')
else:
  print('No')

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

Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
s,w =int(input())
if w>=s:
  print('UNSAFE')
else:
  print("SAFE")
  

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

Verdicts: Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
w,s = list(map,int(input().split()))
if w >= s:
    print('unsafe')
else:
    print('safe')

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

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

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: 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`.

Submission attempts (in order):

#import numpy as np


N = int(input())
keihin = []
for i in range(N):
    keihin.append(input())
# 

# 
# 










import numpy as np


N = int(input())
keihin = []
for i in range(N):
    keihin.append(input())

nn = np.array(keihin)


print(np.unique(nn).size)








a=input().split()
S = int(a[0])
W = int(a[1])
if S >= W:
    print("unsafe")
else:
    print("safe")

a = input().split()
S = int(a[0])
W = int(a[1])
if S <= W:
    print("unsafe")
else:
    print("safe")

Verdicts: Runtime Error

Runtime Error

Wrong Answer

Accepted
Problem: 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`.

Submission attempts (in order):
w,s = input().split()

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

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

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

Verdicts: Wrong Answer

Accepted
Problem: 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`.

Submission attempts (in order):
S, W = map(int, input().split())

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

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

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

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

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

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: 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`.

Submission attempts (in order):
S=int()
W=int()
S=input()
W=input()

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

S=int()
W=int()
S=input()
W=input()

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

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

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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`.

Submission attempts (in order):
import sys
import math


def main():
    input = sys.stdin.readline
    a, b = (int(i) for i in input().split())
    if a <= b:
        print("unsafe")
    else:
        print("safe)


main()


import sys
import math


def main():
    input = sys.stdin.readline
    a, b = (int(i) for i in input().split())
    if a <= b:
        print("unsafe")
    else:
        print("safe")


main()


Verdicts: Runtime Error

Accepted