Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Runtime Error):
a = list(map(int, input().split()))
queuekey = []
queuetime = []

for i in range(0, a[0]):
    tmp = list(input().split())
    queuekey.append(tmp[0])
    queuetime.append(int(tmp[1]))

spentTime = 0
while len(queue) > 0:
    if queuetime[0] < a[1]:
        spentTime += queuetime[0]
        print(queuekey[0], end="")
        print(' ', end="")
        print(spentTime)
        queuekey.pop(0)
        queuetime.pop(0)
    else:
        spentTime += a[1]
        queuetime[0] -= a[1]
        queuetime.append(queletime[0])
        queuekey.append(quelekey[0])
        queuetime.pop(0)
        queuekey.pop(0)

        
    

Fixed submission:
a = list(map(int, input().split()))
queuekey = []
queuetime = []

for i in range(0, a[0]):
    tmp = list(input().split())
    queuekey.append(tmp[0])
    queuetime.append(int(tmp[1]))

spentTime = 0
while len(queuetime) > 0:
    if queuetime[0] <= a[1]:
        spentTime += queuetime[0]
        print(queuekey[0], end="")
        print(' ', end="")
        print(spentTime)
        queuekey.pop(0)
        queuetime.pop(0)
    else:
        spentTime += a[1]
        queuetime[0] -= a[1]
        queuetime.append(queuetime[0])
        queuekey.append(queuekey[0])
        queuetime.pop(0)
        queuekey.pop(0)

Buggy python submission (verdict: Runtime Error):
a = list(map(int, input().split()))
queuekey = []
queuetime = []

for i in range(0, a[0]):
    tmp = list(input().split())
    queuekey.append(tmp[0])
    queuetime.append(int(tmp[1]))

spentTime = 0
while len(queuetime) > 0:
    if queuetime[0] < a[1]:
        spentTime += queuetime[0]
        print(queuekey[0], end="")
        print(' ', end="")
        print(spentTime)
        queuekey.pop(0)
        queuetime.pop(0)
    else:
        spentTime += a[1]
        queuetime[0] -= a[1]
        queuetime.append(queletime[0])
        queuekey.append(quelekey[0])
        queuetime.pop(0)
        queuekey.pop(0)

        
    

Fixed submission:
a = list(map(int, input().split()))
queuekey = []
queuetime = []

for i in range(0, a[0]):
    tmp = list(input().split())
    queuekey.append(tmp[0])
    queuetime.append(int(tmp[1]))

spentTime = 0
while len(queuetime) > 0:
    if queuetime[0] <= a[1]:
        spentTime += queuetime[0]
        print(queuekey[0], end="")
        print(' ', end="")
        print(spentTime)
        queuekey.pop(0)
        queuetime.pop(0)
    else:
        spentTime += a[1]
        queuetime[0] -= a[1]
        queuetime.append(queuetime[0])
        queuekey.append(queuekey[0])
        queuetime.pop(0)
        queuekey.pop(0)
Buggy python submission (verdict: Time Limit Exceeded):
#5.3
n = int(input())
S = list(map(int, input().split()))
q = int(input())
T = list(map(int, input().split()))

findCount = 0

for t in T:
    left = 0
    right = n - 1
    center = right // 2
    while left != right:
        if S[center] == t:
            findCount += 1
            break
        
        if S[center] >= t:
            right = center
        else:
            left = center
            
        center = (left + right) // 2

print(findCount)

Fixed submission:
#5.3
n = int(input())
S = list(map(int, input().split()))
q = int(input())
T = list(map(int, input().split()))

findCount = 0

for t in T:
    left = 0
    right = n
    center = right // 2
    preCenter= 0
    while left < right:
        if S[center] == t:
            findCount += 1
            break
        
        if S[center] > t:
            right = center
        else:
            left = center + 1
        
        center = (left + right) // 2

print(findCount)

Buggy python submission (verdict: Time Limit Exceeded):
#5.3
n = int(input())
S = list(map(int, input().split()))
q = int(input())
T = list(map(int, input().split()))

findCount = 0

for t in T:
    left = 0
    right = n
    center = right // 2
    preCenter= 0
    while left < right:
        if S[center] == t:
            findCount += 1
            break
        
        if S[center] >= t:
            right = center
        else:
            left = center
        
        center = (left + right) // 2

print(findCount)

Fixed submission:
#5.3
n = int(input())
S = list(map(int, input().split()))
q = int(input())
T = list(map(int, input().split()))

findCount = 0

for t in T:
    left = 0
    right = n
    center = right // 2
    preCenter= 0
    while left < right:
        if S[center] == t:
            findCount += 1
            break
        
        if S[center] > t:
            right = center
        else:
            left = center + 1
        
        center = (left + right) // 2

print(findCount)
Buggy python submission (verdict: Runtime Error):
def merge(A,left,mid,right):
    global cnt
    L = A[left:mid]
    R = A[mid:right]
    L.append(float("inf"))
    R.append(float("inf"))
    i = 0
    j = 0
    for k in range(left, right):
        cnt += 1
        if L[i] <=R[j]:
            A[k] = L[i]
            i += 1
        else:
            A[k] = R[j]
            j += 1


def mergeSort(A,left,right):
        if left+1 < right:
            mid = (left+right) // 2
            mergeSort(A,left,mid)
            mergeSort(A,mid,right)
            merge(A,left,mid,right)

n = input()
S = list(map(int,input(),split()))
cnt=0

mergeSort(S,0,n)

print(" ".join(map(str,S)))
print(cnt)

Fixed submission:
def merge(A,left,mid,right):
    global cnt
    L = A[left:mid]
    R = A[mid:right]
    L.append(float("inf"))
    R.append(float("inf"))
    i = 0
    j = 0
    for k in range(left, right):
        cnt += 1
        if L[i] <=R[j]:
            A[k] = L[i]
            i += 1
        else:
            A[k] = R[j]
            j += 1


def mergeSort(A,left,right):
        if left+1 < right:
            mid = (left+right) // 2
            mergeSort(A,left,mid)
            mergeSort(A,mid,right)
            merge(A,left,mid,right)

n = int(input())
S = list(map(int,input().split()))
cnt=0

mergeSort(S,0,n)

print(" ".join(map(str,S)))
print(cnt)
Buggy python submission (verdict: Time Limit Exceeded):
number = int(input())
text = [int(x.strip()) for x in input().split()]

cnt = 0
for i in range(number):
    for j in range(i+1,number):
        if text[i] > text[j]:
            cnt += 1
print(cnt)


Fixed submission:
cnt = 0
def merge(A,left,mid,right):
    global cnt
    n1 = mid - left
    n2 = right - mid

    L = [A[i] for i in range(left, mid)]
    R = [A[i] for i in range(mid, right)]
    L.append(float("inf"))
    R.append(float("inf"))
    i = 0
    j = 0
    for k in range(left, right):
        if L[i] <= R[j]:
            A[k] = L[i]
            i += 1
        else:
            cnt += n1 - i
            A[k] = R[j]
            j += 1

def mergeSort(A,left,right):
        if left + 1 < right:
            mid = (left+right) // 2
            mergeSort(A,left,mid)
            mergeSort(A,mid,right)
            merge(A,left,mid,right)

input()
a = list(map(int, input().split()))
mergeSort(a, 0, len(a))
print(cnt)

Buggy python submission (verdict: Runtime Error):
cnt = 0
def merge(A,left,mid,right):
    global cnt
    n1 = mid - left
    n2 = right - mid

    L = [A[i] for i in range(left, mid)]
    R = [A[i] for i in range(mid, right)]
    L.append(float("inf"))
    R.append(float("inf"))
    i = 0
    j = 0
    for k in range(left, right):
        if L[i] <= R[j]:
            A[k] = L[i]
            i += 1
        else:
            cnt += n1 - i
            A[k] = R[j]
            j += 1

def mergeSort(A,left,right):
        if left + 1 < right:
            mid = (left+right) // 2
            mergeSort(A,left,mid)
            mergeSort(A,mid,right)
            merge(A,left,mid,right)

input()
a = list(map(int, input().split()))
mergeSort(a, 0, len(a))
return cnt



Fixed submission:
cnt = 0
def merge(A,left,mid,right):
    global cnt
    n1 = mid - left
    n2 = right - mid

    L = [A[i] for i in range(left, mid)]
    R = [A[i] for i in range(mid, right)]
    L.append(float("inf"))
    R.append(float("inf"))
    i = 0
    j = 0
    for k in range(left, right):
        if L[i] <= R[j]:
            A[k] = L[i]
            i += 1
        else:
            cnt += n1 - i
            A[k] = R[j]
            j += 1

def mergeSort(A,left,right):
        if left + 1 < right:
            mid = (left+right) // 2
            mergeSort(A,left,mid)
            mergeSort(A,mid,right)
            merge(A,left,mid,right)

input()
a = list(map(int, input().split()))
mergeSort(a, 0, len(a))
print(cnt)
Buggy python submission (verdict: Time Limit Exceeded):
def partition(A, p, r):
    x = int(A[r-1][1])
    i = p-1

    for j in range(p,r-1):
        if int(A[j][1]) <= x:
            i = i + 1
            A[i],A[j] = A[j],A[i]
    A[i+1],A[r-1] = A[r-1],A[i+1]
    return i + 1

def qsort(A,p,r):
    if p < r:
        q = partition(A,p,r)
        qsort(A,p,q)
        qsort(A,q+1,r)
    return A

def isStable(a, b):
    length = int(len(a))
    for i in range(length):
        for j in range(i+1,length-1) :
            for x in range(length):
                for y in range(x+1,length-1) :
                    if a[i][1]==a[j][1] and a[i] == b[y] and a[j] == b[x]:
                        return False
                        break
    return True

if __name__ == '__main__':
    cnt = int(input())
    A = []
    for i in range(cnt):
        A.append(input().split())
    A2 = A[:]
    p = 0
    r = len(A)
    B = qsort(A,p,r)
    if isStable(A2,B):
        print("Stable")
    else:
        print("Not stable")
    for i in B:
        print ("{0} {1}".format(i[0],i[1]))

Fixed submission:
def partition(A, p, r):
    x = int(A[r-1][1])
    i = p-1

    for j in range(p,r-1):
        if int(A[j][1]) <= x:
            i = i + 1
            A[i],A[j] = A[j],A[i]
    A[i+1],A[r-1] = A[r-1],A[i+1]
    return i + 1

def qsort(A,p,r):
    if p < r:
        q = partition(A,p,r)
        qsort(A,p,q)
        qsort(A,q+1,r)
    return A

def isStable(a):
    length = int(len(a))
    for i in range(length):
        for j in range(i+1,length-1) :
            if a[i][1] == a[j][1] and a[i][2] > a[j][2]:
                return False
                break
    return True

if __name__ == '__main__':
    cnt = int(input())
    A = []
    for i in range(cnt):
        N = input().split()
        N.append(i)
        A.append(N)
    p = 0
    r = len(A)
    B = qsort(A,p,r)
    if isStable(B):
        print("Stable")
    else:
        print("Not stable")
    for i in B:
        print ("{0} {1}".format(i[0],i[1]))
Buggy python submission (verdict: Runtime Error):
class dice_2:
    def __init__(self,label):
        self.spots = label

    def result(self,top,front):
        if top == 1:
            self.order=[2,3,5,4,2]
        elif top == 2:
            self.order=[6,3,1,4,6]
        elif top == 3:
            self.order=[2,6,5,1,2]
        elif top == 4:
            self.order=[2,1,5,6,2]
        elif top == 5:
            self.order=[1,3,6,4,1]
        elif top == 6:
            self.order=[2,4,5,3,2]

        for i in range(4):
            if self.order[i] == front:
                self.right = self.order[i+1]

    def output(self):
        print(self.spots[self.right-1])

label = list(map(int,input().split()))
dice = dice_2(label)
for i in range(int(input())):
    top,front = map(int,(input().split()))
    dice.result(top,front)
    dice.output()

Fixed submission:
class dice_2:
    def __init__(self,label):
        self.spots = label

    def result(self,top,front):
        if self.spots.index(top)+1 == 1:
            self.order=[2,3,5,4,2]
        elif self.spots.index(top)+1 == 2:
            self.order=[6,3,1,4,6]
        elif self.spots.index(top)+1 == 3:
            self.order=[2,6,5,1,2]
        elif self.spots.index(top)+1 == 4:
            self.order=[2,1,5,6,2]
        elif self.spots.index(top)+1 == 5:
            self.order=[1,3,6,4,1]
        elif self.spots.index(top)+1 == 6:
            self.order=[2,4,5,3,2]

        for i in range(4):
            if self.order[i] == self.spots.index(front)+1:
                self.right = self.order[i+1]

    def output(self):
        print(self.spots[self.right-1])

label = list(map(int,input().split()))
dice = dice_2(label)
for i in range(int(input())):
    top,front = map(int,(input().split()))
    dice.result(top,front)
    dice.output()
Buggy python submission (verdict: Runtime Error):
dice_a = list(map(int,input().split()))
dice_b = list(map(int,input().split()))
dice_a_roll = []


for i in range(6):
    if dice_a[i] == dice_b[0]:
        b_top = i + 1
    if dice_a[i] == dice_b[1]:
        b_front = i + 1


if b_top == 1:
    order=[2,3,5,4,2,3,5]
    for k in range(4):
        if b_front == order[k]:
            spots = [1, order[k], order[k+1], order[k+3], order[k+2], 6]

elif b_top == 2:
    order=[6,3,1,4,6,3,1]
    for k in range(4):
        if b_front == order[k]:
            spots = [2, order[k], order[k+1], order[k+3], order[k+2], 5]

elif b_top == 3:
    order=[2,6,5,1,2,6,5]
    for k in range(4):
        if b_front == order[k]:
            spots = [3, order[k], order[k+1], order[k+3], order[k+2], 4]

elif b_top == 4:
    order=[2,1,5,6,2,1,5]
    for k in range(4):
        if b_front == order[k]:
            spots = [4, order[k], order[k+1], order[k+3], order[k+2], 3]

elif b_top == 5:
    order=[1,3,6,4,1,3,6]
    for k in range(4):
        if b_front == order[k]:
            spots = [5, order[k], order[k+1], order[k+3], order[k+2], 2]

elif b_top == 6:
    order=[2,4,5,3,2,4,5]
    for k in range(4):
        if b_front == order[k]:
            spots = [6, order[k], order[k+1], order[k+3], order[k+2], 1]


for l in spots:
    dice_a_roll.append(dice_a[l-1])


if dice_a_roll == dice_b:
    print("Yes")
else:
    print("No")

Fixed submission:
class dice:
    def __init__(self,label):
        self.spots = label

    def roll(self,way):
        if way == "N":
            self.spots = [self.spots[1],self.spots[5],self.spots[2],self.spots[3],self.spots[0],self.spots[4]]
        if way == "E":
            self.spots = [self.spots[3],self.spots[1],self.spots[0],self.spots[5],self.spots[4],self.spots[2]]
        if way == "W":
            self.spots = [self.spots[2],self.spots[1],self.spots[5],self.spots[0],self.spots[4],self.spots[3]]
        if way == "S":
            self.spots = [self.spots[4],self.spots[0],self.spots[2],self.spots[3],self.spots[5],self.spots[1]]
    def output(self):
        return self.spots


dice_1 = list(map(int,input().split()))
label = list(map(int,input().split()))
dice_2 = []

rotation = dice(label)
for i in range(3):
    dice_2.append(rotation.output())
    for j in range(3):
        rotation.roll("E")
        dice_2.append(rotation.output())
    rotation.roll("N")

rotation.roll("N")
rotation.roll("N")

for i in range(3):
    dice_2.append(rotation.output())
    for j in range(3):
        rotation.roll("W")
        dice_2.append(rotation.output())
    rotation.roll("N")

if dice_1 in dice_2:
    print("Yes")
else:
    print("No")
Buggy python submission (verdict: Runtime Error):
r=int(input())
p=3.14159265358979
print("{0:.5f} {1:.5f}".format(p*r**2,2*p*r))

Fixed submission:
r=float(input())
p=3.14159265358979
print("{0:.5f} {1:.5f}".format(p*r**2,2*p*r))
Buggy python submission (verdict: Time Limit Exceeded):
count={}
for i in range(97,97+26):
    count[chr(i)] = 0

text=[]
text_out=""
while True:
    try:
        text.append(input())
    except EOFError:
        text_out="".join(text)

text_lower=text_out.lower()

for letter in text_lower:
    if letter in count:
        count[letter] += 1

for x,y in sorted(count.items()):
    print("{0} : {1}".format(x,y))

Fixed submission:
count={}
for i in range(97,97+26):
    count[chr(i)] = 0

text=[]
while True:
    try:
        text.append(input())
    except EOFError:
        break

text_out="".join(text)
text_lower=text_out.lower()

for letter in text_lower:
    if letter in count:
        count[letter] += 1

for x,y in sorted(count.items()):
    print("{0} : {1}".format(x,y))
Buggy python submission (verdict: Runtime Error):
n = input()
lst = list(map(int,input().split())
for i in range(n):
    key = lst[i]
    j = i-1
    while j >= 0 and lst[j] > key:
        lst[j+1] = lst[j]
        j -= 1
    lst[j+1] = key
    print(' '.join(map(str,lst)))

Fixed submission:
n = int(input())
lst = list(map(int,input().split()))
for i in range(n):
    key = lst[i]
    j = i-1
    while j >= 0 and lst[j] > key:
        lst[j+1] = lst[j]
        j -= 1
    lst[j+1] = key
    print(' '.join(map(str,lst)))

Buggy python submission (verdict: Runtime Error):
n = int(input())
a = map(int,input().split())
for i in range(1,n):
    key = a[i]
    j = i-1
    while j >=0 and a[j] > key:
        a[j+1] = a[j]
        j -= 1
    a[j+1] = key
    print(' '.join(map(str,a)))

Fixed submission:
n = int(input())
lst = list(map(int,input().split()))
for i in range(n):
    key = lst[i]
    j = i-1
    while j >= 0 and lst[j] > key:
        lst[j+1] = lst[j]
        j -= 1
    lst[j+1] = key
    print(' '.join(map(str,lst)))

Buggy python submission (verdict: Runtime Error):
n = int(input())
a = list(map(int,input().split().strip())
for i in range(n):
    key = a[i]
    j = i - 1
    while j >= 0 and a[j] > key:
        a[j+1] = a[j]
        j -= 1
    a[j+1] = key
    print(' '.join(map(str,a)))

Fixed submission:
n = int(input())
lst = list(map(int,input().split()))
for i in range(n):
    key = lst[i]
    j = i-1
    while j >= 0 and lst[j] > key:
        lst[j+1] = lst[j]
        j -= 1
    lst[j+1] = key
    print(' '.join(map(str,lst)))

Buggy python submission (verdict: Runtime Error):
n = int(input())
a = list(map(int,input().strip().split())
for i in range(n):
    key = a[i]
    j = i -1
    while j > 0 and a[j] > key:
        a[j+1] = a[j]
        j -= 1
    a[j+1] = key
    print(' '.join(map(str,a)))

Fixed submission:
n = int(input())
lst = list(map(int,input().split()))
for i in range(n):
    key = lst[i]
    j = i-1
    while j >= 0 and lst[j] > key:
        lst[j+1] = lst[j]
        j -= 1
    lst[j+1] = key
    print(' '.join(map(str,lst)))
Buggy python submission (verdict: Runtime Error):
n = int(input())
lst = list(map(int,input().split()))
cnt = 0
for i in range(n):
    for j in range(n-1,i,-1):
        if lst[j] < lst[j-1]:
            count += 1
            lst[j],lst[j-1] = lst[j-1],lst[j]

print(' '.join(map(str,lst)))
print(cnt)

Fixed submission:
n = int(input())
a = list(map(int,input().strip().split()))
count = 0
for i in range(n):
    for j in range(n-1,i,-1):
        if a[j] < a[j-1]:
            a[j],a[j-1] = a[j-1],a[j]
            count += 1
print(' '.join(map(str,a)))
print(count)

Buggy python submission (verdict: Runtime Error):
n = int(input())
a = list(map(int,input().split())
count =0
for i in range(n):
    for j in range(n-1,i,-1):
        if a[j] < a[j-1]:
            a[j],a[j-1] = a[j-1],a[j]
            count += 1
print(' '.join(map(str,a)))
print(count)

Fixed submission:
n = int(input())
a = list(map(int,input().strip().split()))
count = 0
for i in range(n):
    for j in range(n-1,i,-1):
        if a[j] < a[j-1]:
            a[j],a[j-1] = a[j-1],a[j]
            count += 1
print(' '.join(map(str,a)))
print(count)

Buggy python submission (verdict: Runtime Error):
n = int(input())
a = list(map(int,input().strip().split())
count = 0
for i in range(n):
    for j in range(n-1,i,-1):
        if a[j] < a[j-1]:
            count += 1
            a[j],a[j-1] = a[j-1],a[j]

print(' '.join(map(str,a)))
print(count)

Fixed submission:
n = int(input())
a = list(map(int,input().strip().split()))
count = 0
for i in range(n):
    for j in range(n-1,i,-1):
        if a[j] < a[j-1]:
            a[j],a[j-1] = a[j-1],a[j]
            count += 1
print(' '.join(map(str,a)))
print(count)

Buggy python submission (verdict: Runtime Error):
n = int(input())
a = list(map(int,input().strip().split())
count = 0
for i in range(n):
    for j in range(n-1,i,-1):
        if a[j] < a[j-1]:
            a[j],a[j-1] = a[j-1],a[j]
            count += 1
print(' '.join(map(str,a)))
print(count)

Fixed submission:
n = int(input())
a = list(map(int,input().strip().split()))
count = 0
for i in range(n):
    for j in range(n-1,i,-1):
        if a[j] < a[j-1]:
            a[j],a[j-1] = a[j-1],a[j]
            count += 1
print(' '.join(map(str,a)))
print(count)
Buggy python submission (verdict: Runtime Error):
f = input().strip().split()
q = []
for e in f:
    if e =='+':
        q.append(q.pop() + q.pop())
    elif e == '-':
        q.append(-q.pop() + q.pop())
    elif e == '*':
        q.append(q.pop() * q.pop())
    else:
        q.append(int(q))
print(q[0])

Fixed submission:
f = input().strip().split()
q = []
for e in f:
    if e == '+':
        q.append(q.pop() + q.pop())
    elif e == '-':
        q.append(-q.pop() + q.pop())
    elif e == '*':
        q.append(q.pop() * q.pop())
    else:
        q.append(int(e))

print(q[0])
Buggy python submission (verdict: Runtime Error):
x ** 3

Fixed submission:
x = int(input())
print(x**3)
Buggy python submission (verdict: Runtime Error):
a,b = map(int,input())
if a < b:
    print(a,'<',b)
elif a > b:
    print(a,'>',b)
else:
    print(a,'==',b)

Fixed submission:
a,b = map(int,input().split())
if a < b:
    print('a < b')
elif a > b:
    print('a > b')
else:
    print('a == b')

Buggy python submission (verdict: Runtime Error):
a,b = map(int,imput().split())
if a < b:
    print(a,'<',b)
elif a > b:
    print(a,'>',b)
else:
    print(a,'==',b)

Fixed submission:
a,b = map(int,input().split())
if a < b:
    print('a < b')
elif a > b:
    print('a > b')
else:
    print('a == b')
Buggy python submission (verdict: Runtime Error):
a,b,c =  map(int,input().split())
if a < b < c:
    print('Yes')
elde:
    print('No')

Fixed submission:
a,b,c = map(int,input().split())
if a < b < c:
    print('Yes')
else:
    print('No')
Buggy python submission (verdict: Runtime Error):
print(*sorted(input().split())))

Fixed submission:
l = list(input().split())
print(' '.join(map(str,sorted(l))))

Buggy python submission (verdict: Runtime Error):
a,b,c = map(int,input().split())
print(sorted(list(a,b,c)))

Fixed submission:
l = list(input().split())
print(' '.join(map(str,sorted(l))))

Buggy python submission (verdict: Runtime Error):
a,b,c = map(int,input().split())
print(sorted(list(a,b,c)))

Fixed submission:
l = list(input().split())
print(' '.join(map(str,sorted(l))))

Buggy python submission (verdict: Runtime Error):
a,b,c = map(int,input().split())
li= sorted(li[0],li[1],li[2])
print(li[0],li[1],li[2])

Fixed submission:
l = list(input().split())
print(' '.join(map(str,sorted(l))))

Buggy python submission (verdict: Runtime Error):
a,b,c = map(int,input().split())
print(' '.join(map(str,sorted(list(a,b,c)))))

Fixed submission:
l = list(input().split())
print(' '.join(map(str,sorted(l))))

Buggy python submission (verdict: Runtime Error):
l = list(input().split())
print(' 'a.join(map(str,sorted(l))))

Fixed submission:
l = list(input().split())
print(' '.join(map(str,sorted(l))))
Buggy python submission (verdict: Runtime Error):
W,H,x,y,r = (int(i) for i in input().split())
if (0 <= x-r and x+r <= W) and (0 <= y-r and y+r <= M):
    print('Yes')
else:
    print('No')

Fixed submission:
w,h,x,y,r = map(int,input().split())
if (0 <= x-r and x+r <= w) and (0 <= y-r and y+r <= h):
    print('Yes')
else:
    print('No')

Buggy python submission (verdict: Runtime Error):
W,H,x,y,r = list(map(int,input().split()))
if (0 <= x-r and x+r <= W) and ( 0 <= y-r and y+r <= M):
    print('Yes')
else:
    print('No')

Fixed submission:
w,h,x,y,r = map(int,input().split())
if (0 <= x-r and x+r <= w) and (0 <= y-r and y+r <= h):
    print('Yes')
else:
    print('No')

Buggy python submission (verdict: Runtime Error):
W,H,x,y,r = map(int,input().split())
if (0 <= x-r and x+r <= W) and (0 <= y-r and y+r <=h):
    print('Yes')
else:
    print('No')

Fixed submission:
w,h,x,y,r = map(int,input().split())
if (0 <= x-r and x+r <= w) and (0 <= y-r and y+r <= h):
    print('Yes')
else:
    print('No')