Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Runtime Error):
package main

import (
	"fmt"
)

func answer158A(s string) string {
	if s == "AAA" || s == "BBB" {
		return "No"
	} else {
		return "Yes"
	}
}

func main() {
	var s string
	fmt.Scan(&s)
	
	fmt.Println(answer158A(s))
}


Fixed submission:
s = input()

if 'A' in s and 'B' in s:
  	print('Yes')
else:
  	print('No')

Buggy python submission (verdict: Runtime Error):
def actual(n, a, b):
    n_op_least = n // (a + b)

    n_blue_least = a * n_op_least
    adjustment = min(n % (a + b), a)

    return n_blue_least + adjustment

n, a, b = map(int, input().split())
print(actual(n, a, b))


Fixed submission:
s = input()

if 'A' in s and 'B' in s:
  	print('Yes')
else:
  	print('No')

Buggy python submission (verdict: Runtime Error):
import math


def actual(n, a, b):
    _少なくとも必要な操作回数_もしかすると1回足りない = n // (a + b)
    _少なくとも存在する青ボールの数 = a * _少なくとも必要な操作回数_もしかすると1回足りない

    # 操作回数が足りている == 余り0 => 0 だし
    # 操作回数が不足している => 1回だけ追加で操作をすれば良いので、 a追加

    _端数 = min(n % (a + b), a)

    return _少なくとも存在する青ボールの数 + _端数

n, a, b = map(int, input().split())
print(actual(n, a, b))


Fixed submission:
s = input()

if 'A' in s and 'B' in s:
  	print('Yes')
else:
  	print('No')
Buggy python submission (verdict: Runtime Error):
import math


def actual(n, a, b):
    # 文字列の長さがN以上になるために必要な操作の回数
    required_operations = math.ceil(n / (a + b))

    s = ''

    for _ in range(required_operations):
        s += '青' * a + '赤' * b

    return s[:n].count('青')


n, a, b = map(int, input().split())
print(actual(n, a, b))


Fixed submission:
def actual(n, a, b):
    n_op_least = n // (a + b)

    n_blue_least = a * n_op_least
    adjustment = min(n % (a + b), a)

    return n_blue_least + adjustment

n, a, b = map(int, input().split())
print(actual(n, a, b))

Buggy python submission (verdict: Runtime Error):
def actual(n, a, b):
    s = ''

	for _ in range(10**100):
        s += '青' * a + '赤' * b

        if len(s) >= n:
            return s[:n].count('青')

n, a, b = map(int, input().split())
print(actual(n, a, b))


Fixed submission:
def actual(n, a, b):
    n_op_least = n // (a + b)

    n_blue_least = a * n_op_least
    adjustment = min(n % (a + b), a)

    return n_blue_least + adjustment

n, a, b = map(int, input().split())
print(actual(n, a, b))

Buggy python submission (verdict: Runtime Error):
def actual(n, a, b):
    s = ''

    # 無限ループにはならない前提
    while True:
        s += '青' * a + '赤' * b

        if len(s) >= n:
            return s[:n].count('青')

n, a, b = map(int, input().split())
print(actual(n, a, b))


Fixed submission:
def actual(n, a, b):
    n_op_least = n // (a + b)

    n_blue_least = a * n_op_least
    adjustment = min(n % (a + b), a)

    return n_blue_least + adjustment

n, a, b = map(int, input().split())
print(actual(n, a, b))
Buggy python submission (verdict: Runtime Error):
H, N = map(int, input().split())
A = input()

waza = 0
for i in range(0, N):
    waza = waza + int(A.split()[i])

if waza >= H:
    print("Yes")
else:
    print("No")


Fixed submission:
hp, attack = map(int, input().split())

x, y = divmod(hp, attack)

if y == 0:
	print(x)
else:
  	print(x + 1)
Buggy python submission (verdict: Time Limit Exceeded):
H, N = map(int, input().split())
A = input()

waza = 0
for i in range(0, N):
    waza = waza + int(A.split()[i])

if waza >= H:
    print("Yes")
else:
    print("No")


Fixed submission:
def actual(h, n, A):
    max_damage = sum(A)

    if max_damage >= h:
        return 'Yes'

    return 'No'

h, n = map(int, input().split())
A = map(int, input().split())

print(actual(h, n, A))
Buggy python submission (verdict: Runtime Error):
def actual(a, b, k):
    if a >= k:
        # return f'{a - k} {b}'
        return '{} {}'.format((a - k), b)

    if b > (k - a):
        # return f'0 {b - (k - a)}'
        return f'0 {}'.format(b - (k - a))

    return '0 0'

a, b, k = map(int, input().split())
print(actual(a, b, k))
  

Fixed submission:
def actual(a, b, k):
    if a >= k:
        # return f'{a - k} {b}'
        return '{} {}'.format((a - k), b)

    if b > (k - a):
        # return f'0 {b - (k - a)}'
        return '0 {}'.format(b - (k - a))

    return '0 0'

a, b, k = map(int, input().split())
print(actual(a, b, k))
Buggy python submission (verdict: Runtime Error):
a1, a2, a3 = map(int, input().split())

total = sum(a1, a2, a3)

if total >= 22:
	print('bust')
else:
	print('win')

Fixed submission:
a1, a2, a3 = map(int, input().split())

total = a1 + a2 + a3

if total >= 22:
	print('bust')
else:
	print('win')
Buggy python submission (verdict: Runtime Error):
from string import ascii_uppercase


def actual(n, s):
    answer = ''

    for char in s:
        # mod 26 で 26パターンに分類できる。 `-13` はidx調整項
        old_ord = ord(char) % 26
        shift_n = n % 26
        idx_shift_n = old_ord + shift_n - 13

        answer += ascii_uppercase[idx_shift_n]

    return answer

n = int(input())
s = input()

print(actual(n, s))

Fixed submission:
def actual(n, s):
    # 方針: 0->25 の世界で nだけシフトさせる → 65-90の世界に復元
    answer = ''

    ord_A = ord('A')

    for char in s:
        x = ord(char) - ord_A  # Aが0になるように初期化する
        y = (x + n) % 26  # mod 26 で 26パターンに分類できる
        z = y + ord_A  # 復元できるように補正する

        answer += chr(z)

    return answer


n = int(input())
s = input()
 
print(actual(n, s))

Buggy python submission (verdict: Runtime Error):
from string import ascii_uppercase


def actual(n, s):
    answer = ''

    for char in s:
        # mod 26 で 26パターンに分類できる。 `-13` はidx調整項
        idx_shift_n = (ord(char) % 26) + n - 13

        answer += ascii_uppercase[idx_shift_n]

    return answer


n = int(input())
s = input()

print(actual(n, s))

Fixed submission:
def actual(n, s):
    # 方針: 0->25 の世界で nだけシフトさせる → 65-90の世界に復元
    answer = ''

    ord_A = ord('A')

    for char in s:
        x = ord(char) - ord_A  # Aが0になるように初期化する
        y = (x + n) % 26  # mod 26 で 26パターンに分類できる
        z = y + ord_A  # 復元できるように補正する

        answer += chr(z)

    return answer


n = int(input())
s = input()
 
print(actual(n, s))

Buggy python submission (verdict: Runtime Error):
from string import ascii_uppercase


def actual(n, s):
    answer = ''

    for char in s:
        # mod 26 で 26パターンに分類できる。 `-13` はidx調整項
        idx_shift_n = (ord(char) % 26) + n - 13

        answer += ascii_uppercase[idx_shift_n]

    return answer

n = int(input())
s = input()

print(actual(n, s))

Fixed submission:
def actual(n, s):
    # 方針: 0->25 の世界で nだけシフトさせる → 65-90の世界に復元
    answer = ''

    ord_A = ord('A')

    for char in s:
        x = ord(char) - ord_A  # Aが0になるように初期化する
        y = (x + n) % 26  # mod 26 で 26パターンに分類できる
        z = y + ord_A  # 復元できるように補正する

        answer += chr(z)

    return answer


n = int(input())
s = input()
 
print(actual(n, s))
Buggy python submission (verdict: Runtime Error):
import itertools


def actual(n, D):
    """
    combinations でゴリ押し
    """
    comb = itertools.combinations(D, 2)

    # return sum([x * y for x, y in comb])

    """
    「順番を考慮しない2要素の選び方」を全探索する際のポイント
        内側のループ変数の始点を外側のループ変数 +1 から始めるとよい。
        これにより、内側のループで選ぶインデックスが必ず外側のループで選ぶインデックスより大きくなり、
        同じ選び方を 2 回見てしまうことを回避できます。
    """
    # s = 0
    # for i in range(len(D)):
    #     for j in range(i + 1, len(D)):
    #         s += D[i] * D[j]
    #
    # return s

    """
    O(N)で解くパターン
    
    ex: a, b, c, d
        a*b + a*c + a*d = a * (b + c +d)
              b*c + b*d = b * (    c +d)
                    c*d = c * (       d)
    """
    s = 0
    for i in range(len(D) - 1):
        s += D[i] * sum(D[i + 1:])

    return s


n = int(input())
D = list(map(int, input().split()))

print(actual(n, D))


Fixed submission:
a, b = map(int, input().split())

if a <= b * 2:
	print(0)
else:
	print(a - b * 2)

Buggy python submission (verdict: Runtime Error):
import itertools


def actual(n, D):
    """
    combinations でゴリ押し
    """
    comb = itertools.combinations(D, 2)

    # return sum([x * y for x, y in comb])

    """
    「順番を考慮しない2要素の選び方」を全探索する際のポイント
        内側のループ変数の始点を外側のループ変数 +1 から始めるとよい。
        これにより、内側のループで選ぶインデックスが必ず外側のループで選ぶインデックスより大きくなり、
        同じ選び方を 2 回見てしまうことを回避できます。
    """
    # s = 0
    # for i in range(len(D)):
    #     for j in range(i + 1, len(D)):
    #         s += D[i] * D[j]
    #
    # return s

    """
    O(N)で解くパターン
    
    ex: a, b, c, d
        a*b + a*c + a*d = a * (b + c +d)
              b*c + b*d = b * (    c +d)
                    c*d = c * (       d)
    """
    s = 0
    for i in range(len(D) - 1):
        s += D[i] * sum(D[i + 1:])
    
    return s


n = int(input())
D = list(map(int, input().split()))

print(actual(n, D))


Fixed submission:
a, b = map(int, input().split())

if a <= b * 2:
	print(0)
else:
	print(a - b * 2)
Buggy python submission (verdict: Runtime Error):
import itertools


def actual(n, D):
    comb = itertools.combinations(D, 2)

    # return sum([x * y for x, y in comb])

    """
    「順番を考慮しない2要素の選び方」を全探索する際のポイント
        内側のループ変数の始点を外側のループ変数 +1 から始めるとよい。
        これにより、内側のループで選ぶインデックスが必ず外側のループで選ぶインデックスより大きくなり、
        同じ選び方を 2 回見てしまうことを回避できます。"""
    s = 0
    for i in range(len(D)):
        for j in range(i + 1, len(D)):
            s += D[i] * D[j]

    return s

n = int(input())
s = input()

print(actual(n, s))

Fixed submission:
import itertools


def actual(n, D):
    comb = itertools.combinations(D, 2)

    return sum([x * y for x, y in comb])

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

print(actual(n, D))
Buggy python submission (verdict: Time Limit Exceeded):
import itertools


def bit_patterns(n):
    return list(itertools.product(range(2), repeat=n))


def actual(n, V, C):
    diff_list = []

    for bit_pattern in bit_patterns(n):
        values = sum([bit * value for bit, value in zip(bit_pattern, V)])
        costs = sum([bit * cost for bit, cost in zip(bit_pattern, C)])

        diff_list.append(values - costs)

    return max(diff_list)

n = int(input())
V = list(map(int, input().split()))
C = list(map(int, input().split()))

print(actual(n, V, C))

Fixed submission:
def actual(n, V, C):
    # 購入するとプラスになるものだけ買って合計でおk
    sale_jewels = []

    for v, c in zip(V, C):
        if v - c > 0:
            sale_jewels.append(v - c)

    return sum(sale_jewels)

    # return sum([v - c for v, c in zip(V, C) if v - c > 0])


n = int(input())
V = list(map(int, input().split()))
C = list(map(int, input().split()))

print(actual(n, V, C))
Buggy python submission (verdict: Runtime Error):
def actual(s):
    sub_string_list = []

    N = len(s)
    for i in range(N):
        for j in range(N - 1):
            sub_string_list.append(s[i:j])

    set_ACGT = {'A', 'C', 'G', 'T'}
    length_list = []

    for sub_string in sub_string_list:
        if set(sub_string).issubset(set_ACGT):
            length_list.append(len(sub_string))

    return max(length_list)

s = input()
print(actual(s))

Fixed submission:
def generate_substrings(s):
    N = len(s)

    if N == 0:
        return {''}

    if N == 1:
        return {'', s}

    substrings = set()

    for i in range(N):
        for j in range(1, N + 1):
            substrings.add(s[i:j])

    return substrings


def actual(s):
    sub_strings = generate_substrings(s)
    is_agct = lambda string: set(string).issubset({'A', 'G', 'C', 'T'})

    agct_length_list = [len(s) for s in sub_strings if is_agct(s)]

    return max(agct_length_list)

s = input()
print(actual(s))
Buggy python submission (verdict: Time Limit Exceeded):
def actual(N, M, AB):
    count = 0
    payment = 0

    while count < M:
        AB = [x for x in AB if x[1] > 0]
        m = min(AB, key=lambda x: x[0])

        payment += m[0]
        m[1] -= 1
        count += 1

    return payment

N, M = map(int, input().split())
AB = []
for _ in range(N):
  a, b = map(int, input().split())
  AB.append([a, b])
  
print(actual(N, M, AB))

Fixed submission:
def actual(N, M, AB):
    payment = 0

    shop_order_by_price_desc = sorted(AB, key=lambda x: x[0])

    for price, stock in shop_order_by_price_desc:
        if stock >= M:
            # 端数があるときは、残りの必要分だけ買えばよい
            return payment + (price * M)
        else:
            # 端数がないなら買い切る
            M -= stock
            payment += price * stock


N, M = map(int, input().split())
AB = []
for _ in range(N):
    a, b = map(int, input().split())
    AB.append([a, b])

print(actual(N, M, AB))

Buggy python submission (verdict: Time Limit Exceeded):
from __future__ import annotations

from dataclasses import dataclass, field
from typing import List


@dataclass
class Shop:
    id: int
    price: int
    stock: int

    def buy(self) -> None:
        self.stock -= 1


@dataclass(frozen=True)
class Shops:
    values: List[Shop] = field(default_factory=list)

    def register(self, shop: Shop) -> None:
        return self.values.append(shop)

    def _bargain_shop(self) -> Shop:
        shops_have_stock = [shop for shop in self.values if shop.stock > 0]

        return sorted(shops_have_stock, key=lambda shop: shop.price)[0]

    def how_much(self, required_num: int) -> int:
        drink_count = 0
        payment = 0

        while True:
            bargain_shop = self._bargain_shop()

            bargain_shop.buy()

            payment += bargain_shop.price
            drink_count += 1

            if drink_count == required_num:
                return payment


def actual(N, M, AB):
    shops = Shops()

    for idx, (a, b) in enumerate(AB, start=1):
        shop = Shop(id=idx, price=a, stock=b)
        shops.register(shop)

    return shops.how_much(required_num=M)

N, M = map(int, input().split())
AB = []
for _ in range(N):
  a, b = map(int, input().split())
  AB.append((a,b))
  
print(actual(N, M, AB))

Fixed submission:
def actual(N, M, AB):
    payment = 0

    shop_order_by_price_desc = sorted(AB, key=lambda x: x[0])

    for price, stock in shop_order_by_price_desc:
        if stock >= M:
            # 端数があるときは、残りの必要分だけ買えばよい
            return payment + (price * M)
        else:
            # 端数がないなら買い切る
            M -= stock
            payment += price * stock


N, M = map(int, input().split())
AB = []
for _ in range(N):
    a, b = map(int, input().split())
    AB.append([a, b])

print(actual(N, M, AB))
Buggy python submission (verdict: Runtime Error):
5 5
4 2 3 4 5
4 1 3 4 5
4 1 2 4 5
4 1 2 3 5
4 1 2 3 4

Fixed submission:
def actual(N, M, K, A):
    # 各人のAの積集合の要素数が答え
    s = set(A[0])

    for a in A[1:]:
        s &= set(a)

    return len(s)


N, M = map(int, input().split())

K = []
A = []

for _ in range(N):
    ka = list(map(int, input().split()))
    K.append(ka[0])
    A.append(ka[1:])

print(actual(N, M, K, A))
Buggy python submission (verdict: Runtime Error):
def actual(x1, y1, x2, y2):
    a = x2 - x1
    b = y2 - y1

    x3, y3 = x2 - b, y2 + a
    x4, y4 = x3 - a, y3 - b

    return f'{x3} {y3} {x4} {y4}'

x1, y1, x2, y2 = map(int, input().split())
print(actual(x1, y1, x2, y2))


Fixed submission:
def actual(x1, y1, x2, y2):
    a = x2 - x1
    b = y2 - y1

    x3, y3 = x2 - b, y2 + a
    x4, y4 = x3 - a, y3 - b

    # return f'{x3} {y3} {x4} {y4}'
    return '{} {} {} {}'.format(x3, y3, x4, y4)

x1, y1, x2, y2 = map(int, input().split())
print(actual(x1, y1, x2, y2))
Buggy python submission (verdict: Runtime Error):
def actual(n, i):
    return n - i + 1

n, i = map(int, input())
print(actual(n, i))

Fixed submission:
def actual(n, i):
    return n - i + 1

n, i = map(int, input().split())
print(actual(n, i))
Buggy python submission (verdict: Runtime Error):
def actual(a, b):
    return (a - 1) * (b - 1)

a, b = map(int, input())
print(actual(a, b))

Fixed submission:
def actual(a, b):
    return (a - 1) * (b - 1)

a, b = map(int, input().split())
print(actual(a, b))
Buggy python submission (verdict: Runtime Error):
def actual(N, M, X, A):
    # マスXの左右それぞれにある料金所の数を調べればOK
    toll_gates_left = [a_i for a_i in A if a_i < X]
    toll_gates_right = [a_i for a_i in A if X < a_i]

    return min(len(toll_gates_left), len(toll_gates_right))

N, M, X = map(int, input().split())
A = [int(input()) for _ in range(N + 1)]

print(actual(N, M, X, A))


Fixed submission:
def actual(N, M, X, A):
    # マスXの左右それぞれにある料金所の数を調べればOK
    toll_gates_left = [a_i for a_i in A if a_i < X]
    toll_gates_right = [a_i for a_i in A if X < a_i]

    return min(len(toll_gates_left), len(toll_gates_right))

N, M, X = map(int, input().split())
A = list(map(int, input().split()))

print(actual(N, M, X, A))
Buggy python submission (verdict: Runtime Error):
def actual(A, B, C, X):
    count = 0

    for n_500yen in range(A + 1):
        for n_100yen in range(B + 1):
            for n_050yen in range(C + 1):
                amount = 500 * n_500yen + 100 * n_100yen + 50 * n_050yen

                if amount == X:
                    count += 1

    return count

A = int(input())
B = int(input())
C = int(input())
X = int(input())

print(actual(A, B, C, X))


Fixed submission:
def actual(s):
    if set(s) == {'a', 'b', 'c'}:
        return 'Yes'

    return 'No'

s = input()
print(actual(s))
Buggy python submission (verdict: Runtime Error):
def actual(A, B, K):
    min_left = A
    max_left = min(A + (K - 1), B)

    min_right = max(B - (K - 1), max_left + 1)
    max_right = B

    left = set(range(min_left, max_left + 1))
    right = set(range(min_right, max_right + 1))

    unique_nums = left | right

    return '\n'.join(map(str, sorted(unique_nums)))

A, B, K = map(int, input().split())
print(actual_TLE(A, B, K))

Fixed submission:
def actual(A, B, K):
    min_a = A
    max_a = min(A + (K - 1), B)

    min_b = max(B - (K - 1), max_a + 1)
    max_b = B

    left = list(range(min_a, max_a + 1))
    right = list(range(min_b, max_b + 1))

    return '\n'.join(map(str, sorted(set(left + right))))

  
A, B, K = map(int, input().split())
print(actual(A, B, K))
Buggy python submission (verdict: Runtime Error):
def actual(N, D, X, A):
    count = 0

    for a_i in A:
        for i in range(100+1):
            eating_day = 1 + (a_i * i)

            if eating_day <= D:
                count += 1

    return X + count

N = int(input())
D, X = map(int, input().split())
A = [int(input) for _ in range(N)]

print(actual(N, D, X, A))

Fixed submission:
def actual(N, D, X, A):
    count = 0

    for a_i in A:
        for i in range(100+1):
            eating_day = 1 + (a_i * i)

            if eating_day <= D:
                count += 1

    return X + count

N = int(input())
D, X = map(int, input().split())
A = [int(input()) for _ in range(N)]

print(actual(N, D, X, A))
Buggy python submission (verdict: Runtime Error):
def actual(a, b):
    if (a * b) % 2 == 0:
        return 'Even'

    return 'Odd

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

Fixed submission:
a, b = map(int, input().split())

product = a * b

if product % 2 == 1:
    print('Odd')
else:
    print('Even')
Buggy python submission (verdict: Runtime Error):
def actual(a, b, s):
    if s[a] != '-':
        return 'No'

    for i in range(0, a):
        if not '0' <= s[i] <= '9':
            return 'No'

    for j in range(a + 1, len(s) + 1):
        if not '0' <= s[j] <= '9':
            return 'No'

    return 'Yes'


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

print(actual(a, b, s))


Fixed submission:
import re


def actual(a, b, s):
    pattern = r'\d{' + f'{a}' + r'}-\d{' + f'{b}' + '}'
    
    if re.fullmatch(pattern, s):
        return 'Yes'

    return 'No'

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

print(actual(a, b, s))
Buggy python submission (verdict: Time Limit Exceeded):
def actual(N, A):
    count = 0

    while True:
        is_all_even = all([a % 2 == 0 for a in A])

        if is_all_even:
            A = [a // 2 for a in A]
            count += 1
        else:
            break

    return count

N = int(input())
A = map(int, input().split())

print(actual(N, A))

Fixed submission:
def actual(N, A):
    count = 0
    while True:
        is_all_even = all([a % 2 == 0 for a in A])

        if is_all_even:
            A = [a // 2 for a in A]
            count += 1
        else:
            return count

N = int(input())
A = list(map(int, input().split()))

print(actual(N, A))
Buggy python submission (verdict: Runtime Error):
def actual(N, A):
    return max(A) - min(A)

N = int(input())
A = map(int, input().split())

print(actual(N, A))

Fixed submission:
def actual(N, A):
    return max(A) - min(A)

N = int(input())
A = list(map(int, input().split()))

print(actual(N, A))
Buggy python submission (verdict: Time Limit Exceeded):
def actual(K, S):
    count = 0

    for x in range(S + 1):
        for y in range(S + 1):
            z = S - (x + y)

            cond1 = (0 <= x <= K) and (0 <= y <= K) and (0 <= z <= K)
            cond2 = (x + y + z) == S

            if cond1 and cond2:
                count += 1

    return count

K, S = map(int, input().split())
print(actual(K, S))

Fixed submission:
def actual(K, S):
    count = 0

    for x in range(K + 1):
        for y in range(K + 1):
            z = S - (x + y)

            cond1 = (0 <= x <= K) and (0 <= y <= K) and (0 <= z <= K)
            cond2 = (x + y + z) == S

            if cond1 and cond2:
                count += 1

    return count

K, S = map(int, input().split())
print(actual(K, S))
Buggy python submission (verdict: Runtime Error):
def actual(a, b, h):
    return int((a + b) * h / 2)

a, b, h = map(int, input().split())
print(actual(a, b, h))


Fixed submission:
def actual(a, b, h):
    return int((a + b) * h / 2)

a = int(input())
b = int(input())
h = int(input())

print(actual(a, b, h))

Buggy python submission (verdict: Runtime Error):
def actual(a, b, h):
    return int((a + b) * h / 2)

a, b, h = map(int, input())
print(actual(a, b, h))

Fixed submission:
def actual(a, b, h):
    return int((a + b) * h / 2)

a = int(input())
b = int(input())
h = int(input())

print(actual(a, b, h))
Buggy python submission (verdict: Runtime Error):
a=input()
b=a**3+a**2+a
print(b)

Fixed submission:
a = int(input())
b = a ** 3 + a ** 2 + a
print(b)
Buggy python submission (verdict: Runtime Error):
A_V = input().split(" ")
B_W = input().split(" ")
T = int(input())
A = int(A_V[0])
V = int(A_V[1])
B = int(B_W[0])
W = int(B_W[1])
dA = A + V * T
dB = B + W * T
ndA = A - V * T
ndB = B - W * T
if (dA < dB):
    if (ndA > ndB)
        print("NO")
    else:
        print("YES")

Fixed submission:
A_V = input().split(" ")
B_W = input().split(" ")
T = int(input())
A = int(A_V[0])
V = int(A_V[1])
B = int(B_W[0])
W = int(B_W[1])
dA = A + V * T
dB = B + W * T
ndA = A - V * T
ndB = B - W * T
if (A<B):
    if (dA < dB):
        print("NO")
    else:
        print("YES")
else:
    if (ndA > ndB):
        print("NO")
    else:
        print("YES")
Buggy python submission (verdict: Runtime Error):
N = input("")
L = input("").split(" ")
suc = int(N)

for i in range(int(N)):
    for j in range(i):
        if (L[j] < L[i]):
            suc -= 1
            break
    
print(suc)

Fixed submission:
# -*- coding: utf-8 -*-

def fun():
    A = input("")
    return A

N = str(fun()).split(" ")
if (N[0] == N[1]):
    print("Yes")
    
else:
    print("No")
Buggy python submission (verdict: Runtime Error):
N = input("")
L = input("").split(" ")
suc = int(N)
min_ = 200001

for i in range(int(N)):
    if (L[i] == 1):
        continue
    if (min_ < L[i]):
        suc -= 1
        continue
    for j in range(i):
        if (L[j] < L[i]):
            suc -= 1
            break
    
print(suc)

Fixed submission:
N = input("")
L = input("").split(" ")
suc = int(N)
min_ = 200001

for i in range(int(N)):
    if (L[i] == 1):
        min_= 1
        continue
    if (int(min_) < int(L[i])):
        suc -= 1
        continue
    if (int(min_) >= int(L[i])):
        min_ = L[i]
print(suc)

Buggy python submission (verdict: Runtime Error):
# -*- coding: utf-8 -*-

N = input("")
L = input("").split(" ")
suc = N

for i in range(int(N)):
    for j in range(i):
        if (L[j] < L[i]):
            suc -= 1
            break
    
print(suc)

Fixed submission:
N = input("")
L = input("").split(" ")
suc = int(N)
min_ = 200001

for i in range(int(N)):
    if (L[i] == 1):
        min_= 1
        continue
    if (int(min_) < int(L[i])):
        suc -= 1
        continue
    if (int(min_) >= int(L[i])):
        min_ = L[i]
print(suc)