Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Runtime Error):
import string
a = 0
b = 0
while True:
    n = input()
    i = 0
    if n != 0:
        while i != n:
            set = raw_input().split()
            set[0] = int(set[0])
            set[1] = int(set[1])

            if set[0] == set[1]:
                a += set[0]
                b += set[1]

            elif set[0] > set[1]:
                a += ( set[0] + set[1] )
            else:
                b += ( set[0] + set[1] )

            i += 1

        print a,b
    else:
        n=0

Fixed submission:
printlist = []
while True:
    n = input()
    if n == 0:
        break
    a = 0
    b = 0
    i = 0
    if n != 0:
        while i != n:
            set = raw_input().split()
            set[0] = int(set[0])
            set[1] = int(set[1])

            if set[0] == set[1]:
                a += set[0]
                b += set[1]

            elif set[0] > set[1]:
                a += ( set[0] + set[1] )
            else:
                b += ( set[0] + set[1] )

            i += 1

        printlist.append(a)
        printlist.append(b)
    else:
        break

#print 'hoge'
p = len(printlist)
i = 0
while i != p:
    print printlist[i],printlist[i+1]
    i += 2

Buggy python submission (verdict: Runtime Error):
a = 0
b = 0
while True:
    n = input()
    i = 0
    if n != 0:
        while i != n:
            set = raw_input().split()
            set[0] = int(set[0])
            set[1] = int(set[1])

            if set[0] == set[1]:
                a += set[0]
                b += set[1]

            elif set[0] > set[1]:
                a += ( set[0] + set[1] )
            else:
                b += ( set[0] + set[1] )

            i += 1

        print a,b
    else:
        n=0

Fixed submission:
printlist = []
while True:
    n = input()
    if n == 0:
        break
    a = 0
    b = 0
    i = 0
    if n != 0:
        while i != n:
            set = raw_input().split()
            set[0] = int(set[0])
            set[1] = int(set[1])

            if set[0] == set[1]:
                a += set[0]
                b += set[1]

            elif set[0] > set[1]:
                a += ( set[0] + set[1] )
            else:
                b += ( set[0] + set[1] )

            i += 1

        printlist.append(a)
        printlist.append(b)
    else:
        break

#print 'hoge'
p = len(printlist)
i = 0
while i != p:
    print printlist[i],printlist[i+1]
    i += 2
Buggy python submission (verdict: Runtime Error):
from math import sqrt
x1,y1,x2,y2= map(int,raw_input().split())
print '%.8f' % sqrt((y2-y1)**2+(x2-x1)**2)

Fixed submission:
from math import sqrt
x1,y1,x2,y2= map(float,raw_input().split())
print '%.8f' % sqrt((y2-y1)**2+(x2-x1)**2)

Buggy python submission (verdict: Runtime Error):
from math import sqrt
x1,y1,x2,y2= map(int,raw_input().split())
print sqrt((y2-y1)**2+(x2-x1)**2)

Fixed submission:
from math import sqrt
x1,y1,x2,y2= map(float,raw_input().split())
print '%.8f' % sqrt((y2-y1)**2+(x2-x1)**2)

Buggy python submission (verdict: Runtime Error):
import math
x1,y1,x2,y2= map(int,raw_input().split())
print math.sqrt((y2-y1)**2+(x2-x1)**2)

Fixed submission:
from math import sqrt
x1,y1,x2,y2= map(float,raw_input().split())
print '%.8f' % sqrt((y2-y1)**2+(x2-x1)**2)
Buggy python submission (verdict: Runtime Error):
from collections import deque

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

q = deque()

for _ in range(N):
	c = int(input())
	
	if len(q) == M:
		q.popleft()
	
	q.append(c)
	
for _ in reversed(q):
	print(_)

Fixed submission:
N, M = map(int, raw_input().split(' '))

q = [ int(input()) for _ in range(N) ]
poll = set()

cnt = 0

for _ in reversed(q):
	if not _ in poll:
		print(_)
		
		cnt = cnt + 1
		
		if cnt == M:
			break	
		
		poll.add(_)

Buggy python submission (verdict: Runtime Error):
N, M = map(int, input().split(' '))

q = []	

for _ in range(N):
	c = int(input())
	
	if c in q:
		q.remove(c)
		q.append(c)
	else:	
		if len(q) == M:
			q.pop(0)
	
		q.append(c)
	
for _ in reversed(q):
	print(_)

Fixed submission:
N, M = map(int, raw_input().split(' '))

q = [ int(input()) for _ in range(N) ]
poll = set()

cnt = 0

for _ in reversed(q):
	if not _ in poll:
		print(_)
		
		cnt = cnt + 1
		
		if cnt == M:
			break	
		
		poll.add(_)

Buggy python submission (verdict: Runtime Error):
N, M = map(int, raw_input().split(' '))

q = []	

for _ in range(N):
	c = int(input())
	
	if c in q:
		q.remove(c)
		q.append(c)
	else:	
		if len(q) == M:
			q.pop(0)
	
		q.append(c)
	
for _ in reversed(q):
	print(_)

Fixed submission:
N, M = map(int, raw_input().split(' '))

q = [ int(input()) for _ in range(N) ]
poll = set()

cnt = 0

for _ in reversed(q):
	if not _ in poll:
		print(_)
		
		cnt = cnt + 1
		
		if cnt == M:
			break	
		
		poll.add(_)

Buggy python submission (verdict: Runtime Error):
N, M = map(int, input().split(' '))

q = [ int(input()) for _ in range(N) ]
poll = []

cnt = 0

for _ in reversed(q):
	if not _ in poll:
		print(_)
		
		cnt = cnt + 1
		
		if cnt == M:
			break	
		
		poll.append(_)
		

Fixed submission:
N, M = map(int, raw_input().split(' '))

q = [ int(input()) for _ in range(N) ]
poll = set()

cnt = 0

for _ in reversed(q):
	if not _ in poll:
		print(_)
		
		cnt = cnt + 1
		
		if cnt == M:
			break	
		
		poll.add(_)

Buggy python submission (verdict: Runtime Error):
N, M = map(int, raw_input().split(' '))

q = [ int(input()) for _ in range(N) ]
poll = []

cnt = 0

for _ in reversed(q):
	if not _ in poll:
		print(_)
		
		cnt = cnt + 1
		
		if cnt == M:
			break	
		
		poll.append(_)
		

Fixed submission:
N, M = map(int, raw_input().split(' '))

q = [ int(input()) for _ in range(N) ]
poll = set()

cnt = 0

for _ in reversed(q):
	if not _ in poll:
		print(_)
		
		cnt = cnt + 1
		
		if cnt == M:
			break	
		
		poll.add(_)

Buggy python submission (verdict: Runtime Error):
N, M = map(int, raw_input().split(' '))

q = [ int(input()) for _ in range(N) ]
poll = set()

cnt = 0

for _ in reversed(q):
	if not _ in poll:
		print(_)
		
		cnt = cnt + 1
		
		if cnt == M:
			break	
		
		poll.append(_)
		

Fixed submission:
N, M = map(int, raw_input().split(' '))

q = [ int(input()) for _ in range(N) ]
poll = set()

cnt = 0

for _ in reversed(q):
	if not _ in poll:
		print(_)
		
		cnt = cnt + 1
		
		if cnt == M:
			break	
		
		poll.add(_)
Buggy python submission (verdict: Runtime Error):
import sys
import math
r = int(sys.stdin.readline())

print "%.6f, %.6f"%(math.pi*r*r, 2*math.pi*r)

Fixed submission:
import sys
import math
r = float(sys.stdin.readline())
  
print "%.6f %.6f"%(math.pi*r*r, 2*math.pi*r)
Buggy python submission (verdict: Runtime Error):
import sys
a, b = sys.stdin.readline().split()
a = int(a)
b = int(b)
if a > b:
  print "a>b"
elif a < b:
  print "a<b"
else
  print "a==b"

Fixed submission:
import sys
a, b = sys.stdin.readline().split()
a = int(a)
b = int(b)
if a > b:
  print "a > b"
elif a < b:
  print "a < b"
else:
  print "a == b"
Buggy python submission (verdict: Runtime Error):
import sys
xs = [int(x) for x in  sys.stdin.readline()]
sort(xs)
for x in xs:
  print x,

Fixed submission:
import sys
xs = [int(x) for x in  sys.stdin.readline().split()]
for x in sorted(xs):
  print x,

Buggy python submission (verdict: Runtime Error):
import sys
xs = [int(x) for x in  sys.stdin.readline().split()]
sort(xs)
for x in xs:
  print x,

Fixed submission:
import sys
xs = [int(x) for x in  sys.stdin.readline().split()]
for x in sorted(xs):
  print x,
Buggy python submission (verdict: Runtime Error):
impor sys
ans = 1
count = 1
while ans:
  ans = int(sys.stdin.readline())
  if ans:
    print "Case %d: %d"(count, ans)
    count += 1

Fixed submission:
import sys
ans = 1
count = 1
while ans:
  ans = int(sys.stdin.readline())
  if ans:
    print "Case %d: %d"%(count, ans)
    count += 1

Buggy python submission (verdict: Runtime Error):
import sys
ans = 1
count = 1
while ans:
  ans = int(sys.stdin.readline())
  if ans:
    print "Case %d: %d"(count, ans)
    count += 1

Fixed submission:
import sys
ans = 1
count = 1
while ans:
  ans = int(sys.stdin.readline())
  if ans:
    print "Case %d: %d"%(count, ans)
    count += 1
Buggy python submission (verdict: Runtime Error):
import sys
sys.stdin.readline()
xs = [int(x) for x in sys.stdin.readline()]
for x in reversed(xs):
  print x,

Fixed submission:
import sys
sys.stdin.readline()
xs = [int(x) for x in sys.stdin.readline().split()]
for x in reversed(xs):
  print x,
Buggy python submission (verdict: Runtime Error):
#!/usr/bin/env python

def q_sort(a):
        if len(a)==1:
                return a
        pivot  = a[len(a)/2]
        return q_sort([i for i in a if i < pivot ]) + [pivot] + q_sort([i for i in a if pivot < i])



n = int( raw_input() )
array =  [ int(i) for i in raw_input().split(" ") ]
for i in q_sort(array):
        print "%d"%i,
print "\n",

Fixed submission:
#!/usr/bin/env python

import random



def get_2nd(a,b,c):
        l = [a,b,c]
        l.sort()
        return l[1]

def q_sort(a):
        if a==[]:
                return []
        l = len(a)
        pivot = get_2nd(a[0],a[l/2],a[l-1])
        return q_sort([i for i in a if i < pivot ]) + [i for i in a if i == pivot ] + q_sort([i for i in a if pivot < i])



n = int( raw_input() )
array =  [ int(i) for i in raw_input().split(" ") ]
random.shuffle(array)
for i in q_sort(array):
        print i,

Buggy python submission (verdict: Runtime Error):
#!/usr/bin/env python

def q_sort(a):
        if len(a)==1:
                return a
        pivot  = a[len(a)/2]
        return q_sort([i for i in a if i < pivot ]) + [pivot] + q_sort([i for i in a if pivot < i])



n = int( raw_input() )
array =  [ int(i) for i in raw_input().split(" ") ]
for i in q_sort(array):
        print i,

Fixed submission:
#!/usr/bin/env python

import random



def get_2nd(a,b,c):
        l = [a,b,c]
        l.sort()
        return l[1]

def q_sort(a):
        if a==[]:
                return []
        l = len(a)
        pivot = get_2nd(a[0],a[l/2],a[l-1])
        return q_sort([i for i in a if i < pivot ]) + [i for i in a if i == pivot ] + q_sort([i for i in a if pivot < i])



n = int( raw_input() )
array =  [ int(i) for i in raw_input().split(" ") ]
random.shuffle(array)
for i in q_sort(array):
        print i,
Buggy python submission (verdict: Time Limit Exceeded):
import sys

inf = sys.maxsize

# 入力:graphと始点s
# 出力:始点sから各頂点tへの距離dist
def shortestPath(graph, s):
    n = len(graph)

    dist    = [inf for _ in range(n)]
    visited = [False for _ in range(n)]
    dist[s] = 0

    while True:
        idx, u  = -1, inf
        for i in range(n):
            if not visited[i] and dist[i] < u:
                idx = i
                u = dist[i]
        
        if u == inf: break
        
        visited[idx] = True

        for (next, w) in graph[idx]:
            newdist = w + dist[idx]
            if newdist < dist[next]:
                dist[next] = newdist
    return dist

def main():
    v, e, s = map(int, input().split())
    
    # 隣接リスト
    graph = [[] for _ in range(v)]
    
    for i in range(e):
        a, b, cost = map(int, input().split())
        graph[a].append((b, cost))
            
    c_dist = shortestPath(graph, s)
            
    for d in c_dist:
        if d == inf:
            print("INF")
        else:
            print(d)
main()

Fixed submission:
import sys
import heapq as h

inf = sys.maxsize

class heapq:
    def __init__(self):
        self.q = []

    def push(self,v):
        h.heappush(self.q, v)
    
    def pop(self):
        return h.heappop(self.q)

    def is_empty(self):
        return len(self.q) == 0

# 入力:graphと始点s
# 出力:始点sから各頂点tへの距離dist
def shortestPath0(graph, s):
    n = len(graph)

    dist    = [inf for _ in range(n)]
    visited = [False for _ in range(n)]
    dist[s] = 0

    while True:
        idx, u  = -1, inf
        for i in range(n):
            if not visited[i] and dist[i] < u:
                idx = i
                u = dist[i]
        
        if u == inf: break
        
        visited[idx] = True

        for (next, w) in graph[idx]:
            newdist = w + dist[idx]
            if newdist < dist[next]:
                dist[next] = newdist
    return dist

def shortestPath1(graph, s):
    n = len(graph)

    dist    = [inf for _ in range(n)]
    visited = [False for _ in range(n)]
    
    q = heapq()
    q.push((0, s))

    while not q.is_empty():
        (cur_dist, v) = q.pop()

        if visited[v] or dist[v] <= cur_dist:
            continue

        dist[v] = cur_dist
        visited[v] = True

        for next, w in graph[v]:
            if not visited[next] and dist[v] + w < dist[next]:
                q.push((dist[v] + w, next))

    return dist

def main():
    v, e, s = map(int, input().split())
    
    # 隣接リスト
    graph = [[] for _ in range(v)]
    
    for i in range(e):
        a, b, cost = map(int, input().split())
        graph[a].append((b, cost))
            
    c_dist = shortestPath1(graph, s)
            
    for d in c_dist:
        if d == inf:
            print("INF")
        else:
            print(d)
main()
Buggy python submission (verdict: Runtime Error):
import sys

def shortestPath(graph, s):
    n = len(graph)
    dist = [inf for _ in range(n)]
    dist[s] = 0

    for i in range(n):
        for u in range(n):
            for v, cost in graph[u]:
                newDist = dist[u] + cost
                if dist[u] != inf and newDist < dist[v]:
                    if i == n - 1:
                        return None
                    dist[v] = newDist
    return dist

def main():
    v, e, s = map(int, input().split())
    
    graph = [[] for _ in range(v)]
    
    for i in range(e):
        a, b, cost = map(int, input().split())
        graph[a].append((b, cost))
            
    dist = shortestPath(graph, s)

    if not dist:
        print("NEGATIVE CYCLE")
    else:
        for d in dist:
            if d >= inf:
                print("INF")
            else:
                print(d)
main()

Fixed submission:
import sys

inf = int(1e12)

def shortestPath(graph, s):
    n = len(graph)
    dist = [inf for _ in range(n)]
    dist[s] = 0

    for i in range(n):
        for u in range(n):
            for v, cost in graph[u]:
                newDist = dist[u] + cost
                if dist[u] != inf and newDist < dist[v]:
                    if i == n - 1:
                        return None
                    dist[v] = newDist
    return dist

def main():
    v, e, s = map(int, input().split())
    
    graph = [[] for _ in range(v)]
    
    for i in range(e):
        a, b, cost = map(int, input().split())
        graph[a].append((b, cost))
            
    dist = shortestPath(graph, s)

    if not dist:
        print("NEGATIVE CYCLE")
    else:
        for d in dist:
            if d >= inf:
                print("INF")
            else:
                print(d)
main()
Buggy python submission (verdict: Runtime Error):
base = raw_input()


def toggleUpLo(char):
    if char.isupper():
        return char.lower()
    else:
        return char.upper()

new_str = [toggleUpLo(c) for c in base]
print(''.join(new_str)

Fixed submission:
base = raw_input()


def toggleUpLo(char):
    if char.isupper():
        return char.lower()
    else:
        return char.upper()

new_str = [toggleUpLo(c) for c in base]
print(''.join(new_str))
Buggy python submission (verdict: Runtime Error):
import sys

##Fill alpha array
alpha = [0] * (ord('z') - ord('a') + 1)

for line in sys.stdin:
    line_char = filter(
        map(lambda c: c.lower(),
            (lambda c: c.isalpha(), list(line))))
    for c in line_char:
        alpha[ord(c) - ord('a')] += 1

for idx in range(len(alpha)):
    print chr(idx + ord('a')), '=', alpha[idx]

Fixed submission:
import sys

##Fill alpha array
alpha = [0] * (ord('z') - ord('a') + 1)

for line in sys.stdin:
    line_char = map(lambda c: c.lower(),
                    filter(lambda c: c.isalpha(), list(line)))
    for c in line_char:
        alpha[ord(c) - ord('a')] += 1

for idx in range(len(alpha)):
    print chr(idx + ord('a')), ':', alpha[idx]

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

x1, y1, x2, y2 = [int(n) for n in raw_input().split()]
print(math.sqrt(abs(x2 - x1) ** 2 + abs(y2 - y1) ** 2))

Fixed submission:
import math

x1, y1, x2, y2 = [float(n) for n in raw_input().split()]
print math.sqrt(abs(x2 - x1) ** 2 + abs(y2 - y1) ** 2)

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

x1, y1, x2, y2 = [int(n) for n in raw_input().split()]
print math.sqrt(abs(x2 - x1) ** 2 + abs(y2 - y1) ** 2)

Fixed submission:
import math

x1, y1, x2, y2 = [float(n) for n in raw_input().split()]
print math.sqrt(abs(x2 - x1) ** 2 + abs(y2 - y1) ** 2)
Buggy python submission (verdict: Runtime Error):
a, b = map(int, raw_input().split())

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"

elif a == b:
    print "a == b"
Buggy python submission (verdict: Runtime Error):
n = int(input())
a = list(map(int,input()(split()))
for i in range(1,n):
    if a[i] > 0:
        a[i] += a[i-1]
print(max(a[i])+1)


Fixed submission:
n = int(input())
a = list(map(int,input().split()))
for i in range(1,n):
    if a[i] > 0:
        a[i] += a[i-1]
print(max(a)+1)

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


Fixed submission:
n = int(input())
a = list(map(int,input().split()))
for i in range(1,n):
    if a[i] > 0:
        a[i] += a[i-1]
print(max(a)+1)
Buggy python submission (verdict: Runtime Error):
import math
import sys


def main():
	tate = int(raw_input())
	result = []
	for i in range(1, tate+1):
		result.append(i)

	print result

	yoko = int(raw_input())

	for line in sys.stdin.readlines():
		x1, x2 = map(int, line.split(","))
		x1 -= 1
		x2 -= 1
		temp = result[x2]
		result[x2] = result[x1]
		result[x1] = temp

	for num in result:
		print num
	


if __name__ == '__main__':
	main()
import math
import sys


def main():
	tate = int(raw_input())
	result = []
	for i in range(1, tate+1):
		result.append(i)

	print result

	yoko = int(raw_input())

	for line in sys.stdin.readlines():
		x1, x2 = map(int, line.split(","))
		x1 -= 1
		x2 -= 1
		temp = result[x2]
		result[x2] = result[x1]
		result[x1] = temp

	for num in result:
		print num
	


if __name__ == '__main__':
	main()

Fixed submission:
import sys

def main():
	tate = int(raw_input())
	result = []
	for i in range(1, tate+1):
		result.append(i)

	yoko = int(raw_input())

	for line in sys.stdin.readlines():
		x1, x2 = map(int, line.split(","))
		x1 -= 1
		x2 -= 1
		temp = result[x2]
		result[x2] = result[x1]
		result[x1] = temp

	for num in result:
		print num
	


if __name__ == '__main__':
	main()
Buggy python submission (verdict: Runtime Error):
n = int(raw_input())
S = map(int, raw_input().split(" "))
q = int(raw_input())
T = map(int, raw_input().split(" "))

count = 0
for n in S:
	for j in T:
		if n == j:
			count += 1

print count 

Fixed submission:
# import sys

n = int(raw_input())
S = map(int, raw_input().strip(" ").split(" "))
q = int(raw_input())
T = map(int, raw_input().strip(" ").split(" "))

count = 0
for j in T:
	for n in S:
		if n == j:
			count += 1
			break

print count

Buggy python submission (verdict: Runtime Error):


n = int(raw_input())
S = map(int, raw_input().split(" ").strip(" "))
q = int(raw_input())
T = map(int, raw_input().split(" ").strip(" "))

count = 0
for n in S:
	for j in T:
		if n == j:
			count += 1

print count 

Fixed submission:
# import sys

n = int(raw_input())
S = map(int, raw_input().strip(" ").split(" "))
q = int(raw_input())
T = map(int, raw_input().strip(" ").split(" "))

count = 0
for j in T:
	for n in S:
		if n == j:
			count += 1
			break

print count
Buggy python submission (verdict: Time Limit Exceeded):
INF = 1000000000
class Edge:
	def __init__(self, to, cost):
		self.to = to
		self.cost = cost


def dijkstra(graph, start):
	V = len(graph)
	d = [INF for _ in xrange(V)]
	d[start] = 0

	done = [False for _ in xrange(V)]
	while True:
		mini = INF
		min_i = -1
		for i, node in enumerate(graph):
			if done[i] == False:
				if d[i] < mini:
					min_i = i
					mini = d[i]			
		if min_i == -1:
			return d
			
		done[min_i] = True
			
		node = graph[min_i]
		for edge in node:
			if d[min_i] + edge.cost < d[edge.to]:
				d[edge.to] = d[min_i] + edge.cost

def main():
	V, E, r = map(int, raw_input().split())

	graph = [[] for _ in xrange(V)]
	for i in xrange(E):
		_s, _t, _c = map(int, raw_input().split())
		graph[_s].append(Edge(_t, _c))


	distance = dijkstra(graph, r)
	for d in distance:
		if d == INF:
			print "INF"
		else:
			print d




if __name__ == '__main__':
	main()

Fixed submission:
import heapq

INF = 1000000000
class Edge:
	def __init__(self, to, cost):
		self.to = to
		self.cost = cost


def dijkstra(graph, start):
	V = len(graph)
	d = [INF for _ in xrange(V)]
	d[start] = 0

	pq = []
	heapq.heappush(pq, (d[start], start))

	while len(pq) != 0:
		done = heapq.heappop(pq)
		node = graph[done[1]]
		for edge in node:
			if done[0] + edge.cost < d[edge.to]:
				d[edge.to] = done[0]+ edge.cost
				heapq.heappush(pq, (d[edge.to], edge.to))

	return d

def main():
	V, E, r = map(int, raw_input().split())

	graph = [[] for _ in xrange(V)]
	for i in xrange(E):
		_s, _t, _c = map(int, raw_input().split())
		graph[_s].append(Edge(_t, _c))


	distance = dijkstra(graph, r)
	for d in distance:
		if d == INF:
			print "INF"
		else:
			print d




if __name__ == '__main__':
	main()
Buggy python submission (verdict: Runtime Error):
or i in range(1,10):
    for r in range(1,10):
        print "%s*%s=%s" % (i,r,i*r)

Fixed submission:
for i in range(1,10):
    for r in range(1,10):
        print "%sx%s=%s" % (i,r,i*r)
Buggy python submission (verdict: Runtime Error):
list=[]
for i in range(10):
   list.append(input())
list.sort(reverse=true)
for i in range(3):
   print list[i]   

Fixed submission:
list=[]
for i in range(10):
   list.append(input())
list.sort(reverse=True)
for i in range(3):
   print list[i]
Buggy python submission (verdict: Runtime Error):
a=input()
b=input()
print a*b
print a*2+b*2

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

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

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

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

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

Buggy python submission (verdict: Runtime Error):
a,b=input().split(" ")
print a*b,a*2+b*2

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

Buggy python submission (verdict: Runtime Error):
a,b=map(int,input().split())
print a*b,a*2+b*2

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

Buggy python submission (verdict: Runtime Error):
a,b=map(int,input().split())
print a*b,a*2+b*2

Fixed submission:
a,b=map(int,raw_input().split())
print a*b,a*2+b*2
Buggy python submission (verdict: Runtime Error):
i=0
while i<1000:
   print "Hello World"
   i++ 

Fixed submission:
i=0
while i<1000:
   print "Hello World"
   i+=1