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):
import collections
s = input()

l = [int(s[-1])]
d = 10
for i in range(len(s)-2, -1, -1):
  l.append((l[-1] + int(s[i])*d) % 2019)
  d *= 10
  d %= 2019
c = collections.Counter(l)
ans = 0  
for i in c.values():
  ans += i*(i-1)//2

ans += c[0]

print(ans)

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

if s =< w:
  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, 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):
def examA():
    S, W = LI()
    if S<=W:
        print("unsefe")
    else:
        print("safe")
    return

def examB():
    ans = 0
    print(ans)
    return

def examC():
    ans = 0
    print(ans)
    return

def examD():
    ans = 0
    print(ans)
    return

def examE():
    ans = 0
    print(ans)
    return

def examF():
    ans = 0
    print(ans)
    return

import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(readline())
def LI(): return list(map(int,readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]

sys.setrecursionlimit(10**7)

if __name__ == '__main__':
    examA()



def examA():
    S, W = LI()
    if S<=W:
        print("unsafe")
    else:
        print("safe")
    return

def examB():
    A, B, C, D = LI()
    while(True):
        C -= B
        if C<=0:
            print("Yes")
            break
        A -= D
        if A<=0:
            print("No")
            break
    return

def examC():
    ans = 0
    print(ans)
    return

def examD():
    ans = 0
    print(ans)
    return

def examE():
    ans = 0
    print(ans)
    return

def examF():
    ans = 0
    print(ans)
    return

import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(readline())
def LI(): return list(map(int,readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]

sys.setrecursionlimit(10**7)

if __name__ == '__main__':
    examA()



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):
# -*- coding: utf-8 -*-
 
s = input()
counter = 0

for i in range(len(s) - 4):
  for j in range(4, len(s) + 1):
      if int(float(s[i:j])) % 2019 == 0:
        counter += 1
        
print(counter)


# -*- coding: utf-8 -*-

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

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

S = input()

ans = 0


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

print(ans)

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 = input()
#S = str(1817181712114)
ans = 0
 
for a in range(len(S) - 3):
	for b in range(a+3, len(S)):
		if int(S[a:b+1]) % 2019 == 0:
			ans += 1        
print(ans)

S = input()
#S = str(1817181712114)
ans = 0

for a in range(len(S)-1):
	for b in range(a+1, len(S)):
		if int(S[a:b+1]) % 2019 == 0:
			ans += 1        
print(ans)



S = input()
#S = str(1817181712114)
ans = 0

for a in range(len(S) - 3):
	for b in range(a+1, len(S)):
		if int(S[a:b+1]) % 2019 == 0:
			ans += 1        
print(ans)

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

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

n, m = map(int, input().split())
if n <= m:
  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('unsefe')
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 S<=W:
    print("unface")
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 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().sprit())

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

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

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

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

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:
  print('unsafe')
print('safe')

S,W=map(int,input().split())
if W>=S:
  print('unsafe')
  exit()
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 = str(input())
s = int(S)
n = len(S)
count = 0
for i in range(1,n+1):
    for j in range(i+4,n+1):
        si = s%10**(n-i+1)
        sij = si//10**(n-j)
        if sij % 2019 == 0:
            count+=1
            i+=4
            j+=4

print(count)


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):
n,b=input().split()
def b(n,b):
    return "safe" if n>b else "No"
print(b(n,b))

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

def a(n,b):
    return "safe" if n>b else "No"
print(a(n,b))

n,b=input().split()
n,b=int(n),int(b)
def a(n,b):
    return "safe" if n>b else "No"
print(a(n,b))

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

def a(n,b):
    return "safe" if n>=b else "No"
print(a(n,b))

n,b=input().split()
n,b=int(n),int(b)
def b(n,b):
    return "safe" if n>b else "No"
print(b(n,b))

n,m=map(int,input().split())
def func(n,m):
    return "unsafe" if n<=m else "safe"
print(func(n,m))

Verdicts: Runtime Error

Wrong Answer

Wrong Answer

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):
import numpy as np

s = input()

# print(s)

ans = np.zeros((len(s)+1, len(s)+1), dtype = np.int)

# print(ans)

if len(s) >= 4:
  for i in range (0, len(s) - 3):
    for j in range (i + 4, len(s)+1):
      num = int(s[i:j])
      # print(num)
      if num % 2019 == 0:
        ans[i, j] += 1

# print(ans)

print(np.sum(ans))

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

ans = 'unsafe'

if s > w:
  ans = 'safe'

print(ans)

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):
def abc():
    S,W=map(int,input().split(" "))
    if(S>=1 and S<=100 and W>=1 and W<=100):
      if(S>W):
        print("safe")
      else:
        print("unsafe")

def abc():
    S,W=map(int,input().split(" "))
    if(S>=1 and S<=100 and W>=1 and W<=100):
      if(S>W):
        print("safe")
      else:
        print("unsafe")
abc()

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


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


x, y = map(int, input().split())
if y >= x:
    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")

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

ans1 = 0
while a>=0:
    a -= d
    ans1 += 1

ans2 = 0
while c >= 0:
    c -= b
    ans2 += 1

if ans1 >= ans2:
    print("Yes")
else:
    print("No")


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

ans1 = 0
while a>=0:
    a -= d
    ans1 += 1

ans2 = 0
while c >= 0:
    c -= b
    ans2 += 1

if ans1 >= ans2:
    print("No")
else:
    print("Yes")

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

Verdicts: 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 = input()
l = len(S)
count = 0
for i in range(4,l+1):
  for j in range(l-i+1):
    if float(S[j:j+i]) % 2019 == 0:
      count += 1
print(count)

S, W = list(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())
t=0
while A>0 and C>0:
  if t%2==0:
    A-=D
  else:
    C-=B
  t+=1
if A<=0:
  print("No")
else:
  print("Yes")


S=input()
N=len(S)
Slis=[]
for i in range(N):
  Slis+=[int(S[i])]
T=[0 for i in range(N+1)]


def kaizyou(n):
  c=1
  c=c*10**n
  return c%2019


for i in range(N):
  T[N-i-1]=(T[N-i]+kaizyou(i)*Slis[N-i-1])%2019

MOD=[0 for i in range(2019)]
for i in range(N+1):
  tmp=T[i]%2019
  MOD[tmp]+=1


  
ans=0

for i in range(2019):
  tmp=MOD[i]
  ans+=tmp*(tmp-1)//2
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):
s,w=map(int,input())
if s<=w:
    print('unsafe')
else:
    print('safe')

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

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 = int(input())

W = int(input())

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

S = int(input())

W = int(input())

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

S = int(input())

W = int(input())

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

S = int(input())

W = int(input())

if W >= S/2:
  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

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):
N = int(input())
S = []
for i in range(N):
    S.append(input())
print(set(S))

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('unsafe')
else
  print('safe')

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

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

class Main:

    def main(s1,s2):
        if s1 <= s2:
            print("unsafe");
        else:
            print("safe");
    main()

def main():
    s = int(input.split());
    if s[1] <= s[2]:
        print("unsafe");
    else:
        print("safe");
main()


class Main:

    t1, a1, t2, a2= map(int,input().split());

    while(t1 > 0 and t2 > 0):
        if t2 <= 0:
            break;
        t2 -= a1;
        if t1 <= 0:
            break;
        t1 -= a2;

    if t1 >= t2:
        print("Yes");
    else:
        print("No")




class Main:

    s = int(input().split());

    if s[0] <= s[1]:
        print("unsafe");
    else:
        print("safe");


import sys;


class Main:
    s = set([i.strip() for i in sys.stdin.readlines()]);

    print(len(s));





class Main:

    s1, s2= int(input().split());

    if s1 <= s2:
        print("unsafe");
    else:
        print("safe");



class Main:

    def main(s1,s2):
        if s1 <= s2:
            print("unsafe");
        else:
            print("safe");

class Main:

    s1, s2= map(int,input().split());

    if s1 <= s2:
        print("unsafe");
    else:
        print("safe");


Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Wrong Answer

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

A,B,C,D = map(int, input().split())

check = True
while True:
    if check:
        c -= b
        if c <= 0:
            print("Yes")
            break

else:
    a -= d
    if a<= 0:
        print("No")
        break

    check = not check


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):
TaHP,TaAP,AoHP,AoAP = map(int, input().split())

Flag_Ta = True

while( TaHP > 0 or AoHP > 0):
	if	Flag_Ta:
		AoHP = AoHP - TaAP
		Flag_Ta = False
	else:
		TaHP = TaHP - AoAP
		Flag_Ta = True
if TaHP > 0:
	print("Yes")
else:
    print("No")


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):
a,b,c,d=map(int,input().split())
taka=c/b
ao=a/d
taka=taka if taka==c//b else int(taka)+1
ao=ao if ao==a//d else int(ao)+1
print("Yes" if taka<=ao else "No")

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

def Sol(w,s):
    
    if s>w:
        print("safe")
    else:
        print("unsafe")
    
    return

    

#for t in range(int(input())):
n,k = map(int,input().split())
#n = int(input())
#arr = []

#    time = list(map(int,input().split()))
#    time = time[0] + (time[1]/60)
#    arr.append(time)
#arr = list(map(int,input().split()))
#k = input()
#n = int(input())
Sol(n,k)


def Sol(a,b,c,d):
    
    if a%d != 0:
        m_aoki = int(a/d) + 1
    else:
        m_aoki = int(a/d)

    if c%b != 0:
        m_taka = int(c/b) + 1
    else:
        m_taka = int(c/b)
        
    if m_taka >= m_aoki:
        print("YES")
    else:
        print("NO")

    return

    

#for t in range(int(input())):
n,k,c,d = map(int,input().split())
#n = int(input())
#arr = []

#    arr.append(input())
#arr = list(map(int,input().split()))
#k = input()
#n = int(input())
Sol(n,k,c,d)



def Sol(s,w):
    
    if s>w:
        print("safe")
    else:
        print("unsafe")
    
    return

    

#for t in range(int(input())):
n,k = map(int,input().split())
#n = int(input())
#arr = []

#    time = list(map(int,input().split()))
#    time = time[0] + (time[1]/60)
#    arr.append(time)
#arr = list(map(int,input().split()))
#k = input()
#n = int(input())
Sol(n,k)


Verdicts: 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):
n = int(input())
s = [str(input()) for i in range(n)]
print(len(set(s)))


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

S,W = list(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):
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):
def main():
    x,y = tuple([int(t)for t in input().split()])

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


if __name__ == "__main__":
    main()

def main():
    x,y = tuple([int(t)for t in input().split()])

    if x<=y:
        print("unsafe")
    else:
        print("safe")


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

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


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

a, b = map(int, input().split())
print("safe" if a > b else "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())
ans = "Yes"
curA = A
curC = C
for i in range(max(A,C)):
  curC  = curC-B
  if(curC<=0):
    ans = "Yes"
    break
  curA = curA-D
  if(curA<=0):
    ans = "No"
    break
print(ans)

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

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


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


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 (int12,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 w>=s:
    print("unafe")
else:
    print("safe")

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


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):
a, b, c, d = map(int, input().split())
if c // b >= a // d:
    print('Yes')
else:
    print('No')

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

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

S = input()

s = []
for i in S:
    s.append(int(i))
count = 0

if (len(s) < 4 ):
    print(0)
    sys.exit()

for i in range(len(s)):
    j = i
    target = s[i]
    for k in range(len(s)-i):
        j += 1
        if(j >= len(s)):
            break
        target = target*10
        target += s[j]
        if ( target%2019 == 0):
            count += 1
print(count)


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, b, c, d = map(int, input().split())
if c//b + 1 > a//d:
  print("No")
else:
  print("Yes")

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("usnafe")
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 = 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):
import sys

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


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

if __name__ == '__main__':
    solve()


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

num=list(map(int,input().split()))
if num[0]>num[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):
import sys
def main():
	A,B,C,D = map(int, input().split())
	while True:
		C - B
		if C <= 0:
			print("Yes")
		A - D
		if A <= 0:
			print("No")
			sys.exit()
main()


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

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

elif W < S:
	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(:)
w = input(:)
S = int(s)
W = int(w)
if S<=W:
  print("unsafe")
else:
  print("safe")

s = input(:)
w = input(:)
S = int(s)
W = int(w)
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):
s = input()
# print(s[2:len(s)])
l = len(s)
count = 0


# for i, j in itertools.combinations(range(len(s)+1), 2):
#     if(int(s[i:j]) % 2019 == 0):
#         count = count + 1
#
# print(count)

for i in range(2019):
    count2 = 0
    for j in range(l):
        if int(s[j:l]) % 2019 == i:
            count2 = count2 + 1
    count = count + (count2 * (count2 - 1)) / 2
print(int(count))

s = input()
count = 0

for i in range(len(s)):
    for j in range(len(s) - i):
        if int(s[i:i+j+1]) % 2019 == 0:
            count = count + 1

print(count)

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

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

W, S = input()

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

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

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

s,w =map(int,input().split())
if(s<=w):
    print('unsafe')
if(s>w):
    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):
N = int(input())
S = list()
for i in range(N):
  x = input()
  S.append(x)
  
A = set(S)
print(len(A))

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

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

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

if w >= s:
  print("unsefe")
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):

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

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

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

li = str.split()
if(eval(li[0])<=eval(li[1])):
  print("unsafe")
else:
  print("safe")

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

str = input("")
li = str.split()
if(eval(li[0])<=eval(li[1])):
  print("unsafe")
else:
  print("safe")
  

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

S,W = 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):
n = input()
p=input()
p=p[0:-1]
if n==p:
    print("Yes")
else:
    print("No")

n, k = map(int, input().split())
if n<=k:
  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()
print(sum([int(S[i:j])  % 2019 == 0 for i in range(len(S)) for j in range(i, len(S) + 1) if i < j]))

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

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):
import sys
lines = sys.stdin.readlines()

S = str(lines[0])
X = []
A = []
p =1
for i in range(len(S)):
  A.append(p)
  p = p*10%2019


import sys
lines = sys.stdin.readlines()

S = str(input())


A = []
p =1
for i in range(len(S)):
  A.append(p)
  p = p*10%2019


X = []
a = 0
for i in range(len(S)):
  a = (a + int(S[len(S)-i-1])*A[i]) %2019
  X.append(a)
X.sort()
flag =1
n = 0


for i in range(len(X)-1):
  if X[i]==0:
    n +=1
  if X[i]==X[i+1]:
    flag += 1
  else:
    n += flag*(flag-1)//2
    flag = 1
print(n)

import sys

lines = sys.stdin.readlines()

x = lines[0].split(' ')
S =int(x[0])
W =int(x[1])

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

print(ans)


Verdicts: 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 = input()
n = len(S)
count = 0
for i in range(0,n-3):
    s = S[i:i+4]
    for j in range(i+4,n):
        s = s + S[j]
        if int(s)%2019 == 0 : count += 1
print(count)

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

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):
s, w = map(str, input().split())
if w >=  s:
  print('unsafe')
elif:
  print('safe')

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

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


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

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


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


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