Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Runtime Error):
asd = raw_input()
asdd = asd.split()
n = int(asdd[0])
m = int(asdd[1])
x=(m+1)/(n-1)
print (2*((m+1)*x-x*(n-1)*(x+1)/2)+m+1)%1000000007

Fixed submission:
asd = raw_input()
asdd = asd.split()
n = int(asdd[0])
m = int(asdd[1])
if n == 1:
    print (m+1)%1000000007
    exit(0)

x=(m+1)/(n-1)
print (2*((m+1)*x-x*(n-1)*(x+1)/2)+m+1)%1000000007

Buggy python submission (verdict: Runtime Error):
asd = raw_input()
asdd = asd.split()
n = int(asdd[0])
if n == 1:
    print m+1%1000000007
    exit(0)
m = int(asdd[1])
x=(m+1)/(n-1)
print (2*((m+1)*x-x*(n-1)*(x+1)/2)+m+1)%1000000007

Fixed submission:
asd = raw_input()
asdd = asd.split()
n = int(asdd[0])
m = int(asdd[1])
if n == 1:
    print (m+1)%1000000007
    exit(0)

x=(m+1)/(n-1)
print (2*((m+1)*x-x*(n-1)*(x+1)/2)+m+1)%1000000007
Buggy python submission (verdict: Runtime Error):
print("ai1333"+"3"*"int(input())//100))


Fixed submission:
print("ai1333"+"3"*(int(input())//100))
Buggy python submission (verdict: Runtime Error):
S = int(input())
h = S // 3600
m = S % 3600 // 60
s = S % 60
print({h}":"{m}":"{s})


Fixed submission:
S = int(input())
h = S // 3600
m = S % 3600 // 60
s = S % 60
print(f'{h}:{m}:{s}')

Buggy python submission (verdict: Runtime Error):
S = int(input())
h = S // 3600
m = S % 3600 // 60
s = S % 60
print(h:m:s)


Fixed submission:
S = int(input())
h = S // 3600
m = S % 3600 // 60
s = S % 60
print(f'{h}:{m}:{s}')
Buggy python submission (verdict: Runtime Error):
var = input()
print(var*var*var)


Fixed submission:
var = int(input())
print(var*var*var)

Buggy python submission (verdict: Runtime Error):
var = input()
print(var*var*var)



Fixed submission:
var = int(input())
print(var*var*var)
Buggy python submission (verdict: Runtime Error):
x, y = [int(n) for n in input().split()]
if (x < y):
    x, y = y, x
while b > 0:
    x, y = x, x % y
print(x)



Fixed submission:
x, y = [int(n) for n in input().split()]
if (x < y):
    x, y = y, x
while y:
    (x, y) = (y, x % y)
print(x)
Buggy python submission (verdict: Time Limit Exceeded):
N = int(input())
arr = [int(input()) for i in range(N)]

swap_cnt = 0
i = 0
while True:
    swap_flg = False
    for j in range(N - 1, i + 1, -1):
        if (arr[j] < arr[j - 1]):
            arr[j], arr[j - 1] = arr[j - 1], arr[j]
            swap_cnt += 1
            swap_flg = True
    if (swap_flg):
        break



Fixed submission:
N = int(input())
arr = [int(n) for n in input().split()]

swap_cnt = 0
swap_flg = True
i = 0
while swap_flg:
    swap_flg = False
    for j in range(N - 1, i, -1):
        if (arr[j] < arr[j - 1]):
            arr[j], arr[j - 1] = arr[j - 1], arr[j]
            swap_cnt += 1
            swap_flg = True
    i += 1

print(' '.join(map(str, arr)))
print(swap_cnt)

Buggy python submission (verdict: Runtime Error):
N = int(input())
arr = [int(input()) for i in range(N)]

swap_cnt = 0
i = 0
while True:
    swap_flg = False
    for j in range(N - 1, i + 1, -1):
        if (arr[j] < arr[j - 1]):
            arr[j], arr[j - 1] = arr[j - 1], arr[j]
            swap_cnt += 1
            swap_flg = True
    if (!swap_flg):
        break



Fixed submission:
N = int(input())
arr = [int(n) for n in input().split()]

swap_cnt = 0
swap_flg = True
i = 0
while swap_flg:
    swap_flg = False
    for j in range(N - 1, i, -1):
        if (arr[j] < arr[j - 1]):
            arr[j], arr[j - 1] = arr[j - 1], arr[j]
            swap_cnt += 1
            swap_flg = True
    i += 1

print(' '.join(map(str, arr)))
print(swap_cnt)
Buggy python submission (verdict: Runtime Error):
N = int(input())
arr = [int(n) for n in input().split()]

swap_cnt = 0
for i in range(0, N):
    minj = i
    for j in range(i + 1, N - 1):
        if A[j] < A[minj]
            minj = j
        arr[i], arr[minj] = arr[minj], arr[i]
        swap_cnt += 1 if i != minj else 0

print(' '.join(map(str, arr)))
print(swap_cnt)



Fixed submission:
N = int(input())
arr = [int(n) for n in input().split()]

swap_cnt = 0
for i in range(0, N):
    minj = i
    for j in range(i, N):
        if arr[j] < arr[minj]:
            minj = j
    if (i != minj):
        arr[i], arr[minj] = arr[minj], arr[i]
        swap_cnt += 1

print(' '.join(map(str, arr)))
print(swap_cnt)

Buggy python submission (verdict: Runtime Error):
N = int(input())
arr = [int(n) for n in input().split()]

swap_cnt = 0
minj = 0
for i in range(0, N):
    minj = i
    for j in range(i + 1, N - 1):
        if A[j] < A[minj]
            minj = j
        arr[i], arr[minj] = arr[minj], arr[i]
        swap_cnt += 1 if i != minj else 0

print(' '.join(map(str, arr)))
print(swap_cnt)



Fixed submission:
N = int(input())
arr = [int(n) for n in input().split()]

swap_cnt = 0
for i in range(0, N):
    minj = i
    for j in range(i, N):
        if arr[j] < arr[minj]:
            minj = j
    if (i != minj):
        arr[i], arr[minj] = arr[minj], arr[i]
        swap_cnt += 1

print(' '.join(map(str, arr)))
print(swap_cnt)

Buggy python submission (verdict: Runtime Error):
N = int(input())
arr = [int(n) for n in input().split()]

swap_cnt = 0
for i in range(0, N):
    minj = i
    for j in range(i + 1, N - 1):
        if arr[j] < arr[minj]
            minj = j
        arr[i], arr[minj] = arr[minj], arr[i]
        swap_cnt += 1 if i != minj else 0

print(' '.join(map(str, arr)))
print(swap_cnt)



Fixed submission:
N = int(input())
arr = [int(n) for n in input().split()]

swap_cnt = 0
for i in range(0, N):
    minj = i
    for j in range(i, N):
        if arr[j] < arr[minj]:
            minj = j
    if (i != minj):
        arr[i], arr[minj] = arr[minj], arr[i]
        swap_cnt += 1

print(' '.join(map(str, arr)))
print(swap_cnt)
Buggy python submission (verdict: Runtime Error):
def binarySearch(key, arr, N):
    left = 0
    right = N
    while left < right:
        mid = (left + right) // 2
        if arr[mid] == key:
            return mid
        else if key < arr[mid]:
            right = mid
        else:
            left = mid + 1


N1 = int(input())
arr1 = [int(n) for n in input().split()]
N2 = int(input())
arr2 = [int(n) for n in input().split()]

print(sum([linearSearch(key, arr1) for key in arr2]))



Fixed submission:
def binarySearch(key, arr, N):
    left = 0
    right = N
    while left < right:
        mid = (left + right) // 2
        if arr[mid] == key:
            return 1
        elif key < arr[mid]:
            right = mid
        else:
            left = mid + 1
    return 0


N1 = int(input())
arr1 = [int(n) for n in input().split()]
N2 = int(input())
arr2 = [int(n) for n in input().split()]

print(sum([binarySearch(key, arr1, N1) for key in arr2]))

Buggy python submission (verdict: Runtime Error):
def binarySearch(key, arr, N):
    left = 0
    right = N
    while left < right:
        mid = (left + right) // 2
        if arr[mid] == key:
            return mid
        else if key < arr[mid]:
            right = mid
        else:
            left = mid + 1


N1 = int(input())
arr1 = [int(n) for n in input().split()]
N2 = int(input())
arr2 = [int(n) for n in input().split()]

print(sum([binarySearch(key, arr1, N1) for key in arr2]))



Fixed submission:
def binarySearch(key, arr, N):
    left = 0
    right = N
    while left < right:
        mid = (left + right) // 2
        if arr[mid] == key:
            return 1
        elif key < arr[mid]:
            right = mid
        else:
            left = mid + 1
    return 0


N1 = int(input())
arr1 = [int(n) for n in input().split()]
N2 = int(input())
arr2 = [int(n) for n in input().split()]

print(sum([binarySearch(key, arr1, N1) for key in arr2]))

Buggy python submission (verdict: Runtime Error):
def binarySearch(key, arr, N):
    left = 0
    right = N
    while left < right:
        mid = (left + right) // 2
        if arr[mid] == key:
            return mid
        elif key < arr[mid]:
            right = mid
        else:
            left = mid + 1


N1 = int(input())
arr1 = [int(n) for n in input().split()]
N2 = int(input())
arr2 = [int(n) for n in input().split()]

print(sum([binarySearch(key, arr1, N1) for key in arr2]))



Fixed submission:
def binarySearch(key, arr, N):
    left = 0
    right = N
    while left < right:
        mid = (left + right) // 2
        if arr[mid] == key:
            return 1
        elif key < arr[mid]:
            right = mid
        else:
            left = mid + 1
    return 0


N1 = int(input())
arr1 = [int(n) for n in input().split()]
N2 = int(input())
arr2 = [int(n) for n in input().split()]

print(sum([binarySearch(key, arr1, N1) for key in arr2]))
Buggy python submission (verdict: Runtime Error):
from numba.decorators import jit


Fixed submission:
n = int(input())
a = list(map(int, input().split()))
q = int(input())
m = list(map(int, input().split()))


def memoize(f):
    cache = {}

    def helper(x, y):
        if (x, y) not in cache:
            cache[(x, y)] = f(x, y)
        return cache[(x, y)]
    return helper


def main():
    for number in m:
        if solve(0, number):
            print('yes')
        else:
            print('no')


@memoize
def solve(i, m):
    if m == 0:
        return True

    if i >= n:
        return False

    res = solve(i + 1, m) or solve(i + 1, m - a[i])
    return res


if __name__ == '__main__':
    main()
Buggy python submission (verdict: Time Limit Exceeded):
# -*- coding:utf-8 -*-
import sys


def search(x, y):
    x_length = len(x)
    y_length = len(y)
    memo = [[0] * y_length for i in range(x_length)]
    for i in range(x_length):
        for j in range(y_length):
            if i == 0 or j == 0:
                if x[i] == y[j]:
                    memo[i][j] = 1
                else:
                    memo[i][j] = 0
            elif x[i] == y[j]:
                memo[i][j] = memo[i-1][j-1] + 1
            else:
                memo[i][j] = max(memo[i-1][j], memo[i][j-1])
    return memo[i][j]


if __name__ == "__main__":
    n = int(input())
    strs = [list(val) for val in sys.stdin.read().splitlines()]
    for i in range(n):
        print(search(strs[i*2], strs[i*2+1]))


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


def search(x, y):
    x_length = len(x)
    y_length = len(y)
    memo = [[0] * (y_length + 1) for i in range(x_length + 1)]
    for i, ch_x in enumerate(x, 1):
        row = memo[i]
        pre_row = memo[i-1]
        for j, ch_y in enumerate(y, 1):
            if ch_x == ch_y:
                row[j] = pre_row[j-1] + 1
            elif pre_row[j] < row[j-1]:
                row[j] = row[j-1]
            else:
                row[j] = pre_row[j]
    return memo[-1][-1]


if __name__ == "__main__":
    n = int(input())
    strs = [list(val) for val in sys.stdin.read().splitlines()]
    result = [search(strs[i*2], strs[i*2+1]) for i in range(n)]
    print(*result, sep="\n")

Buggy python submission (verdict: Time Limit Exceeded):
# -*- coding:utf-8 -*-
import sys


def search(x, y):
    x_length = len(x)
    y_length = len(y)
    memo = [[0] * (y_length + 1) for i in range(x_length + 1)]
    for i, ch_x in enumerate(x, 1):
        row = memo[i]
        pre_row = memo[i-1]
        for j, ch_y in enumerate(y, 1):
            if ch_x == ch_y:
                row[j] = pre_row[j-1] + 1
            else:
                row[j] = max(pre_row[j], row[j-1])
    return memo[-1][-1]


if __name__ == "__main__":
    n = int(input())
    strs = [list(val) for val in sys.stdin.read().splitlines()]
    result = [search(strs[i*2], strs[i*2+1]) for i in range(n)]
    print(*result, sep="\n")


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


def search(x, y):
    x_length = len(x)
    y_length = len(y)
    memo = [[0] * (y_length + 1) for i in range(x_length + 1)]
    for i, ch_x in enumerate(x, 1):
        row = memo[i]
        pre_row = memo[i-1]
        for j, ch_y in enumerate(y, 1):
            if ch_x == ch_y:
                row[j] = pre_row[j-1] + 1
            elif pre_row[j] < row[j-1]:
                row[j] = row[j-1]
            else:
                row[j] = pre_row[j]
    return memo[-1][-1]


if __name__ == "__main__":
    n = int(input())
    strs = [list(val) for val in sys.stdin.read().splitlines()]
    result = [search(strs[i*2], strs[i*2+1]) for i in range(n)]
    print(*result, sep="\n")
Buggy python submission (verdict: Time Limit Exceeded):
def insertionSortForShell(lst, n, g):
    cnt = 0
    for i in range(g, n):
        v = lst[i]
        j = i - g
        while j >= 0 and lst[j] > v:
            lst[j+g] = lst[j]
            j = j - g
            cnt += 1
        lst[j+g] = v
    return cnt


def shellSort(lst, n):
    cnt = 0
    G = [1000000, 500000, 100000, 50000, 10000, 5000, 2500, 1000, 600, 400,
         200, 100, 80, 50, 30, 10, 5, 3, 1]
    G2 = []
    for i in range(0, len(G)):
        if G[i] < n:
            tmp = insertionSortForShell(lst, n, G[i])
            if tmp != 0:
                G2.append(G[i])
            cnt += tmp

    if len(G2) == 0:
        print(1)
        print(1)
    else:
        print(len(G2))
        print(" ".join([str(g) for g in G2]))
    print(cnt)
    for n in lst:
        print(n)


if __name__ == "__main__":
    n = int(input())
    lst = []
    for i in range(0, n):
        lst.append(int(input()))
    shellSort(lst, n)

Fixed submission:
def insertionSortForShell(lst, n, g):
    cnt = 0
    for i in range(g, n):
        v = lst[i]
        j = i - g
        while j >= 0 and lst[j] > v:
            lst[j+g] = lst[j]
            j = j - g
            cnt += 1
        lst[j+g] = v
    return cnt


def cleate_split_lst(n):
    lst = []
    while 1:
        n = int(n/2)
        if n <= 1:
                lst.append(1)
                break
        else:
                lst.append(n)
    return lst


def shellSort(lst, n):
    cnt = 0
    G = cleate_split_lst(n)

    for i in range(0, len(G)):
        cnt += insertionSortForShell(lst, n, G[i])

    print(len(G))
    print(" ".join([str(g) for g in G]))
    print(cnt)
    for n in lst:
        print(n)


if __name__ == "__main__":
    n = int(input())
    lst = []
    for i in range(0, n):
        lst.append(int(input()))
    shellSort(lst, n)
Buggy python submission (verdict: Time Limit Exceeded):
# -*- coding:utf-8 -*-
import sys


def binary_search(data, targets, n):
    cnt = 0
    for num in targets:
        small = 0
        big = n - 1
        while 1:
            index = (small + big) >> 1
            if num == data[index]:
                cnt += 1
                break
            if small == big:
                break
            if num < data[index]:
                big = index - 1
            elif num > data[index]:
                small = index + 1

    return cnt


if __name__ == "__main__":
    data = [val.split() for val in sys.stdin.read().splitlines()]
    print(binary_search(data[1], data[3], int(data[0][0])))

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


def binary_search(data, targets, n):
    cnt = 0
    for num in targets:
        small = 0
        big = n - 1
        while small < big:
            index = (small + big) >> 1
            if small < big:
                if num < data[index]:
                    big = index - 1
                if num > data[index]:
                    small = index + 1
                if num == data[index]:
                    cnt += 1
                    break
        if small == big and num == data[small]:
            cnt += 1

    return cnt


if __name__ == "__main__":
    input_data = [val.split() for val in sys.stdin.read().splitlines()]
    n = int(input_data[0][0])
    data = [int(n) for n in input_data[1]]
    targets = [int(n) for n in input_data[3]]
    print(binary_search(data, targets, n))
Buggy python submission (verdict: Time Limit Exceeded):
# -*- coding:utf-8 -*-
import sys


def exhaustive(n, target, lst):
    if n == target:
        return True
    if n > target or lst == []:
        return False
    else:
        for i, val in enumerate(lst, 1):
            if exhaustive(n + val, target, lst[i:]):
                return True
    return False


def main(data, targets):
    for target in targets:
        if exhaustive(0, target, data):
            print("yes")
        else:
            print("no")


if __name__ == "__main__":
    lst = [val.split() for val in sys.stdin.read().splitlines()]
    data = [int(n) for n in lst[1]]
    targets = [int(n) for n in lst[3]]
    main(data, targets)

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


def exhaustive(lst, size):
    result = []
    for i in range(0, 1 << size):
        total = 0
        for j in range(0, size):
            if (i & 0x01) == 1:
                total += lst[j]
            i = i >> 1
        result.append(total)
    return result


if __name__ == "__main__":
    lst = [val.split() for val in sys.stdin.read().splitlines()]
    n, data, m, targets = [[int(n) for n in inner_lst] for inner_lst in lst]
    result = exhaustive(data, int(n[0]))
    print("\n".join(["yes" if x in result else "no" for x in targets]))
Buggy python submission (verdict: Runtime Error):
s = int(input())
h=s // 3600
m = s % 3600 // 60
ss = s % 3600 % 60

print(h:m:ss)

Fixed submission:
s = int(input())


base = s // 60

print('{}:{}:{}'.format(base // 60, base%60, s%60))
Buggy python submission (verdict: Runtime Error):
import math

n = int(input())
r_t = [int(input().strip()) for i in range(n)]

r_i = r_t[0]
r_i_index = 0
diff = -math.inf
for _ in range(1, n):
    r_j = max(r_t[r_i_index+1:])

    tmp_diff = r_j - r_i

    if tmp_diff > diff:
        diff = tmp_diff

    for i in range(r_i_index, n):
        tmp_r_i = r_t[i]
        if tmp_r_i < r_i:
            r_i = tmp_r_i
            r_i_index = r_t.index(r_i)
            break

print(diff)


Fixed submission:
import math

N = int(input())
R = [int(input().strip()) for _ in range(N)]

maxv = -math.inf
minv = R[0]
for i in range(1, N):

    tmp_maxv = R[i] - minv # 差額をセットする
    # 現在の最大差額と差額の大きい方を最大差額にする
    if maxv < tmp_maxv:
        maxv = tmp_maxv

    # 現在値が最小なら、最小値を更新する
    if R[i] < minv:
        minv = R[i]

print(maxv)

Buggy python submission (verdict: Time Limit Exceeded):
import math

n = int(input())
r_t = [int(input().strip()) for i in range(n)]

r_i = r_t[0]
r_i_index = 0
diff = -math.inf
for _ in range(1, n):
    r_j = max(r_t[r_i_index+1:])

    tmp_diff = r_j - r_i

    if tmp_diff > diff:
        diff = tmp_diff

    for i in range(r_i_index, n):
        tmp_r_i = r_t[i]
        if tmp_r_i < r_i:
            r_i = tmp_r_i
            r_i_index = r_t.index(r_i)
            break

    if r_i_index + 1 >= n:
        break

print(diff)


Fixed submission:
import math

N = int(input())
R = [int(input().strip()) for _ in range(N)]

maxv = -math.inf
minv = R[0]
for i in range(1, N):

    tmp_maxv = R[i] - minv # 差額をセットする
    # 現在の最大差額と差額の大きい方を最大差額にする
    if maxv < tmp_maxv:
        maxv = tmp_maxv

    # 現在値が最小なら、最小値を更新する
    if R[i] < minv:
        minv = R[i]

print(maxv)
Buggy python submission (verdict: Time Limit Exceeded):
def fib(n):
    if n == 0 or n == 1:
        return 1
    else :
        return fib(n - 1) + fib(n - 2)

def main():
    print( fib( int( input() ) ) )

if __name__ == '__main__':
    main()



Fixed submission:
class fibNum():
    def __init__(self):
        self.arr = [1, 1]
    def fib(self, n):
        return_num = 1
        if n > 1:
            if len(self.arr) <= n:
                self.arr.append( self.fib(n-1) + self.fib(n-2) )
            return_num = self.arr[n]
        return return_num

def main():
    n = int( input() )
    fn = fibNum()
    print( fn.fib(n) )

if __name__ == '__main__':
    main()

Buggy python submission (verdict: Time Limit Exceeded):
def fib(n):
    if n == 0 or n == 1:
        return 1
    else :
        return fib(n - 1) + fib(n - 2)


print( fib( int( input() ) ) )



Fixed submission:
class fibNum():
    def __init__(self):
        self.arr = [1, 1]
    def fib(self, n):
        return_num = 1
        if n > 1:
            if len(self.arr) <= n:
                self.arr.append( self.fib(n-1) + self.fib(n-2) )
            return_num = self.arr[n]
        return return_num

def main():
    n = int( input() )
    fn = fibNum()
    print( fn.fib(n) )

if __name__ == '__main__':
    main()
Buggy python submission (verdict: Runtime Error):
def main():
    # データ入力
    n, q = input().split()
    n = int( n )
    q = int( q )
    name = []
    time = []
    for i in range(n):
        tmp_n, tmp_t = input().split()
        name.append( tmp_n )
        time.append( int( tmp_t ) )

    # 処理
    count = 0
    while n > 0:
        if time[0] > q:
            time[0] -= q
            count += q
            time.append( time[0] )
            time.pop( 0 )
            name.append( name[0] )
            name.pop( 0 )
        else :
            count += time[0]
            print( name[0], end=" " )
            print( str( count ) )
            time.pop( 0 )
            name.pop( 0 )
            n -= 1

if __name__ == '__main__':
    main()



Fixed submission:
def main():
    A = input().split()
    length = len(A)
    stack = []
    for i in range(length):
        if A[i] == "+":
            stack.insert( 0, stack[1] + stack[0] )
            stack.pop(1)
            stack.pop(1)
        elif A[i] == "-":
            stack.insert( 0, stack[1] - stack[0] )
            stack.pop(1)
            stack.pop(1)
        elif A[i] == "*":
            stack.insert( 0, stack[1] * stack[0] )
            stack.pop(1)
            stack.pop(1)
        else :
            stack.insert( 0, int(A[i]) )
    print( stack[0] )

if __name__ == "__main__":
    main()
Buggy python submission (verdict: Time Limit Exceeded):
dict=[]
n=int(raw_input())
for i in range(n):
	list=raw_input().split()
	if list[0]=='insert':
		dict.append(list[1])
	elif list[0]=='find':
		try:
			dict.index(list[1])
			print 'yes'
		except:
			print 'no'

Fixed submission:
n=int(raw_input())
a={}
for i in range(n):
	inst,key=raw_input().split()
	if inst=='insert': 
		a.update({key:i})
	elif inst=='find': 
		if a.has_key(key)==True:
			 print 'yes'
		else:print 'no'
Buggy python submission (verdict: Runtime Error):
import math
point=list(map(int,input().split()))
print(math.sqrt(pow(point[2]-point[0],2)+pow(point[3]-point[1],2)))

Fixed submission:
import math
point=list(map(float,input().split()))
print(math.sqrt(pow(point[2]-point[0],2)+pow(point[3]-point[1],2)))

Buggy python submission (verdict: Runtime Error):
import math
point=list(map(int,input().split()))
print(math.sqrt(pow(point[2]-point[0],2)+pow(point[3]-point[1],2)))

Fixed submission:
import math
point=list(map(float,input().split()))
print(math.sqrt(pow(point[2]-point[0],2)+pow(point[3]-point[1],2)))

Buggy python submission (verdict: Runtime Error):
import math
point=list(map(int,input().split()))
print(math.sqrt(pow(point[2]-point[0],2)+pow(point[3]-point[1],2)))

Fixed submission:
import math
point=list(map(float,input().split()))
print(math.sqrt(pow(point[2]-point[0],2)+pow(point[3]-point[1],2)))

Buggy python submission (verdict: Runtime Error):
import math
point=list(map(int,input().split()))
print(math.sqrt(pow(point[2]-point[0],2)+pow(point[3]-point[1],2)))

Fixed submission:
import math
point=list(map(float,input().split()))
print(math.sqrt(pow(point[2]-point[0],2)+pow(point[3]-point[1],2)))
Buggy python submission (verdict: Runtime Error):
x,y)=map(int, input().split(" "))
print(x * y, 2 * x + 2* y)

Fixed submission:
x,y=map(int,raw_input().split())
print x*y,2*(x+y)

Buggy python submission (verdict: Runtime Error):
s=int(raw_input())
h=s/3600
m=(s-3600*h)/60
print "%d:%d:%d"%(h,m,s-3600*h-60*m)

Fixed submission:
x,y=map(int,raw_input().split())
print x*y,2*(x+y)
Buggy python submission (verdict: Runtime Error):
h,m,s=int(int,raw_input().split())
print 3600*h+60*m+s

Fixed submission:
s=int(raw_input())
h=s/3600
m=(s-3600*h)/60
print "%d:%d:%d"%(h,m,s-3600*h-60*m)

Buggy python submission (verdict: Runtime Error):
h,m,s=map(int,raw_input().split() )
print 3600*h+60*m+s

Fixed submission:
s=int(raw_input())
h=s/3600
m=(s-3600*h)/60
print "%d:%d:%d"%(h,m,s-3600*h-60*m)
Buggy python submission (verdict: Runtime Error):
a,b=int(raw_input())
if a<b: print 'a < b'
elif a>b: print'a > b'
else: print 'a == b' 

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