qyliang/CodeNanoFix huggingface dataset:
Buggy code:
N=int(input())
L=list(map(int,input().split()))
N=200000
L=[i for i in range(N)]
Left=[[0,0]]
Right=[[0,N]]
for i in range(N):
    Left.append([Left[i][0]+L[i],i+1])
for i in range(N):
    Right.append([Right[i][0]+L[i*(-1)-1],N-i-1])
Right=list(reversed(Right))
Left=sorted(Left, key=lambda x: x[0])
_sum_=Right[0][0]
Left=sorted(Left, key=lambda x: x[0],reverse=True)
Right=sorted(Right, key=lambda x: x[0])
Left.append([0,0])
Right.append([0,0])

j=0
s=0
ans=0
for i in range(N+1):
    if i != 0:
        if Left[i][0]!=Left[i-1][0]:
            s=0
    while(Left[i][0]+Right[j][0]<_sum_ and j<=N):
        j+=1
    if j>N:
        break
    elif Left[i][0]+Right[j][0]>_sum_:
        continue
    else:
        while(Left[i][0]+Right[j][0]==_sum_ and j<=N):
            if Left[i][1]>=Right[j][1]:
                j+=1
            else:
                s+=1
                ans+=s
                break
print(ans)

Fixed code:
N=int(input())
L=list(map(int,input().split()))
Left=[[0,0]]
Right=[[0,N]]
for i in range(N):
    Left.append([Left[i][0]+L[i],i+1])
for i in range(N):
    Right.append([Right[i][0]+L[i*(-1)-1],N-i-1])
Right=list(reversed(Right))
Left=sorted(Left, key=lambda x: x[0])
_sum_=Right[0][0]
Left=sorted(Left, key=lambda x: x[0],reverse=True)
Right=sorted(Right, key=lambda x: x[0])
Left.append([0,0])
Right.append([0,0])
 
j=0
s=0
ans=0
for i in range(N+1):
    if i != 0:
        if Left[i][0]!=Left[i-1][0]:
            s=0
    while(Left[i][0]+Right[j][0]<_sum_ and j<=N):
        j+=1
    if j>N:
        break
    elif Left[i][0]+Right[j][0]>_sum_:
        continue
    else:
        while(Left[i][0]+Right[j][0]==_sum_ and j<=N):
            if Left[i][1]>=Right[j][1]:
                j+=1
            else:
                s+=1
                ans+=s
                break
print(ans)
Buggy code:
import numpy as np
N = int(input())
A = np.array([0] + list(map(int, input().split())))
B = np.cumsum(A)
B.sort()
cnt = 1
out = 0
for k in range(N):
  if B[k] == B[k+1]:
    cnt += 1
    if k == N-1:
      out += (cnt * (cnt - 1)) // 2
    print('cnt: {}'.format(cnt))
  else:
    out += (cnt * (cnt - 1)) // 2
    cnt = 1
    print('out: {}'.format(out))
print(out)

Fixed code:
import numpy as np
N = int(input())
A = np.array([0] + list(map(int, input().split())))
B = np.cumsum(A)
B.sort()
cnt = 1
out = 0
for k in range(N):
  if B[k] == B[k+1]:
    cnt += 1
    if k == N-1:
      out += (cnt * (cnt - 1)) // 2
  else:
    out += (cnt * (cnt - 1)) // 2
    cnt = 1
print(out)
Buggy code:
# coding=utf-8

n = int(input())
s = list(map(int, input().split()))
for i in range(1, n):
    s[i] += s[i-1]

ans = 0
print(s)
s = sorted(s)
print(s)
i = 0
while True:
    mid = 0
    for j in range(i+1, n):
        if s[j] == s[i]:
            mid += 1
            ans += mid
        else:
            break
    if s[i] == 0:
        ans += mid+1
    i += mid
    i += 1
    if i >= n:
        break
print(ans)

Fixed code:
# coding=utf-8

n = int(input())
s = list(map(int, input().split()))
for i in range(1, n):
    s[i] += s[i-1]

ans = 0
s = sorted(s)
i = 0
while True:
    mid = 0
    for j in range(i+1, n):
        if s[j] == s[i]:
            mid += 1
            ans += mid
        else:
            break
    if s[i] == 0:
        ans += mid+1
    i += mid
    i += 1
    if i >= n:
        break
print(ans)
Buggy code:
n = int(input())
a = list(map(int,input().split()))
dic_S = {0:[0]}
S = 0
ans = 0
for i in range(n):
    S += a[i]
    if S not in dic_S:
        dic_S[S] = []
    else:
        pass
    dic_S[S].append(a[i])
    

for k in dic_S.keys():
    I = len(dic_S[k])
    if 3 <= I:
        ans += (I*(I-1))// *2
    elif I == 2:
        ans += 1
    else:
        pass
print(ans)


Fixed code:
import math
n = int(input())
a = list(map(int,input().split()))
dic_S = {0:[0]}
S = 0
ans = 0
for i in range(n):
    S += a[i]
    if S not in dic_S:
        dic_S[S] = []
    else:
        pass
    dic_S[S].append(a[i])
    

for k in dic_S.keys():
    I = len(dic_S[k])
    if 3 <= I:
        ans += math.factorial(I) // (math.factorial(I-2)*2)
    elif I == 2:
        ans += 1
    else:
        pass
print(ans)
Buggy code:
def main():
    N = int(input())
    A = [int(i) for i in input().split()]
    
    result = 0
    s = [0]
    for i in range(N):
        s.append(s[-1] + A[i])
        
    s.sort()
    print(s)
    
    count = 1
    for i in range(N):
        if(s[i] == s[i+1]):
            count += 1
        else:
            result += count * (count -1 ) // 2
            count = 1
    result += count * (count -1 ) // 2
    print(result)
    
if __name__=="__main__":
    main()

Fixed code:
def main():
    N = int(input())
    A = [int(i) for i in input().split()]
    
    result = 0
    s = [0]
    for i in range(N):
        s.append(s[-1] + A[i])
        
    s.sort()
#    print(s)
    
    count = 1
    for i in range(N):
        if(s[i] == s[i+1]):
            count += 1
        else:
            result += count * (count -1 ) // 2
            count = 1
    result += count * (count -1 ) // 2
    print(result)
    
if __name__=="__main__":
    main()
Buggy code:
# coding : utf-8
 
import numpy as np
 
N = int(input())
 
A = [int(i) for i in input().split()]

S = [0 for i in range(N+1)]

for i in range(N):
	S[i+1] = S[i] + A[i]

S = sorted(S)
cnt = 0
s = S[0]
for i in range(1,N+1):
	if s == S[i]:
		cnt += 1
	else:
		s = S[i]

#print(S)
print(cnt)

Fixed code:
# coding : utf-8
 
import numpy as np
 
N = int(input())
 
A = [int(i) for i in input().split()]

S = [0 for i in range(N+1)]

for i in range(N):
	S[i+1] = S[i] + A[i]

S = sorted(S)
cnt = 0
block = 1
s = S[0]
for i in range(1,N+1):
	if s == S[i]:
		cnt += block
		block += 1
	else:
		s = S[i]
		block = 1

#print(S)
print(cnt)
Buggy code:
n = int(input())
a = list(map(int, input().split()))
dic = {}
dic[0] = 1
total = 0
for i in range(n):
  total += a[i]
  dic[total] += 1
ans = 0
for v in dic.values():
  ans += v*(v-1) // 2
print(ans)

Fixed code:
n = int(input())
a = list(map(int, input().split()))
dic = {}
dic[0] = 1
total = 0
for i in range(n):
  total += a[i]
  if total in dic:
    dic[total] += 1
  else:
    dic[total] = 1
ans = 0
for v in dic.values():
  ans += v*(v-1) // 2
print(ans)
Buggy code:
from collections import Counter

N = [int(_) for _ in input().split()][0]
a = [int(_) for _ in input().split()]

s = [0] * (len(a) + 1)
for i in range(len(a)):
    s[i + 1] = s[i] + a[i]

c = Counter()

for i in range(len(s)):
    c[s[i]] += 1

ans = 0
for cnt in c.values():
    if cnt < 2: continue

    ans += (cnt + cnt - 1) // 2
print(ans)


Fixed code:
from collections import Counter

N = [int(_) for _ in input().split()][0]
a = [int(_) for _ in input().split()]

s = [0] * (len(a) + 1)
for i in range(len(a)):
    s[i + 1] = s[i] + a[i]

c = Counter()

for i in range(len(s)):
    c[s[i]] += 1

ans = 0
for cnt in c.values():
    if cnt < 2: continue

    ans += (cnt * (cnt - 1)) // 2
print(ans)
Buggy code:
import bisect
 
N = int(input())
A = [int(i) for i in input().split()]
 
B =  {}
B[0] = 1

s = 0
ans = 0

for a in A:
    s += a
    ans += B.get(a,0)
    B[a] = B.get(a,0) + 1

print(ans)
    

Fixed code:
N = int(input())
A = [int(i) for i in input().split()]

B = {}
B[0] = 1

s = 0
ans = 0

for a in A:
    s += a
    ans += B.get(s,0)
    B[s] = B.get(s,0)+1

print(ans)
Buggy code:
from itertools import accumulate
from collections import Counter
import sys
input = sys.stdin.readline
n = int(input())
a = [0]
a.extend(map(int,input().split()))
a = list(accumulate(a))
c = Counter(a)
ans = 0
for i in c.values():
  ans+=i*(i-1)//2

Fixed code:
from itertools import accumulate
from collections import Counter
import sys
input = sys.stdin.readline
n = int(input())
a = [0]
a.extend(map(int,input().split()))
a = list(accumulate(a))
c = Counter(a)
ans = 0
for i in c.values():
  ans+=i*(i-1)//2
print(ans)
Buggy code:
from itertools import accumulate
from collections import Counter
N = int(input())
Alist = [0]+list(map(int, input().split()))
cumsum = Counter(sorted(list(accumulate(Alist)))).most_common()
ans = 0

for k, v in cumsum:
    if v > 1:
        ans += n*(n-1)//2
    else:
        break
print(ans)


Fixed code:
from itertools import accumulate
from collections import Counter
N = int(input())
Alist = [0]+list(map(int, input().split()))
cumsum = Counter(sorted(list(accumulate(Alist)))).most_common()
ans = 0

for k, v in cumsum:
    if v > 1:
        ans += v*(v-1)//2
    else:
        break
print(ans)
Buggy code:
n=int(input())
a=[int(i) for i in range(n)]
b=[0 for i in range(n+1)]
for i in range(n):
  b[i+1]=b[i]+a[i]
b.sort()
res=0
now=0
cnt=1
for i in range(n):
  if now==b[i+1]:
    cnt+=1
  else:
    res+=(cnt-1)*cnt//2
    cnt=0
    now=b[i+1]
res+=(cnt-1)*cnt//2
print(res)

Fixed code:
n=int(input())
a=[int(i) for i in input().split()]
b=[0 for i in range(n+1)]
for i in range(n):
  b[i+1]=b[i]+a[i]
b.sort()
res=0
now=b[0]
cnt=1
for i in range(n):
  if now==b[i+1]:
    cnt+=1
  else:
    res+=(cnt-1)*cnt//2
    cnt=1
    now=b[i+1]
res+=(cnt-1)*cnt//2
print(res)
Buggy code:
n=int(input())
s=input().split()
l=[int(i) for i in s]
ll=[0 for i in range(n)]
ll[0]=l[0]
for i in range(1,n):
    ll[i]=ll[i-1]+l[i]
ll=[0]+ll
ll.sort()
now=ll[0]
cnt=1
res=0
for i in range(1,n):
    if ll[i]==now:
        cnt+=1
    else:
        if i==n-1:
            break
        res+=cnt*(cnt-1)//2
        cnt=0
        now=ll[i+1]
res+=cnt*(cnt-1)//2
print(res)

Fixed code:
n=int(input())
s=input().split()
l=[int(i) for i in s]
ll=[0 for i in range(n)]
ll[0]=l[0]
for i in range(1,n):
    ll[i]=ll[i-1]+l[i]
ll=[0]+ll
ll.sort()
now=ll[0]
cnt=1
res=0
for i in range(1,n+1):
    if ll[i]==now:
        cnt+=1
    else:
        res+=cnt*(cnt-1)//2
        cnt=1
        now=ll[i]
res+=cnt*(cnt-1)//2
print(res)
Buggy code:
n = int(input())
a = list(map(int,input().split()))
list_S = [0]
ans = 0
for i in range(n):
    list_S.append(list_S[i] + a[i])

dict_S = {}
for i in list_S:
    if i in dict_S:
        dict_S[i] = 1
    else:
        dict_S[i] += 1

for v in dict_S.values():
    ans += v * (v-1) // 2

print(ans)

Fixed code:
n = int(input())
a = list(map(int,input().split()))
list_S = [0]
ans = 0
for i in range(n):
    list_S.append(list_S[i] + a[i])

dict_S = {}
for i in list_S:
    if i in dict_S:
        dict_S[i] += 1
    else:
        dict_S[i] = 1

for v in dict_S.values():
    ans += v * (v-1) // 2

print(ans)
Buggy code:
n = int(input())
A = list(map(int, input().split()))
for i in range(1, n):
    A[i] = A[i] + A[i-1]
ans = 0
A.sort()
p = A[0]
count = 1
for i in range(1, n):
    x = A[i]
    if x == p:
        count += 1
    else:
        ans += count * (count-1)//2
        count = 1
        p = x
ans += count * (count-1)//2
print(ans)


Fixed code:
n = int(input())
A = list(map(int, input().split()))
for i in range(1, n):
    A[i] = A[i] + A[i-1]
ans = 0
A.sort()
p = A[0]
count = 1
for i in range(1, n):
    x = A[i]
    if x == p:
        count += 1
    else:
        if p == 0:
            ans += count
        ans += count * (count-1)//2
        count = 1
        p = x
if p == 0:
    ans += count
ans += count * (count-1)//2
print(ans)
Buggy code:
import collections

#n=int(input())
#a=list(map(int,input().split(" ")))
n=5
a=[1,-2,3,-4,5]
b=[0 for i in range(n+1)]
s=[0 for i in range(n+1)]
for i in range(1,n+1):
  s[i]=s[i-1]+a[i-1]
c=collections.Counter(s).most_common()
d=0
for i in c:
  if i[1]<2:
    break
  d+=i[1]*(i[1]-1)//2
print(d)

Fixed code:
import collections

n=int(input())
a=list(map(int,input().split(" ")))
#n=5
#a=[1,-2,3,-4,5]
s=[0 for i in range(n+1)]
for i in range(1,n+1):
  s[i]=s[i-1]+a[i-1]
c=collections.Counter(s).most_common()
d=0
for i in c:
  if i[1]<2:
    break
  d+=i[1]*(i[1]-1)//2
print(d)
Buggy code:
m= (input=().count('o')
print(str(700+m*100))

Fixed code:
m=input().count("o")
print(700+m*100)
Buggy code:
s = input()
print(700+s.count("o)*100)

Fixed code:

s = input()

count = s.count("o")

print(700 + count*100)
Buggy code:
s=input()
price=700+100*s.count('s')
print(price)

Fixed code:
s=input()
price=700+100*s.count('o')
print(price)
Buggy code:
a = list(input())
ans = 700
for i in a:
    if i == "+":
        ans += 100
print(ans)


Fixed code:
a = list(input())
ans = 700
for i in a:
    if i == "o":
        ans += 100
print(ans)
Buggy code:
S=list(input())

count=0
if S[0]=="〇":
    count+=100
if S[1]=="〇":
    count+=100
if S[2]=="〇":
    count+=100
print(700+count)

Fixed code:
S=list(input())

count=0
if S[0]=="o":
    count+=100
if S[1]=="o":
    count+=100
if S[2]=="o":
    count+=100
print(700+count)
Buggy code:
data=input().rstrip().split()
data=list(data)
ans=700
for i in data:
  if "o" ==i:
    ans+=100
print(ans)

Fixed code:
data=input().rstrip()
data=list(data)
ans=700
for i in data:
  if "o"==i:
    ans+=100
print(ans)
Buggy code:
s = list(input())
t = 0
for row in s:
    if row ==  'o':
        t += 1
print(800 + 100 * t)

Fixed code:
s = list(input())
t = 0
for row in s:
    if row ==  'o':
        t += 1
print(700 + 100 * t)
Buggy code:
to = list(input())
counter = 0

if to[0] == "o":
  counter += 1
if to[1] == "o":
  counter += 1:
if to[2] == "o":
  counter += 1:
    
price = 700 + 100 * int(counter)

print(price)

Fixed code:
to = list(input())
counter = 0

if to[0] == "o":
  counter += 1
if to[1] == "o":
  counter += 1
if to[2] == "o":
  counter += 1
    
price = 700 + 100 * int(counter)

print(price)
Buggy code:
print(700+input.count('o')*100)

Fixed code:
print((input().count("o"))*100+700)
Buggy code:
s=input()
price=0
if s[0] == 'o':
    price += 700
if s[1] == 'o':
    price += 100
if s[2] == 'o':
    price += 100
print(price)



Fixed code:
s=input()
price=700
if s[0] == 'o':
    price += 100
if s[1] == 'o':
    price += 100
if s[2] == 'o':
    price += 100
print(price)
Buggy code:
S = input()
print(700 + S.count(o) * 100)

Fixed code:
S=input()
print(700+((S.count("o")*100)))
Buggy code:
#n = int(input())
#n,k = map(int,input().split())
#x = list(map(int,input().split()))


s = list(input())

cnt = 700
for i in range(3):
    if s[i] == "o"
    cnt += 100

print(cnt)



Fixed code:
#n = int(input())
#n,k = map(int,input().split())
#x = list(map(int,input().split()))


s = list(input())

cnt = 700
for i in range(3):
    if s[i] == "o":
        cnt += 100

print(cnt)
Buggy code:
s=input()
n=0
for s in a:
  if a=='o':
    n+=100
sum = 700+n
print(sum)

Fixed code:
s=input()
n=0
for a in s:
  if a=='o':
    n+=100
sum = 700+n
print(sum)
Buggy code:
toppings = list(input())
print(toppings)
ans = 700
for i in toppings:
  if i == "o":
    ans += 100
print(ans)

Fixed code:
toppings = list(input())
ans = 700
for i in toppings:
  if i == "o":
    ans += 100
print(ans)
Buggy code:
# vim: fileencoding=utf-8


def main():
    s = input()
    p = 700
    if s[0] == 'o';
        p += 100
    if s[1] == 'o';
        p += 100
    if s[2] == 'o';
        p += 100
    print(p)


if __name__ == '__main__':
    main()


Fixed code:
# vim: fileencoding=utf-8


def main():
    s = input()
    p = 700
    if s[0] == "o":
        p += 100
    if s[1] == "o":
        p += 100
    if s[2] == "o":
        p += 100
    print(p)


if __name__ == "__main__":
    main()
Buggy code:
def main():
    S = int(input())
    cnt = 0
    for i in range(3):
        if s[i]=='o':
            cnt += 1
    ans = 700 + cnt * 100
    print(ans)
main()

Fixed code:
def main():
    S = input()
    cnt = 0
    for i in range(3):
        if S[i]=='o':
            cnt += 1
    ans = 700 + cnt * 100
    print(ans)
main()
Buggy code:
s = input()
count = 0
for i in range(3):
  if s[i] == 'o':
    count+=1
pront(count*100 + 700)

Fixed code:
s = input()
count = 0
for i in range(3):
  if s[i] == 'o':
    count+=1
print(count*100 + 700)
Buggy code:
x = list(input())
print(700+x.count(o)*100)

Fixed code:
x = list(input())
print(700+x.count("o")*100)
Buggy code:
t = input()

ans=700
for x in t:
  if x=='o':
    ans+=100


Fixed code:
t = input()

ans=700
for x in t:
  if x=='o':
    ans+=100
print(ans)
Buggy code:
s = input()
a = list(s)
print(a.count("o")*100+a.count("x")*700)

Fixed code:
s = input()
a = list(s)
print(a.count("o")*100+700)
Buggy code:
tp=input()
ttl=700
for i in tp:
  if i = "o":
    ttl+=100
print(ttl)

Fixed code:
tp=input()
ttl=700
for i in tp:
  if i == "o":
    ttl+=100
print(ttl)
Buggy code:
S = list(map(str, input()))
count = 0
for i in range(3):
  if S[i] =  "o":
    count += 1

print(700+count*100)

Fixed code:
S = list(map(str, input()))
count = 0
for i in range(3):
  if S[i] ==  "o":
    count += 1

print(700+count*100)
Buggy code:
S = input()
l = list(S)
print(700+l.count('o')*100)
@

Fixed code:
S = input()
l = list(S)
print(700+l.count('o')*100)
Buggy code:
S = input().
a = S.count('o')
print(700 + 100 * a)

Fixed code:
S = input()
a = S.count('o')
print(700 + 100 * a)
Buggy code:
s = int(input())
print(700+100*s.count('o'))


Fixed code:
s = input()
print(700 + int(s.count('o')) * 100)
Buggy code:
s = list(input())
t = 700 + s.count(o) * 100
print(t)

Fixed code:
s = list(input())
t = 700 + s.count("o") * 100
print(t)
Buggy code:
s=input()
print(700+100*s.count(o))

Fixed code:
s = input()
print(700 + 100 * s.count("o"))
Buggy code:
s = input()
a = 700
for i in s:
    if i == o:
        a += 100
    if i == x:
        continue
print(a)


Fixed code:
s = input()
a = 700
for i in s:
    if i == "o":
        a += 100
    if i == "x":
        continue
print(a)
Buggy code:
def resolve():
    s = list(str(input()))
    cnt = 0
    if s[0] == 'o':
        cnt += 1
    if s[1] == 'o':
        cnt += 1
    if s[2] == 'o':
        cnt += 1
    print(700+cnt*100)

Fixed code:
s = list(str(input()))
cnt = 0
if s[0] == 'o':
    cnt += 1
if s[1] == 'o':
    cnt += 1
if s[2] == 'o':
    cnt += 1
print(700+cnt*100)
Buggy code:
s = input()
cnt = 0
for i in s:
    if s == "o":
        cnt += 1
print(700 + 100 * cnt)

Fixed code:
s = input()
cnt = 0
for i in s:
    if i == "o":
        cnt += 1
print(700 + 100 * cnt)
Buggy code:
s = input()
ans = 700
for i in range(3):
    if s[i]=="o":
        ans += 100
    print(ans)

Fixed code:
s = str(input())
ans = 700
for i in range(3):
    if s[i]=="o":
        ans += 100
print(ans)
Buggy code:
# -*- coding: utf-8 -*-
text = string(input())
sum = 700
if text[0] == "o":
    sum += 100
if text[1] == "o":
    sum += 100
if text[2] == "o":
    sum += 100
print(sum)

Fixed code:
# -*- coding: utf-8 -*-
text = input()
sum = 700
if text[0] == "o":
    sum += 100
if text[1] == "o":
    sum += 100
if text[2] == "o":
    sum += 100
print(sum)
Buggy code:
s = input()
print(700 + int(s.count(o)*100))

Fixed code:
s = input()
print(700 + int(s.count("o")*100))
Buggy code:
s=input()
co=0
for i in s:
    if s=='o':
        co+=1
print(700+co*100)

Fixed code:
s=input()
sum=0
for i in s:
  if i =="o":
    sum+=1
print(700+sum*100)
Buggy code:
s = input()
for x in s:
  if x == 'o':
    ans += 1
print(700+ans*100)

Fixed code:
s = input()
ans = 0
for x in s:
  if x == 'o':
    ans += 1
print(700+ans*100)
Buggy code:
qqq = list(input())
List_R = []
if qqq[0] == "○":
    List_R.append(1)
if qqq[1] == "○":
    List_R.append(1)
if qqq[2] == "○":
    List_R.append(1)
print(700+len(List_R*100))

Fixed code:
qqq = list(input())
List_R = []
if qqq[0] == "o":
    List_R.append(1)
if qqq[1] == "o":
    List_R.append(1)
if qqq[2] == "o":
    List_R.append(1)
print(700+len(List_R*100))
Buggy code:
s = list(str(input()))
p = 0
for i in s:
    if i == o:
        p = p + 100
        
print(700 + p)

Fixed code:
s = list(str(input()))
p = 0
for i in s:
    if i == 'o':
        p = p + 100
        
print(700 + p)
Buggy code:
A = input()
B = print(A.count('o'))
print(700+int(B)*100)

Fixed code:
A = input()
B = A.count('o')
print(700+int(B)*100)
Buggy code:
a = input()
sum = 700
if a[0] == 'o': sum += 100
if a[1] == '0': sum += 100
if a[2] == 'o': sum += 100
print(sum)
    


Fixed code:
a = input()
sum = 700
if a[0] == 'o': sum += 100
if a[1] == 'o': sum += 100
if a[2] == 'o': sum += 100
print(sum)
Buggy code:
s = str(input())
y = 700
if s[0] == "○":
  y += 100
if s[1] == "○":
  y += 100
if s[2] == "○":
  y += 100
print(y)

Fixed code:
s = str(input())
y = 700
if s[0] == "o":
  y += 100
if s[1] == "o":
  y += 100
if s[2] == "o":
  y += 100
print(y)
Buggy code:
input(S)
a=S.count(o)
y=700+100*a
print(y)

Fixed code:
S=input()
a=S.count('o')
y=700+100*a
print(y)
Buggy code:
S = input()
count = 0
List = [s for s in S]
for i in List:
  if i = "o":
    count+=1
print(700+100*count)

Fixed code:
S = input()
count = 0
List = [s for s in S]
for i in List:
  if i == "o":
    count+=1
print(700+100*count)
Buggy code:
s = str(input)
v = 700
if s[0] == 'o':
    v+= 100
if s[1] == 'o':
    v+= 100
if s[2] == 'o':
    v += 100
print(v)

Fixed code:
s = str(input())
v = 700
if s[0] == 'o':
    v+= 100
if s[1] == 'o':
    v+= 100
if s[2] == 'o':
    v += 100
print(v)
Buggy code:
S = input()
S_list = [S[i:i+1] for i in range(S)]
count = 0
for k in range(len(S)):
  if S_list[k]==o:
    count += 1
  else:
    pass
print(700 + 100*count)

Fixed code:
S = input()
S_list = [S[i:i+1] for i in range(len(S))]
count = 0
for k in range(len(S)):
  if S_list[k] == 'o':
    count += 1
  else:
    pass
print(700 + 100 * count)
Buggy code:
#-*- coding: utf-8 -*-

price = 700
S = raw_input()
for i in S:
    if i= 'o':
        price = price + 100
print price

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

price = 700
S = input()
for i in S:
    if i == 'o':
        price = price + 100
print(price)
Buggy code:
s = input()
r = 700

for i in range(3):
    if s[i] == 'o':
        700 += 100
print(r)

Fixed code:
s = input()
r = 700
 
for i in range(3):
    if s[i] == 'o':
        r += 100
print(r)
Buggy code:
s = input()
if s.count("o") == 1:
  print(700+100)
elif s.count("o") == 2:
  print(700+200)
else:
  print(700+300)

Fixed code:
s = input()
if s.count("o") == 1:
  print(700+100)
elif s.count("o") == 2:
  print(700+200)
elif s.count("o") == 3:
  print(700+300)
else:
  print(700)
Buggy code:
s=input()
t=count('o')
print(700+t*100)

Fixed code:
s=input()
t=s.count('o')
print(700+t*100)
Buggy code:
s = input()
print(700 + s.count(o) * 100)

Fixed code:
s = input()
print(700 + s.count("o") * 100)
Buggy code:
s = input()
 print(700 + 100 * s.count("o"))

Fixed code:
s=input()

a=s.count("o")

print(a*100+700)
Buggy code:
S = input()
a = 700
if S[0] ++ "o":
  a += 100
if S[1] ++ "o":
  a += 100
if S[2] ++ "o":
  a += 100
print(a)


Fixed code:
S = input()
a = 700
if S[0] == "o":
  a += 100
if S[1] == "o":
  a += 100
if S[2] == "o":
  a += 100
print(a)
Buggy code:
S = input()
print(700 + 100*S.count(o))

Fixed code:
S = input()

print(700+S.count("o")*100)
Buggy code:
s = input()
cnt = 0
for c in s:
  if c == 'o':
    cnt++
print(700 + cnt*100)

Fixed code:
s = input()
cnt = 0
for c in s:
  if c == 'o':
    cnt += 1
print(700 + cnt*100)
Buggy code:
print(700+((str(input()).count("o"))*100)

Fixed code:
print(700+((str(input()).count("o"))*100))
Buggy code:
if __name__ == '__main__':
    s = input()
    t = list(s).count('〇')
    v = 700 + 100 * t
    print(v)

Fixed code:
if __name__ == '__main__':
    s = input()
    t = list(s).count('o')
    v = 700 + 100 * t
    print(v)
Buggy code:
top = input()
count = 0
for i in len(str(top)):
  if top[i] == 'o':
    count += 1

sum = 700 + count*100
print(sum)


Fixed code:
top = input()
count = 0
for i in range(len(top)):
  if top[i] == 'o':
    count += 1

sum = 700 + count*100
print(sum)
Buggy code:
#abc095 a
s=input()
print(700+s.count"o"*100)


Fixed code:
#abc095 a
s=input()
print(700+s.count("o")*100)
Buggy code:
import collections

a=list(input())
print(a)
print(a.count("o"))

A = collections.Counter(a)
x = (A["o"])

print(700+100*x)

Fixed code:
import collections

a=list(input())
A = collections.Counter(a)
x = (A["o"])

print(700+100*x)
Buggy code:
S = list(input())

price = 700
l = len(S)

for i in range(l):
  if(S[i] == '○'):
    price += 100
    
  else:
    continue
    
print(price)


Fixed code:
S = list(input())

price = 700
l = len(S)

for i in range(l):
  if(S[i] == 'o'):
    price += 100
    
  else:
    continue
    
print(price)
Buggy code:
S=str(input())
k = 700
for i in range(3):
  if S[i] == "○":
    k = k + 100
print(k)


Fixed code:
S=str(input())
k = 700
for i in range(3):
  if S[i] == 'o':
    k = k + 100
print(k)