Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Runtime Error):
s = a * b
print s

Fixed submission:
l = map(int, raw_input().split())
print l[0] * l[1], 2 * (l[0] + l[1])

Buggy python submission (verdict: Runtime Error):
a = raw_input()
b = raw_input()
a = int(a)
b = int(b)
s = a * b
print s

Fixed submission:
l = map(int, raw_input().split())
print l[0] * l[1], 2 * (l[0] + l[1])

Buggy python submission (verdict: Runtime Error):
a = raw_input()
b = raw_input()
a = int(a)
b = int(b)
s = a * b
print s

Fixed submission:
l = map(int, raw_input().split())
print l[0] * l[1], 2 * (l[0] + l[1])

Buggy python submission (verdict: Runtime Error):
a = raw_input();b = raw_input()
a = int(a);b = int(b)
s = a * b
print s

Fixed submission:
l = map(int, raw_input().split())
print l[0] * l[1], 2 * (l[0] + l[1])

Buggy python submission (verdict: Runtime Error):
l = raw_input().split()
s = l[0] * l[1]
y = (l[0] + l[1]) * 2
print s y

Fixed submission:
l = map(int, raw_input().split())
print l[0] * l[1], 2 * (l[0] + l[1])

Buggy python submission (verdict: Runtime Error):
l = raw_input().split()
s = l[0] * l[1]
y = (l[0] + l[1]) * 2
print s

Fixed submission:
l = map(int, raw_input().split())
print l[0] * l[1], 2 * (l[0] + l[1])

Buggy python submission (verdict: Runtime Error):
l = raw_input().split()
s = l[0] * l[1]
y = (l[0] + l[1]) * 2
print s,
print " "y

Fixed submission:
l = map(int, raw_input().split())
print l[0] * l[1], 2 * (l[0] + l[1])
Buggy python submission (verdict: Runtime Error):
#include<cstdio>
using namespace std;
 
int main(){
int a,b,c;
scanf("%d %d %d",&a,&b,&c);
if((a<b)&&(b<c))puts("Yes");
else puts("No");
return 0;
 
}

Fixed submission:
a,b,c=map(int,raw_input().split())
if a<b<c:
    print "Yes"
else :
    print "No"

Buggy python submission (verdict: Runtime Error):
#include<cstdio>
using namespace std;
 
int main(){
int a,b,c;
scanf("%d %d %d",&a,&b,&c);
if((a<b)&&(b<c))puts("Yes");
else puts("No");
return 0;
 
 
}

Fixed submission:
a,b,c=map(int,raw_input().split())
if a<b<c:
    print "Yes"
else :
    print "No"
Buggy python submission (verdict: Runtime Error):
a = gets.to_i
for num in 1..a
    if num.to_s =~ /3/ || num % 3 == 0
        print " #{num}"
    end
end
puts

Fixed submission:
n=input()
print "",
for i in xrange(1,n+1):
    if i%3==0 or '3' in str(i):
        print i,
Buggy python submission (verdict: Runtime Error):
import sys

d_num = int(sys.stdin.readline().strip())

graph_list = []

for _ in range(0, d_num):
    array = sys.stdin.readline().strip().split(" ")
    if len(array) > 2:
        graph_list.append([])
    else:
        graph_list.append([int(array[i]) for i in range(2, len(array))])

t = 1
result = [[] for _ in range(0, d_num)]
searched_list = []
stack = []

stack.append(0)
while sorted(searched_list) != range(0, d_num):
    if len(stack) == 0:
        stack.append(filter(lambda x: x not in searched_list, range(0, d_num))[0])
    node = stack[-1]
    searched_list.append(node)
    children = filter(lambda x: x not in searched_list, graph_list[node])
    if len(child) == 0:
        next_node = children[0]
        result[next_node].append(t)
    else:
        stack.pop()
        result[node].append(t)
    t += 1

s = ""

for i in range(0, len(result)):
    print str(i+1) + " " + str(result[i][0] + 1) + " " + str(result[i][1] + 1)
    

Fixed submission:
import sys

d_num = int(sys.stdin.readline().strip())

graph_list = []

for _ in range(0, d_num):
    array = sys.stdin.readline().strip().split(" ")
    if len(array) <= 2:
        graph_list.append([])
    else:
        graph_list.append([int(array[i]) - 1 for i in range(2, len(array))])

t = 1
result = [[] for _ in range(0, d_num)]
searched_list = []
stack = []

while True:
    if len(stack) == 0:
        ll = filter(lambda x: x not in searched_list, range(0, d_num))
        if len(ll) == 0:
            break
        stack.append(ll[0])
        result[ll[0]].append(t)
        searched_list.append(ll[0])
    else:
        node = stack[-1]
        children = filter(lambda x: x not in searched_list, graph_list[node])
        if len(children) != 0:
            next_node = children[0]
            stack.append(next_node)
            result[next_node].append(t)
            searched_list.append(next_node)
        else:
            stack.pop()
            result[node].append(t)
    t += 1

s = ""

for i in range(0, len(result)):
    print str(i+1) + " " + str(result[i][0]) + " " + str(result[i][1])
Buggy python submission (verdict: Runtime Error):
import sys

n = int(sys.stin.readline().strip())

dist = {}

for i in xrange(0, n):
    array = map(int, sys.stdin.readline().strip().split(" "))
    for (j, d) in enumerate(array):
        dist[(i, j)] = d

searched = []
length = 0

target = 0

while len(searched) != n:
    searched.append(target)
    min_len = 2001
    for v in searched:
        for i in xrange(0, n):
            if (i not in searched) and (min_len > dist[(v, i)]) and (dist[(v, i)] != -1):
                min_len = dist[(v, i)]
                target = i
    length += min_len

print str(length)
                

Fixed submission:
import sys

n = int(sys.stdin.readline().strip())

dist = {}

for i in xrange(0, n):
    array = map(int, sys.stdin.readline().strip().split(" "))
    for (j, d) in enumerate(array):
        dist[(i, j)] = d

searched = []
length = 0

target = 0

while len(searched) != n:
    searched.append(target)
    min_len = 2001
    for v in searched:
        for i in xrange(0, n):
            if (i not in searched) and (min_len > dist[(v, i)]) and (dist[(v, i)] != -1):
                min_len = dist[(v, i)]
                target = i
    if min_len != 2001:
        length += min_len

print str(length)
Buggy python submission (verdict: Runtime Error):
import sys

stack = []

array = sys,stdin.readline().strip().split(" ")

for op in array:
    if op.isdigit():
        stack.append(int(op))
    else:
        tmp1 = stack.pop()
        tmp2 = stack.pop()
        if op == "+":
            stack.append(tmp1 + tmp2)
        elif op == "-":
            stack.append(tmp2 - tmp1)
        elif op == "*":
            stack.append(tmp1 * tmp2)
        elif op == "/":
            stack.append(float(tmp2) / tmp1)
res = stack.pop()
print str(int(res))

Fixed submission:
import sys

stack = []

array = sys.stdin.readline().strip().split(" ")

for op in array:
    if op.isdigit():
        stack.append(int(op))
    else:
        tmp1 = stack.pop()
        tmp2 = stack.pop()
        if op == "+":
            stack.append(tmp1 + tmp2)
        elif op == "-":
            stack.append(tmp2 - tmp1)
        elif op == "*":
            stack.append(tmp1 * tmp2)
        elif op == "/":
            stack.append(float(tmp2) / tmp1)
res = stack.pop()
print str(int(res))

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

stack = []

array = sys,stdin.readline().strip().split(" ")

for op in array:
    if op.isdigit():
        stack.append(int(op))
    else:
        tmp1 = stack.pop()
        tmp2 = stack.pop()
        if op == "+":
            stack.append(tmp1 + tmp2)
        elif op == "-":
            stack.append(tmp2 - tmp1)
        elif op == "*":
            stack.append(tmp1 * tmp2)
        elif op == "/":
            stack.append(float(tmp2) / tmp1)
res = stack.pop()
print str(int(res))

Fixed submission:
import sys

stack = []

array = sys.stdin.readline().strip().split(" ")

for op in array:
    if op.isdigit():
        stack.append(int(op))
    else:
        tmp1 = stack.pop()
        tmp2 = stack.pop()
        if op == "+":
            stack.append(tmp1 + tmp2)
        elif op == "-":
            stack.append(tmp2 - tmp1)
        elif op == "*":
            stack.append(tmp1 * tmp2)
        elif op == "/":
            stack.append(float(tmp2) / tmp1)
res = stack.pop()
print str(int(res))
Buggy python submission (verdict: Runtime Error):
import Queue
import sys

class Proc:
    def __init__(self, name, time):
        self.time = time
        self.name = name

def main():
    array = map(lambda x: int(x), sys.stdin.readline().strip().split(" "))
    p_num = array[0]
    q_time = array[1]
    p_queue = Queue.Queue()
    for i in range(0, p_num):
        array = sys.readline().strip().split()
        p_queue.put(Proc(array[0], int(array[1])))
    t = 0
    while not p_queue.empty():
        p = p_queue.get()
        if p.time > q_time:
            p.time = p.time - q_time
            p_queue.put(p)
            t += q_time
        else:
            t += p.time
            print p.name + " " + str(t)
    
if __name__ == "__main__":
    main()

Fixed submission:
import Queue
import sys

class Proc:
    def __init__(self, name, time):
        self.time = time
        self.name = name

def main():
    array = map(lambda x: int(x), sys.stdin.readline().strip().split(" "))
    p_num = array[0]
    q_time = array[1]
    p_queue = Queue.Queue()
    for i in range(0, p_num):
        array = sys.stdin.readline().strip().split(" ")
        p_queue.put(Proc(array[0], int(array[1])))
    t = 0
    while not p_queue.empty():
        p = p_queue.get()
        if p.time > q_time:
            p.time = p.time - q_time
            p_queue.put(p)
            t += q_time
        else:
            t += p.time
            print p.name + " " + str(t)
    
if __name__ == "__main__":
    main()

Buggy python submission (verdict: Runtime Error):
import Queue
import sys

class Proc:
    def __init__(self, name, time):
        self.time = time
        self.name = name

def main():
    array = map(lambda x: int(x), sys.stdin.readline().strip().split(" "))
    p_num = array[0]
    q_time = array[1]
    p_queue = Queue.Queue()
    for i in range(0, p_num):
        array = sys.readline().strip().split(" ")
        p_queue.put(Proc(array[0], int(array[1])))
    t = 0
    while not p_queue.empty():
        p = p_queue.get()
        if p.time > q_time:
            p.time = p.time - q_time
            p_queue.put(p)
            t += q_time
        else:
            t += p.time
            print p.name + " " + str(t)
    
if __name__ == "__main__":
    main()

Fixed submission:
import Queue
import sys

class Proc:
    def __init__(self, name, time):
        self.time = time
        self.name = name

def main():
    array = map(lambda x: int(x), sys.stdin.readline().strip().split(" "))
    p_num = array[0]
    q_time = array[1]
    p_queue = Queue.Queue()
    for i in range(0, p_num):
        array = sys.stdin.readline().strip().split(" ")
        p_queue.put(Proc(array[0], int(array[1])))
    t = 0
    while not p_queue.empty():
        p = p_queue.get()
        if p.time > q_time:
            p.time = p.time - q_time
            p_queue.put(p)
            t += q_time
        else:
            t += p.time
            print p.name + " " + str(t)
    
if __name__ == "__main__":
    main()
Buggy python submission (verdict: Runtime Error):
import sys

class Area:
    def __init__(self, start, end, area):
        self.start = start
        self.end = end
        self.area = area
    def addArea(self, area):
        self.area += area

if __name__ == "__main__":
    line = sys.stdin.readline().strip()
    
    area_stack = []
    field_stack = []
    
    for i in range(0, len(line)):
        c = line[i]
        if (c == "\\"):
            field_stack.append((c, i))
        elif (c == "/"):
            if len(field_stack) == 0:
                continue
            cc = field_stack.pop()
            current_area = Area(cc[1], i, (i - cc[1]))
            if len(area_stack) == 0:
                area_stack.append(current_area)
                continue
            prev_area = area_stack.pop()
            flag = True
            while (prev_area.start > current_area.start) and (prev_area.end < current_area.end):
                current_area.addArea(prev_area.area)
                if len(area_stack) == 0:
                    flag = False
                    break
                prev_area = area_stack.pop()
            if flag:
                area_stack.append(prev_area)
            area_stack.append(current_area)
    print str(reduce(lambda x, y: x + y, map(lambda x: x.area, area_stack)))
    s = ""
    s += str(len(area_stack)) + " "
    for item in area_stack:
        s += str(item.area) + " "
    s = s.strip()
    print s

Fixed submission:
import sys

class Area:
    def __init__(self, start, end, area):
        self.start = start
        self.end = end
        self.area = area
    def addArea(self, area):
        self.area += area

if __name__ == "__main__":
    line = sys.stdin.readline().strip()
    
    area_stack = []
    field_stack = []
    
    for i in range(0, len(line)):
        c = line[i]
        if (c == "\\"):
            field_stack.append((c, i))
        elif (c == "/"):
            if len(field_stack) == 0:
                continue
            cc = field_stack.pop()
            current_area = Area(cc[1], i, (i - cc[1]))
            if len(area_stack) == 0:
                area_stack.append(current_area)
                continue
            prev_area = area_stack.pop()
            flag = True
            while (prev_area.start > current_area.start) and (prev_area.end < current_area.end):
                current_area.addArea(prev_area.area)
                if len(area_stack) == 0:
                    flag = False
                    break
                prev_area = area_stack.pop()
            if flag:
                area_stack.append(prev_area)
            area_stack.append(current_area)
    print str(reduce(lambda x, y: x + y, map(lambda x: x.area, area_stack), 0))
    s = ""
    s += str(len(area_stack)) + " "
    for item in area_stack:
        s += str(item.area) + " "
    s = s.strip()
    print s
Buggy python submission (verdict: Runtime Error):
import sys

n = int(sys.stdin.readline().strip())
S = map(int, sys.stdin.readline().strip().split(" "))

n = int(sys.stdin.readline().strip())
T = map(int, sys.stdin.readline().strip().split(" "))

res = []

for t in T:
    rse.append(S.count(t))
print sum(res)

Fixed submission:
import sys

n = int(sys.stdin.readline().strip())
S = map(int, sys.stdin.readline().strip().split(" "))

n = int(sys.stdin.readline().strip())
T = map(int, sys.stdin.readline().strip().split(" "))

res = []

for t in T:
    res.append(int(S.count(t) != 0))
print sum(res)

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

n = int(sys.stdin.readline().strip())
S = map(int, sys.stdin.readline().strip().split(" "))

n = int(sys.stdin.readline().strip())
T = map(int, sys.stdin.readline().strip().split(" "))

res = []

for t in T:
    rse.append(S.count(t))
print sum(res)

Fixed submission:
import sys

n = int(sys.stdin.readline().strip())
S = map(int, sys.stdin.readline().strip().split(" "))

n = int(sys.stdin.readline().strip())
T = map(int, sys.stdin.readline().strip().split(" "))

res = []

for t in T:
    res.append(int(S.count(t) != 0))
print sum(res)

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

n = int(sys.stdin.readline().strip())
S = map(int, sys.stdin.readline().strip().split(" "))

n = int(sys.stdin.readline().strip())
T = map(int, sys.stdin.readline().strip().split(" "))

res = []

for t in T:
    rse.append(S.count(t))
print sum(res)

Fixed submission:
import sys

n = int(sys.stdin.readline().strip())
S = map(int, sys.stdin.readline().strip().split(" "))

n = int(sys.stdin.readline().strip())
T = map(int, sys.stdin.readline().strip().split(" "))

res = []

for t in T:
    res.append(int(S.count(t) != 0))
print sum(res)
Buggy python submission (verdict: Runtime Error):
import sys

def binary_search(array, num, left, right):
    if right < left:
        return False
    center = (right + left) / 2
    if array[center] == num:
        return True
    elif array[center] < num:
        return binary_search(array, num, center + 1, right)
    elif array[center] > num:
        return binary_search(array, num, left, center)

n = int(sys.stdin.readline().strip())
S = map(lambda x: int(x), sys.stdin.readline().strip().split(" "))
n = int(sys.stdin.readline().strip())
T = map(lambda x: int(x), sys.stdin.readline().strip().split(" "))

res = 0

for t in T:
    if binary_search(S, t, 0, len(S)):
        res += 1

print res
        

Fixed submission:
import sys

def binary_search(array, num, left, right):
    if right < left + 1:
        return False
    center = (right + left) / 2
    if array[center] == num:
        return True
    elif array[center] < num:
        return binary_search(array, num, center + 1, right)
    elif array[center] > num:
        return binary_search(array, num, left, center)

n = int(sys.stdin.readline().strip())
S = map(lambda x: int(x), sys.stdin.readline().strip().split(" "))
n = int(sys.stdin.readline().strip())
T = map(lambda x: int(x), sys.stdin.readline().strip().split(" "))

res = 0

for t in T:
    if binary_search(S, t, 0, len(S)):
        res += 1

print res
Buggy python submission (verdict: Runtime Error):
import sys

def printlist(lst):
	for l in lst:
		print(l),
	print

N = int(sys.stdin.readline().strip())
A = sys.stdin.readline().strip().split(" ")

A = map(lambda x:int(x),A)
for i in range(0,N):
	temp = A[i]
	j = i-1
	while j>=0 and A[j]>temp:
		A[j+1] = A[j]
		j-=1
	A[j+1]=temp
	printlist(A)

Fixed submission:
import sys

def printlist(lst):
	for l in lst:
		print(l),
	print

N = int(sys.stdin.readline().strip())
A = sys.stdin.readline().strip().split(" ")

A = map(lambda x:int(x),A)
for i in range(0,N):
	temp = A[i]
	j = i-1
	while j>=0 and A[j]>temp:
		A[j+1] = A[j]
		j-=1
	A[j+1]=temp
	printlist(A)
Buggy python submission (verdict: Runtime Error):
import sys

def gcd(a,b):
	temp = a
	if a<b:
		a=b
		b=a
	if b==0:
		return a
	c = a%b
	return gcd(b,c)


line = sys.stdin.readline().strip().split(" ")
A = int(line[0])
B = int(line[1])

print(gcd(A,B))
return

Fixed submission:
import sys

def gcd(a,b):
	temp = a
	if a<b:
		a=b
		b=temp
	if b==0:
		return a
	c = a%b
	return gcd(b,c)


line = sys.stdin.readline().strip().split(" ")
A = int(line[0])
B = int(line[1])

print(gcd(A,B))
Buggy python submission (verdict: Runtime Error):
from sys import stdin

global time
time = 0

def dfs(graph,start,state,discover,finish):

    state[start-1] = 1
    global time
    time = time + 1
    discover[start-1] = time
    # print str(time) + " go to " + str(start)

    neighbours = sorted(graph[start])

    for neighbour in neighbours:
        if state[neighbour-1] == 0:
            dfs(graph,neighbour,state,discover,finish)

    state[start-1] = 2
    time = time + 1
    finish[start - 1] = time
    # print str(time) + " out of " + str(start)

def main():
    # g = {1: [2, 3],
    #      2: [3, 4],
    #      3: [5],
    #                     4: [6],
    #                     5: [6],
    #                     6: []}

    d = [0]*6
    f = [0]*6

    # deal with input
    n = int(stdin.readline())

    g = {}

    d = [-1]*n

    all_vertex = []

    for i in xrange(n):
        entry = [int(s) for s in stdin.readline().split()[2:]]
        g[i+1] = entry
        all_vertex.append(i+1)



    # exp = []
    # state represent vertex visited state: 0 not visited 1 visiting 2 finished
    state = [0]*n

    for node in all_vertex:
        if state[node-1] == 0:
            dfs(g,node,state,d,f)

    # print  'state ' + str(state)

    # print 'd' + str(d)
    # print 'f' + str(f)

    # deal with output
    for i in xrange(n):
        print str(i+1) + ' ' + str(d[i]) + ' ' + str(f[i])

main()


Fixed submission:
from sys import stdin

global time
time = 0

def dfs(graph,start,state,discover,finish):

    state[start-1] = 1
    global time
    time = time + 1
    discover[start-1] = time
    # print str(time) + " go to " + str(start)

    neighbours = sorted(graph[start])

    for neighbour in neighbours:
        if state[neighbour-1] == 0:
            dfs(graph,neighbour,state,discover,finish)

    state[start-1] = 2
    time = time + 1
    finish[start - 1] = time
    # print str(time) + " out of " + str(start)

def main():
    # g = {1: [2, 3],
    #      2: [3, 4],
    #      3: [5],
    #                     4: [6],
    #                     5: [6],
    #                     6: []}



    # deal with input
    n = int(stdin.readline())

    g = {}

    d = [0]*n
    f = [0]*n

    all_vertex = []

    for i in xrange(n):
        entry = [int(s) for s in stdin.readline().split()[2:]]
        g[i+1] = entry
        all_vertex.append(i+1)



    # exp = []
    # state represent vertex visited state: 0 not visited 1 visiting 2 finished
    state = [0]*n

    for node in all_vertex:
        if state[node-1] == 0:
            dfs(g,node,state,d,f)

    # print  'state ' + str(state)

    # print 'd' + str(d)
    # print 'f' + str(f)

    # deal with output
    for i in xrange(n):
        print str(i+1) + ' ' + str(d[i]) + ' ' + str(f[i])

main()
Buggy python submission (verdict: Runtime Error):
#!/opt/local/bin/python
import math
a = raw_input()
print"%f %f" %(math.pi*int(a)**2.0,2.0*math.pi*int(a))

Fixed submission:
#!/opt/local/bin/python
import math
a = raw_input()
print"%f %f" %(math.pi*float(a)**2.0,2.0*math.pi*float(a))

Buggy python submission (verdict: Runtime Error):
#!/opt/local/bin/python
import math
a = raw_input()
print"%f %f" %(math.pi*int(a)**2.0,2.0*math.pi*int(a))

Fixed submission:
#!/opt/local/bin/python
import math
a = raw_input()
print"%f %f" %(math.pi*float(a)**2.0,2.0*math.pi*float(a))

Buggy python submission (verdict: Runtime Error):
#!/opt/local/bin/python
from math import pi
a = raw_input()
print"%f %f" %(pi*int(a)**2.0,2.0*pi*int(a))

Fixed submission:
#!/opt/local/bin/python
import math
a = raw_input()
print"%f %f" %(math.pi*float(a)**2.0,2.0*math.pi*float(a))

Buggy python submission (verdict: Runtime Error):
#!/opt/local/bin/python
from math import pi
a = raw_input()
print"%.6f %.6f" %(pi*int(a)**2.0,2.0*pi*int(a))

Fixed submission:
#!/opt/local/bin/python
import math
a = raw_input()
print"%f %f" %(math.pi*float(a)**2.0,2.0*math.pi*float(a))
Buggy python submission (verdict: Runtime Error):
#!/opt/local/bin/python
# coding: UTF-8
import math
a,b,C = [float(i) for i in raw_input().split()]
S = 0.5 * a * b * math.sin(math.pi * (C / 180))
L = a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.pi * (C / 180))
H = 2 * S / a
print S,L,H

Fixed submission:
#!/opt/local/bin/python
# coding: UTF-8
import math
a,b,C = [float(i) for i in raw_input().split()]
S = 0.5 * a * b * math.sin(math.pi * (C / 180))
L = a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.pi * (C / 180)))
H = 2 * S / a
print S,L,H
Buggy python submission (verdict: Runtime Error):
#!/opt/local/bin/python
# coding: UTF-8
num = int(raw_input())
Taro = 0
Hanako = 0
for i in xrange(num):
	animal = raw_input().split()
	if animal[0] > animal[1]:
		Tato += 3
	elif animal[0] < animal[1]:
		Hanako += 3
	else:
		Taro += 1
		Hanako += 1
print Taro,Hanako

Fixed submission:
#!/opt/local/bin/python
# coding: UTF-8
num = int(raw_input())
Taro = 0
Hanako = 0
for i in xrange(num):
	animal = raw_input().split()
	if animal[0] > animal[1]:
		Taro += 3
	elif animal[0] < animal[1]:
		Hanako += 3
	else:
		Taro += 1
		Hanako += 1
print Taro,Hanako
Buggy python submission (verdict: Runtime Error):
x = input()
pritn str(x**3)

Fixed submission:
x = input()
print str(x**3)
Buggy python submission (verdict: Runtime Error):
a=map(int, raw_input().split())

if a[0]<a[1]<a[2]:
    print("Yes")
else :
    print("No")

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

if a[0]<a[1]<a[2]:
    print("Yes")
else :
    print("No")
Buggy python submission (verdict: Runtime Error):
import math

k=int(raw_input())

s=k*k*math.pi
t=2*k*math.pi

print "%.6f %.6f"%(s,t)

Fixed submission:
import math

k=float(raw_input())

s=k*k*math.pi
t=2*k*math.pi

print "%.6f %.6f"%(s,t)

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

k=int(raw_input())

s=k*k*math.pi
t=2*k*math.pi

print "%.6f %.6f"%(s,t)

Fixed submission:
import math

k=float(raw_input())

s=k*k*math.pi
t=2*k*math.pi

print "%.6f %.6f"%(s,t)