Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Runtime Error):
def insertionSort(a,g):
    global cnt
    for i in range(g,len(a)):
        v = a[i]
        j = i - g
        while j >= 0 and a[j] > v:
            a[j+g] = a[j]
            j = j - g
            cnt+=1
            a[j+g] = v


def shellSort(a):
    global cnt
    cnt = 0
    g = []
    h = 1
    while h <= len(a):
        g.append(h)
        h = 3*h+1
    g.reverse()
    m = len(g)
    print(m)
    print(' '.join(map(str,g)))
    for i in range(m):
        insertionSort(a,g[i])


a=[int(raw_input()) for i in range(int(raw_input()))]
shellSort(a)
print(cnt)
for e in a: print(e)

Fixed submission:
import math


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


def shellsort(a, n):
    g = []
    gap = 1
    while gap <= math.ceil(n / 3):
        g.append(gap)
        gap = 3 * gap + 1
    g = g[::-1]
    m = len(g)
    print(m)
    print(*g)
    cnt = 0
    for i in range(m):
        cnt += insertionsort(a, n, g[i])
    print(cnt)

n = int(input())
a = []
for i in range(n):
    a.append(int(input()))
shellsort(a, n)
print("\n".join(map(str, a)))

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


def insertion_sort(A, N, g):
    for i in range(g, N):
        v = A[i]
        j = i - g
        while j >= 0 and A[j] > v:
            # v????????§???????????°???????????????
            A[j+g] = A[j]
            j -= g
        A[j+g] = v
        print(*A)


def shell_sort(a, n):
    g = []
    gap = 1
    while gap <= math.ceil(n / 3):
        g.append(gap)
        gap = 3 * gap + 1
    g = g[::-1]
    m = len(g)
    print(m)
    print(*g)
    cnt = 0
    for i in range(m):
        cnt += insertion_sort(a, n, g[i])
    print(cnt)

n = int(input())
a = []
for i in range(n):
    a.append(int(input()))
shell_sort(a, n)
print("\n".join(map(str, a)))

Fixed submission:
import math


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


def shellsort(a, n):
    g = []
    gap = 1
    while gap <= math.ceil(n / 3):
        g.append(gap)
        gap = 3 * gap + 1
    g = g[::-1]
    m = len(g)
    print(m)
    print(*g)
    cnt = 0
    for i in range(m):
        cnt += insertionsort(a, n, g[i])
    print(cnt)

n = int(input())
a = []
for i in range(n):
    a.append(int(input()))
shellsort(a, n)
print("\n".join(map(str, a)))
Buggy python submission (verdict: Runtime Error):
num = []
for p in input().split():
    if p.isdisit():
        num.append(int(p))
    else:
        b = num.pop()
        a = num.pop()
        if p == '*':
            num.append(a * b)
        elif p == '+':
            num.append(a + b)
        elif p == '-':
            num.append(a - b)
print(num.pop())

Fixed submission:
poland = input().split()
num = []
for p in poland:
    if p.isdigit():
        num.append(int(p))
    else:
        b = num.pop()
        a = num.pop()
        if p == '*':
            num.append(a * b)
        elif p == '/':
            num.append(a / b)
        elif p == '+':
            num.append(a + b)
        elif p == '-':
            num.append(a - b)
print(num.pop())

Buggy python submission (verdict: Runtime Error):
num = []
for p in input().split():
    if p.isdisit():
        num.append(int(p))
    else:
        b = num.pop()
        a = num.pop()
        if p == '*':
            num.append(a * b)
        elif p == '+':
            num.append(a + b)
        elif p == '-':
            num.append(a - b)
print(num.pop())

Fixed submission:
poland = input().split()
num = []
for p in poland:
    if p.isdigit():
        num.append(int(p))
    else:
        b = num.pop()
        a = num.pop()
        if p == '*':
            num.append(a * b)
        elif p == '/':
            num.append(a / b)
        elif p == '+':
            num.append(a + b)
        elif p == '-':
            num.append(a - b)
print(num.pop())

Buggy python submission (verdict: Runtime Error):
poland = input().split()

num = []
for p in poland:
    if p.isdisit():
        num.append(int(p))
    else:
        b = num.pop()
        a = num.pop()
        if p == '*':
            num.append(a * b)
        elif p == '+':
            num.append(a + b)
        elif p == '-':
            num.append(a - b)
print(num.pop())

Fixed submission:
poland = input().split()
num = []
for p in poland:
    if p.isdigit():
        num.append(int(p))
    else:
        b = num.pop()
        a = num.pop()
        if p == '*':
            num.append(a * b)
        elif p == '/':
            num.append(a / b)
        elif p == '+':
            num.append(a + b)
        elif p == '-':
            num.append(a - b)
print(num.pop())
Buggy python submission (verdict: Runtime Error):
n = int(input())
S = map(int, input().split())
q = int(input())
T = map(int, input().split())

def binary_search(A, key):
    left = 0
    right = n
    while left < right:
        mid = (left + right)/2
        if A[mid] == key:
            return True
        elif key < A[mid]:
            right = mid
        else:
            left = mid + 1
    return False

cnt = 0
for i in T:
    if binary_search(S, i):
        cnt += 1

print(cnt)

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


def binary_search(A, key):
    left = 0
    right = n
    while left < right:
        mid = int((left + right)/2)
        if A[mid] == key:
            return True
        elif key < A[mid]:
            right = mid
        else:
            left = mid + 1
    return False

cnt = 0
for i in T:
    if binary_search(S, i):
        cnt += 1

print(cnt)
Buggy python submission (verdict: Runtime Error):
def merge(A, left, mid, right):
    global count
    L = A[left:mid]
    R = A[mid:right]
    R.append[1000000001]
    L.append[1000000001]

    i = j = 0
    for k in range(left, right):
        if L[i] <= R[j]:
            A[k] = L[i]
            i += 1
        else:
            A[k] = R[j]
            j += 1
    count += right - left


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

N = int(input())
A = list(map(int, input().split()))
count = 0
merge_sort(A, 0, N)
print(*A)
print(count)











def merge(A, left, mid, right):
    global count
    L = A[left:mid] + [1000000001]
    R = A[mid:right] + [1000000001]
    i = j = 0
    for k in range(left, right):
        if L[i] <= R[j]:
            A[k] = L[i]
            i += 1
        else:
            A[k] = R[j]
            j += 1
    count += right - left


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

N = int(input())
A = list(map(int, input().split()))
count = 0
def merge(A, left, mid, right):
    global count
    L = A[left:mid]
    R = A[mid:right]
    R.append[1000000001]
    L.append[1000000001]
    
    i = j = 0
    for k in range(left, right):
        if L[i] <= R[j]:
            A[k] = L[i]
            i += 1
        else:
            A[k] = R[j]
            j += 1
    count += right - left

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

N = int(input())
A = list(map(int, input().split()))
count = 0
merge_sort(A, 0, N)
print(*A)
print(count)

Fixed submission:
def merge(A, left, mid, right):
    global count
    L = A[left:mid] + [1000000001]
    R = A[mid:right] + [1000000001]
    i = j = 0
    for k in range(left, right):
        if L[i] <= R[j]:
            A[k] = L[i]
            i += 1
        else:
            A[k] = R[j]
            j += 1
    count += right - left


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

N = int(input())
A = list(map(int, input().split()))
count = 0
merge_sort(A, 0, N)
print(*A)
print(count)
Buggy python submission (verdict: Runtime Error):
def partition(a, p, r):
    x = a[r]
    i = p - 1
    for j in range(p, r):
        if a[j] <= x:
            i = i + 1
            a[i], a[j] = a[j], a[i]
    a[i+1], a[r] = a[r], a[i+1]
    print(*a)
    return i+1

n = int(input())
a = list(map(int, input().split()))
partition(a, 0, n)

Fixed submission:
def partition(a, p, r):
    x = a[r]
    i = p - 1
    for j in range(p, r):
        if a[j] <= x:
            i = i + 1
            a[i], a[j] = a[j], a[i]
    a[i+1], a[r] = a[r], a[i+1]
    return i+1

n = int(input())
a = list(map(int, input().split()))
m = partition(a, 0, n-1)
a = list(map(str, a))
a[m] = "[%s]"%(a[m])
print(" ".join(a))

Buggy python submission (verdict: Runtime Error):
def partition(a, p, r):
    x = a[r]
    i = p - 1
    for j in range(p, r):
        if a[j] <= x:
            i = i + 1
            a[i], a[j] = a[j], a[i]
    a[i+1], a[r] = a[r], a[i+1]
    return i+1

n = int(input())
a = list(map(int, input().split()))
m = partition(a, 0, n-1)
a[m] = "[%s]"%(a[m])
print(" ".join(a))

Fixed submission:
def partition(a, p, r):
    x = a[r]
    i = p - 1
    for j in range(p, r):
        if a[j] <= x:
            i = i + 1
            a[i], a[j] = a[j], a[i]
    a[i+1], a[r] = a[r], a[i+1]
    return i+1

n = int(input())
a = list(map(int, input().split()))
m = partition(a, 0, n-1)
a = list(map(str, a))
a[m] = "[%s]"%(a[m])
print(" ".join(a))
Buggy python submission (verdict: Runtime Error):
N, W = map(int, raw_input().split())

v = [0] * N
w = [0] * N

for i in range(N):
    v[i], w[i] = map(int, raw_input().split())


def rec(i, j):
    if i == N:
        res = 0
    elif j < w[i]:
        res = rec(i + 1, j)
    else:
        res = max(rec(i + 1, j), rec(i + 1, j - w[i]) + v[i])
    return res

print(rec(0, W))

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

v = [0] * N
w = [0] * N
dp = [[0 for i in range(W + 1)] for j in range(N + 1)]

for i in range(N):
    v[i], w[i] = map(int, raw_input().split())

for i in range(N - 1, -1, -1):
    for j in range(W + 1):
        if j < w[i]:
            dp[i][j] = dp[i + 1][j]
        else:
            dp[i][j] = max(dp[i + 1][j], dp[i + 1][j - w[i]] + v[i])

print(dp[0][W])

Buggy python submission (verdict: Time Limit Exceeded):
N, W = map(int, raw_input().split())

v = [0] * N
w = [0] * N

for i in range(N):
    v[i], w[i] = map(int, raw_input().split())


def rec(i, j):
    if i == N:
        res = 0
    elif j < w[i]:
        res = rec(i + 1, j)
    else:
        res = max(rec(i + 1, j), rec(i + 1, j - w[i]) + v[i])
    return res

print(rec(0, W))

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

v = [0] * N
w = [0] * N
dp = [[0 for i in range(W + 1)] for j in range(N + 1)]

for i in range(N):
    v[i], w[i] = map(int, raw_input().split())

for i in range(N - 1, -1, -1):
    for j in range(W + 1):
        if j < w[i]:
            dp[i][j] = dp[i + 1][j]
        else:
            dp[i][j] = max(dp[i + 1][j], dp[i + 1][j - w[i]] + v[i])

print(dp[0][W])
Buggy python submission (verdict: Runtime Error):
n = print()
a = list(map(int, input().sprit()))
print(a.reverse())

Fixed submission:
n = int(input())
array = list(input().split())
array.reverse()
 
for i in range(n - 1):
    print(array[i] + " ", end = "")

print (array[n - 1])

Buggy python submission (verdict: Runtime Error):
n = print()
a = list(map(int, input().sprit()))
print(reversed(a))

Fixed submission:
n = int(input())
array = list(input().split())
array.reverse()
 
for i in range(n - 1):
    print(array[i] + " ", end = "")

print (array[n - 1])

Buggy python submission (verdict: Runtime Error):
n = print()
a = list(map(int, input().sprit()))
a.reverse()
print(a)

Fixed submission:
n = int(input())
array = list(input().split())
array.reverse()
 
for i in range(n - 1):
    print(array[i] + " ", end = "")

print (array[n - 1])
Buggy python submission (verdict: Runtime Error):
from math import *
PI = 3.1415926535898
pool = []
pool.append("1100000011")
pool.append("1000000010000000100000001")
pool.append("1111")
pool.append("1000000110000001")
pool.append("11000000011")
pool.append("100000001100000001")
pool.append("110000011")
while True:
	try:
		pat = ""
		for i in range(8):
			pat += str(raw_input())
		flag = False
		tp = ""
		for x in pat:
			if x != '0':
				flag = True
			if flag:
				tp += x
		pat = reversed(tp)
		flag = False
		tp = ""
		for x in pat:
			if x != '0':
				flag = True
			if flag:
				tp += x
		pat = tp
		print chr(pool.index(pat) + ord('A'))
	except EOFError:
		break

Fixed submission:
from math import *
PI = 3.1415926535898
pool = []
pool.append("1100000011")
pool.append("1000000010000000100000001")
pool.append("1111")
pool.append("1000000110000001")
pool.append("11000000011")
pool.append("100000001100000001")
pool.append("110000011")
while True:
	try:
		pat = ""
		for i in range(8):
			s = str(raw_input())
			while len(s) == 0:
				s = str(raw_input())
			pat += s
		flag = False
		tp = ""
		for x in pat:
			if x != '0':
				flag = True
			if flag:
				tp += x
		pat = reversed(tp)
		flag = False
		tp = ""
		for x in pat:
			if x != '0':
				flag = True
			if flag:
				tp += x
		pat = tp
		print chr(pool.index(pat) + ord('A'))
	except EOFError:
		break
Buggy python submission (verdict: Runtime Error):
from math import *
PI = 3.1415926535898
ans = 0
while True:
    try:
        s = raw_input()
        t = ""
        for x in s:
            if x.isdigit():
                t += x
            elif len(t) > 0 and t[len(t)-1].isdigit():
                t += " "
        arr = map(int, t.strip().split(' '))
        for x in arr:
            ans += x
    except EOFError:
        break
print ans

Fixed submission:
from math import *
PI = 3.1415926535898
ans = 0
while True:
    try:
        s = raw_input()
        t = ""
        for x in s:
            if x.isdigit():
                t += x
            elif len(t) > 0 and t[len(t)-1].isdigit():
                t += " "
        if len(t) > 0:
            arr = map(int, t.strip().split(' '))
            for x in arr:
                ans += x
    except EOFError:
        break
print ans
Buggy python submission (verdict: Runtime Error):
from math import *
PI = 3.1415926535898
while True:
    try:
    	a, b, x, y = map(float, raw_input().strip().split(' '))
    	print pow((a-x)*(a-x)+(b-y)*(b-y), 0.5)
    except EOFError:
        break

Fixed submission:
from math import *
PI = 3.1415926535898
while True:
    try:
    	k = raw_input()
    	if len(k) > 0:
	    	a, b, x, y = map(float, k.strip().split(' '))
	    	print pow((a-x)*(a-x)+(b-y)*(b-y), 0.5)
    except EOFError:
        break
Buggy python submission (verdict: Runtime Error):
import sys

lines = sys.stdin.readlines()
size = int(lines[0])
data = lines[1:len(lines)]
for line in data:
    line = line.split(" ")
    inp = []
    for i in line:
        inp.append(float(i))
    x = []
    x.append(inp[0])
    x.append(inp[2])
    x.append(inp[4])
    x.append(inp[6])
    y = []
    y.append(inp[1])
    y.append(inp[3])
    y.append(inp[5])
    y.append(inp[7])
    tilt1 = (y[1]-y[0])/(x[1]-x[0])
    tilt2 = (y[3]-y[2])/(x[3]-x[2])
    if tilt1==tilt2:
        print ("YES")
    else:
        print ("NO")

Fixed submission:
import sys
import decimal

lines = sys.stdin.readlines()
size = int(lines[0])
data = lines[1:len(lines)]
for line in data:
    line = line.split(" ")
    inp = []
    for i in line:
        inp.append(decimal.Decimal(i))
    x = []
    x.append(inp[0])
    x.append(inp[2])
    x.append(inp[4])
    x.append(inp[6])
    y = []
    y.append(inp[1])
    y.append(inp[3])
    y.append(inp[5])
    y.append(inp[7])
    if x[1]==x[0] and x[3]==x[2]:
        print ("YES")
    elif x[1]==x[0] or x[3]==x[2]:
        print ("NO")
    else:
        tilt1 = (y[1]-y[0])/(x[1]-x[0])
        tilt2 = (y[3]-y[2])/(x[3]-x[2])
        if tilt1==tilt2:
            print ("YES")
        else:
            print ("NO")
Buggy python submission (verdict: Time Limit Exceeded):
import sys
def func(w,result):
   list = [1,2,4,8,16,32,64,128,256,512]
   for i in range(len(list)):
       if w == list[i]:
           result.append(list[i])
           w = w - list[i]
           break
       else:
           if list[i] > w :
               result.append(list[i-1])
               w = w - list[i-1]
               break

   return w
def sort1(num):
   i = 0
   j = 0
   for i in range(0,len(num)):
        for j in range(0,len(num)-i-1):
            if num[j] < num[j+1]:
               temp = num[j]
               num[j] = num[j+1]
               num[j+1]=temp
   return num
for line in sys.stdin.readlines():
   result = []
   w = int(line)
   while w > 0 :
       w = func(w,result)
   i = len(result)-1
   while i > 0:
       print(result[i],end=' ')
       i -= 1
   print(result[0])
   del(result)

Fixed submission:
import sys
def func(w,result):
   list = [1,2,4,8,16,32,64,128,256,512]
   for i in range(len(list)):
       if w == list[i]:
           result.append(list[i])
           w = w - list[i]
           break
       else:
           if list[i] > w :
               result.append(list[i-1])
               w = w - list[i-1]
               break
           elif w > 512:
               result.append(512)
               w = w - 512
               break

   return w
for line in sys.stdin.readlines():
   result = []
   w = int(line)
   while w > 0 :
       w = func(w,result)
   i = len(result)-1
   while i > 0:
       print(result[i],end=' ')
       i -= 1
   print(result[0])
   del(result)
Buggy python submission (verdict: Runtime Error):
a=[]
n=int(input())
for i in range(10):
        a.append(-1)
while(n!=0):
    b=[]
    c=[]
    a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9]=map(int,input().split())
    for i in range(10):
        b.append(-1)
        c.append(-1)
    j=1
    k=0
    lenb=0
    lenc=0
    b[0]=a[0]
    for i in range(1,10):
        if(a[i]>b[j-1]):
            b[j]=a[i]
            j+=1
        else:
            if(k==0):
                c[0]=a[i]
                k+=1
            elif(a[i]>c[k-1]):
                c[k]=a[i]
                k+=1
    for i in range(10):
        if(b[i]!=-1):
            lenb+=1
        if(c[i]!=-1):
            lenc+=1
    if(len(a)==(lenb+lenc)):
        print("YES")
    else:
        print("NO")

Fixed submission:
a=[]
n=int(input())
for i in range(10):
        a.append(-1)
while(n!=0):
    n-=1
    b=[]
    c=[]
    a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9]=map(int,input().split())
    for i in range(10):
        b.append(-1)
        c.append(-1)
    j=1
    k=0
    lenb=0
    lenc=0
    b[0]=a[0]
    for i in range(1,10):
        if(a[i]>b[j-1]):
            b[j]=a[i]
            j+=1
        else:
            if(k==0):
                c[0]=a[i]
                k+=1
            elif(a[i]>c[k-1]):
                c[k]=a[i]
                k+=1
    for i in range(10):
        if(b[i]!=-1):
            lenb+=1
        if(c[i]!=-1):
            lenc+=1
    if(len(a)==(lenb+lenc)):
        print("YES")
    else:
        print("NO")
Buggy python submission (verdict: Time Limit Exceeded):
x,y = map(int,raw_input().split())
if y>x:
    tmp = x
    x = y
    y = tmp
i=2
ans = 1
while i<=x:
    if x % i ==0:
        if y % i==0:
            ans = i
    i+=1
print ans

Fixed submission:
x,y = map(int,raw_input().split())
if x==y:
    print x
else:
    if y>x:
        tmp = x
        x = y
        y = tmp
    i=2
    ans = 1
    al = []
    while i*i<=x:
        if x % i ==0:
            if y % i==0:
                al.append(i)
                x = x/i
                y = y/i
                continue
        i+=1
    if len(al)!=0:
        for j in al:
            ans *= j
    print ans

Buggy python submission (verdict: Time Limit Exceeded):
x,y = map(int,raw_input().split())
if x==y:
    print x
else:
    if y>x:
        tmp = x
        x = y
        y = tmp
    i=2
    ans = 1
    al = []
    while i<=x/2:
        if x % i ==0:
            if y % i==0:
                al.append(i)
                x = x/i
                y = y/i
                continue
        i+=1
    if len(al)==0:
        pass
    else:
        for j in al:
            ans *= j
    print ans

Fixed submission:
x,y = map(int,raw_input().split())
if x==y:
    print x
else:
    if y>x:
        tmp = x
        x = y
        y = tmp
    i=2
    ans = 1
    al = []
    while i*i<=x:
        if x % i ==0:
            if y % i==0:
                al.append(i)
                x = x/i
                y = y/i
                continue
        i+=1
    if len(al)!=0:
        for j in al:
            ans *= j
    print ans
Buggy python submission (verdict: Time Limit Exceeded):
input_profit = []
for x in xrange(input()):
    input_profit.append(input())
max_profit=input_profit[1]-input_profit[0]
for i in xrange(len(input_profit)-1):
    min_profit = input_profit[i]
    candidate = max(input_profit[i+1:])-min_profit
    if candidate>max_profit:
        max_profit=candidate
print max_profit

Fixed submission:
input_n = input()
price1  = input()
price2  = input()
min_price = min(price1,price2)
max_profit = price2-price1
for i in xrange(input_n-2):
    input_profit = input()
    tmp = input_profit-min_price
    if max_profit<tmp:
        max_profit = tmp
    if min_price>input_profit:
        min_price = input_profit
print max_profit
Buggy python submission (verdict: Runtime Error):
def show_list(a):
    for x in a:
        print x,
    print

def selection_sort(a,n):
    count=0
    for i in xrange(1,10):
        minj = i
        for j in xrange(i,n):
            if a[j]<a[minj]:
                minj = j
        tmp = a[i]
        a[i]=a[minj]
        a[minj]=tmp
        count+=1
    show_list(a)
    print count


def main():
    n = input()
    a = map(int,raw_input().split())
    selection_sort(a,n)


if __name__ == '__main__':
    main()

Fixed submission:
def show_list(a):
    for x in a:
        print x,
    print

def selection_sort(a,n):
    count=0
    for i in xrange(n):
        minj = i
        for j in xrange(i,n):
            if a[j]<a[minj]:
                minj = j
        if minj!=i:  
            tmp = a[i]
            a[i]=a[minj]
            a[minj]=tmp
            count+=1
    show_list(a)
    print count


def main():
    n = input()
    a = map(int,raw_input().split())
    selection_sort(a,n)


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

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

    while True:
        try:
            yield ''.join(raw_input().strip())
        except EOFError:
            break
inlist = list(get_input())
instr = "".join(inlist)
instr = instr.lower()
ascstart = 97
ascfin = 122
strlist = [0 for i in xrange(97,122+1)]
# print len(strlist)
for x in xrange(len(instr)):
    if ord(instr[x]) < ascstart or ord(instr[x]) > ascfin:
        continue
    strlist[ord(instr[x])-ascstart] +=1

for x in xrange(ascstart,ascfin+1):
    print "%s : %d" % (chr(x),strlist[x-ascstart])

Fixed submission:
def get_input():
    while True:
        try:
            yield ''.join(raw_input().strip())
        except EOFError:
            break
inlist = list(get_input())
instr = "".join(inlist)
instr = instr.lower()
ascstart = 97
ascfin = 122
strlist = [0 for i in xrange(97,122+1)]
# print len(strlist)
for x in xrange(len(instr)):
    if ord(instr[x]) < ascstart or ord(instr[x]) > ascfin:
        continue
    strlist[ord(instr[x])-ascstart] +=1

for x in xrange(ascstart,ascfin+1):
    print "%s : %d" % (chr(x),strlist[x-ascstart])