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

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

else :
    print("safe")

S = input()
W = input()

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

elif S > W :
    print("safe")

S = input()
W = input()

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

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

else :
    print("safe")

S,W = amp(int,input,split)

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

else :
    print("safe")


S = input()
W = input()

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

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

elif S > W :
    print("safe")

S = input()
W = input()

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

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

elif S > W :
    print("safe")
    


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

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

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


s = int(input())
w = int(input())
if s <= w:
  print('unsafe')
elif:
  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

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

a,b,c,d = map(int,input().split())
if (math.ceil(a/d)) <= (math.ceil(b/c)):
    print('No')
else:
    print('Yes')


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

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 collections
s = input()
l = len(s)

d = [0] * l
for i in range(l-1,0,-1):
  d[i] = int(s[i:]) % 2019

ans = 0
for v in collections.Counter(d).values():
  ans += v*(v-1)/2

print(int(ans))


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

if a > b:
  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().rstrip().split(' '))
if s<=w:
  print('safe')
else:
  print('unsafe')
  

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

S, W = tuple(int(c) for c in 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):
S,W = map(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 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

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

s = input('enter a number')
w = input('enter a number')
print('safe' if s > w else 'unsafe')

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

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

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

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

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

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

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

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

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

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

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

num = map(int,input().split())
a = []
for i in num:
    a.append(i)
if a[0]<a[1]:
    print('unsafe')
elif a[0]>a[1]:
    print('safe')
else:
    print('unsafe')

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

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

if m>=n:

    print('unsafe')

else:
    print('safe')


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

if m>=n:

    print('unsafe')

else:
    print('safe')


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

if m>=n:

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


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


S, W = map(int, input().split())
print(["unsafe", "safe"][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):
n=int(input())
s,l=[],[]
s=[input() for i in range(n)]
for i in s:
  if i not in l:
      l.append(i)
print(len(l))

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):
nums = input()
S = int(nums.split(' ')[0])
W = int(nums.split(' ')[1])

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

nums = input()
S = int(nums.split(' ')[0])
W = int(nums.split(' ')[1])

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

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

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

S=int(input("羊:"))
W=int(input("狼:"))
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

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

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

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())
L=[input() for i in range(N)]
M=set(L)
print(len(M))

a,b,c,d=map(int,input().split())
e=a//d
f=c//b
x=a-e*d
y=c-f*b
if x==y==0:
  if f<=e:
    print('Yes')
  else:
    print('N0')
elif x==0 and y!=0:
  if f+1<=e:
    print('YES')
  else:
    print('No')
elif y==0 and x!=0:
  if f<=e+1:
    print('Yes')
  else:
    print('NO')
else:
  if f<=e:
    print('Yes')
  else:
    print('No')
  

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


a,b,c,d=map(int,input().split())
e=a//d
f=c//b
x=a-e*d
y=c-f*b
if x==y==0:
  if f<=e:
    print('Yes')
  else:
    print('N0')
if x==0:
  if f+1<=e:
    print('YES')
  else:
    print('No')
if y==0:
  if f<=e+1:
    print('Yes')
  else:
    print('NO')
else:
  if f<=e:
    print('Yes')
  else:
    print('No')
  

a,b,c,d=map(int,input().split())
e=a//d
f=c//b
x=a-e*d
y=c-f*b
if x==y==0:
  if f<=e:
    print('Yes')
  else:
    print('N0')
elif x==0 and y!=0:
  if f+1<=e:
    print('Yes')
  else:
    print('No')
elif y==0 and x!=0:
  if f<=e+1:
    print('Yes')
  else:
    print('NO')
else:
  if f<=e:
    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=input().split()
if(int(A)>int(B)):
    print("unsafe")
else:
    print("safe")

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

A,B=input().split()
if(int(A)<=int(B)):
    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):
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define REP(i, n)    for (ll (i) = 0;   (i) < (n); ++(i))
#define FOR(i, a, b) for (ll (i) = (a); (i) < (b); ++(i))

signed main() {

    int a, b;
    cin >> a >> b;
    if (a > b) cout << "safe" << endl;
    else cout << "unsafe" << endl;

}


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):
tmp = input().split()
N = int(tmp[0])

ListG = []

for i in range(N):
    Si = input().split()
    p = Si in ListG
    if not p :
        ListG.append(Si)
    
print(len(ListG))

tmp = input().split()
S = int(tmp[0])
W = int(tmp[1])

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

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

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

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


a, b, c, d = map(int, input().split())
c / b 
a / d
if a / d > c / d:
  print('Yes')
else:
  print('No')

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





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

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

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 = list(map(int,input().split()))
 
if S[1] >= S[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):
a,b,c,d = map(int,input().split())
while a <= 0 or c <= 0:
    c =c - b
    a =a - d
    if c <= 0:
        print('Yes')
    else:
        print('No')

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

a,b,c,d = map(int,input().split())
while a >= 0 or c >= 0:
    c =c - b
    a =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

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("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):
n=input()
length=len(n)
rs=0
for i in range(1,length-2):
    num=0
    start=0
    end=length-i
    gap=length-end
    for j in range(i):
        num=int(n[start+j:end+1+j])
        if num%2019==0:
            rs+=1
print(rs)

def compare():
    a,b=map(int,input().split())

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


compare()

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

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

s = input()
len_s = len(s)
ans = 0
for i in range(len_s):
    for j in range(i + 3 , len_s + 1):
        if int(s[i:j]) % 2019 == 0:
            ans += 1
print(ans)



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

s, w =[int(i) for i in input().split()]
if w >= s:
    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):
line = input().split()
a=int(line[0])
b=int(line[1])
c=int(line[2])
d=int(line[3])
e=c//b
f=a//d
if e>=f:
  g=e
else:
  g=f
h=int(c)
j=int(a)
for i in range(ｇ):
	h=h-b
	j=j-d
	if h <= 0:
		print("Yes")
	elif j <= 0:
		print("No")

line = input().split()
s=int(line[0])
w=int(line[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 = list(input())
n = len(s)

counter = [0] * 2019

counter[0] += 1
temp=""
for i in range(1, n+1):
    c=s.pop()
    temp = c + (temp if i != 1 else "")
    #s_cu.append(temp)
    counter[int(temp) % 2019] += 1

ans = 0
for i in counter:
    ans += (i * (i - 1)) // 2

print(ans)


import sys
input= lambda: sys.stdin.readline().rstrip()
def pin(type=int):return map(type,input().split())
def tupin(t=int):return tuple(pin(t))
#%%code
def resolve():
    N,M=pin()
    cond=M<N
    print(["unsafe","safe"][cond])
#%%submit!
resolve()

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

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

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

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

s = input(int())
w = input(int())

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

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

if (S <= W) and 0 <= S,W <= 100: 
    print('unsafe')
else:
    print('safe')

S = input()
W = input()

if int(S) <= int(W):
  print('unsafe')
elif int(S) > int(W):
  print('safe')
  

import random

S = random.randint(1,100)
W = random.randint(1,100)

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

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

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):
_=input()
while True:
  pass

#!/usr/bin/env python3
s, w = map(int, input().split())
print(['unsafe', 'safe'][s > w])

Verdicts: Time Limit Exceeded

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

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

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

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

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



a,b=[int(x) for x in 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()))

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

s, w = list(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 = int(input())
S = [input() for i in range(N)]
a = set(S)
print(len(a))

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

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):
#define _GLIBCXX_DEBUG

#include <bits/stdc++.h>
using namespace std;

int main() {
    int s,w; cin >> s >> w;
    if (w >= s){
        cout << "unsafe\n";
    }
    else{
        cout << "safe\n";
    }
}

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 = int(input())
l = []
for i in range(N):
  Si = input()
  if not Si in l:
    l.append(Si)
print(len(l))

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

a,b=map(int, input().split())
print('unsafe') if a<=b 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 math
A, B, C, D = map(int,input().split())
hpa = math.ceil(A / D)
hhb = math.ceil(C / B)
if (hpa >= hpb):
    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):
S=input()
count=0
#S3=''


#    S3+=str(int(S[i])%3)
for i in range(0,len(S)-4):
    check3=int(S[i])+int(S[i+1])+int(S[i+2])+int(S[i+3])
    for j in range(i+5,len(S)+1):
        check3+=int(S[j-1])
        check3%=3
        if check3==0:
            if int(S[i:j])%673==0:
                count+=1
                
print(str(count))

S=[str(input()) for i in range(2*10^1-1)]
S.pop(0)
print(len(set(S)))

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

if S > W:
    print('safe')

elif S < W:
    print('unsafe')


python3 make.py abc 999 --num 6

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

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

s, w = list(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):
n = int(input())

l = []
for i in range(n):
  l.append(input())
  

L = []
for i in l:
  if i not in L:
    L.append(i)
 
print(len(L))

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

if a > b:
  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().split()
#print(s)
if s[0] => s[1]:
  print(unsafe)
	else:
      print(safe)
      

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

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

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

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

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

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

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


#abc164a

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


#abc164a

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

S, W = map(int, input().split())
print('unsafe') if W>= S 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: 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: 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 collections import Counter
N = list(input())
M = [0]
S = 0
K = 1
ans = 0

for i in range(len(N)):
    S += int(N[-i-1])*K
    S %= 2019

    K *= 10
    K %= 2019
    M.append(S)

P = Counter(M)
for i in range(2020):ans+=P[i]*(P[i]-1)//2
print(ans)


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

if b-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):
a = input("羊の数")
b = input("狼の数")

S = int(a)
W = int(b)

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):
list = input().split()
a = int(list[0])
b = int(list[1]) 
c = int(list[2])
d = int(list[3])


while c>0 and a>0:
    c = c - b
    if c <= 0:
        print("Yes")
        break
    else:
        pass

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


list = input().split()
s = list[0]
w = list[1]
ins = int(s)
inw = int(w)
if inw >= ins:
    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 = int(input())
W = int(input())
if S <= W : print("unsafe")
else: print("safe")

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

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

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

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

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=int(input("羊の数を入力"))
W=inr(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())
print(w>=s)

a, b, c, d = map(int, input().split())
takahashi = [a, b] if a>b else [b, a]
aoki = [c, d] if c>d else [d, c]
attackers = [takahashi, aoki]
attacker = 0

while 0 not in takahashi and 0 not in aoki:
  attackers[attacker^1][1] = max(0, attackers[attacker^1][1]-attackers[attacker][0])
  attackers[attacker^1].sort(reverse=True)
  attacker = attacker^1

if 0 in attackers[0]:
  print('No')
else:
  print('Yes')

s, w = map(int, input().split())
print('unsafe' if w>=s else '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, w = map(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):
q = input().split()
q = [int(i) for i in q]

t = [q[0], q[1]]
a = [q[2], q[3]]

while True:
    a[0] = a[0] - t[1]
    if (a[0] <= 0):
        print("Yes")
        break

    t[0] = t[0] - a[1]
    if (t[0] <= 0):
        print("No")
        break



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

s = q[0]
w = q[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 = input().split()
print("safe") if s < w else print("unsafe")

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

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

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=list(map(int,list(input())))
n=len(s)
m=[[0]*(n+1) for _ in range(n+1)]
ans=0
for i in range(1,n+1):
    for j in range(i,n+1):
        m[i][j]=(m[i][j-1]*10+s[j-1])%2019
        if m[i][j]==0:
            ans+=1
print(ans)

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

S,W=[int(i) for i in 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):
import re
S=input()

x=[i*2019 for i in range(1,10000)]


ans=0

for i in x:
    t=len(re.findall("(?={})".format(i),S))
    ans+=t

print(ans)


import re
S=input()

x=[i for i in range(1,10000)]
x=map(lambda i:str(i*2019),x)



ans=0

for i in x:
    t=len(re.findall("(?={})".format(i),S))
    ans+=t

print(ans)


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

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):
# import math
# import numpy as np
# import itertools
# import heapq
# =map(int,input().split())
w=int(input())
s=int(input())
if w>=s:
    print('unsafe')
else:
    print('safe')



# import math
# import numpy as np
# import itertools
# import heapq
# =map(int,input().split())
s,w=map(int,input().split())
if w>=s:
    print('unsafe')
else:
    print('safe')



Verdicts: Runtime Error

Accepted