qyliang/CodeNanoFix huggingface dataset:
Buggy code:
n, k = map(int, input().split())
r, s, p = map(int, input().split())
t = input()
score_map = {
    "r": p,
    "p": s,
    "s": r,
    "n": 0,
}
t = list(t)
ans = 0
for i in range(k):
    skipped_list = t[i::k]
    print(f"{skipped_list}===")
    for j, c in enumerate(skipped_list[1:]):
        if skipped_list[j] == c:
            skipped_list[j+1] = "n"
    for c in skipped_list:
        ans += score_map[c]
print(ans)


Fixed code:
n, k = map(int, input().split())
r, s, p = map(int, input().split())
t = input()
score_map = {
    "r": p,
    "p": s,
    "s": r,
    "n": 0,
}
t = list(t)
ans = 0
for i in range(k):
    skipped_list = t[i::k]
    for j, c in enumerate(skipped_list[1:]):
        if skipped_list[j] == c:
            skipped_list[j+1] = "n"
    for c in skipped_list:
        ans += score_map[c]
print(ans)
Buggy code:
n,k=map(int, input().split())
point = [int(i) for i in input().split()]
janken = input()
print(janken)

for i in range(k,n):
  if janken[i] == janken[i-k]:
    janken= janken[0:i]+'0'+janken[i+1:n]
print(janken)

count=0

for i in range(n):
  if janken[i] == 'r':
    count += point[2]
  elif janken[i] == 's':
    count += point[0]
  elif janken[i] == 'p':
    count += point[1]

print(count)

Fixed code:
n,k=map(int, input().split())
point = [int(i) for i in input().split()]
janken = input()

for i in range(k,n):
  if janken[i] == janken[i-k]:
    janken= janken[0:i]+'0'+janken[i+1:n]

count=0

for i in range(n):
  if janken[i] == 'r':
    count += point[2]
  elif janken[i] == 's':
    count += point[0]
  elif janken[i] == 'p':
    count += point[1]

print(count)
Buggy code:
n,k = map(int,input().split())
r,s,p = map(int,input().split())
t = input()
ans = 0
ls = list
for i in range(k):
    if t[i] == "r":
        ls.append("p")
        ans += p
    elif t[i] == "s":
        ls.append("r")
        ans += r
    elif t[i] == "p":
        ls.append("s")
        ans += s
        
for i in range(n):
        if ls[-k] != "r":
            ans += p
            ls.append("p")
        else:
            ls.append("x")
    elif t[i] == "s":
        if ls[-k] != "s":
            ans += r
            ls.append("r")
        else:
            ls.append("x")
    else:
        if ls[-k] != "p":
            ans += s
            ls.append("s")
        else:
            ls.append("x")
print(ans)

Fixed code:
n,k = map(int,input().split())
r,s,p = map(int,input().split())
t = input()
ans = 0
ls = []
for i in range(n):
    if t[i] == "r":
        if len(ls) >= k:
            if ls[-k] != "r":
                ans += p
                ls.append("r")
            else:
                ls.append("x")
        else:
            ans += p
            ls.append("r")
    elif t[i] == "s":
        if len(ls) >= k:
            if ls[-k] != "s":
                ans += r
                ls.append("s")
            else:
                ls.append("x")
        else:
            ans += r
            ls.append("s")
    else:
        if len(ls) >= k:
            if ls[-k] != "p":
                ans += s
                ls.append("p")
            else:
                ls.append("x")
        else:
            ans += s
            ls.append("p")
print(ans)
Buggy code:
from sys import stdin
# import math
N, K = [int(x) for x in stdin.readline().rstrip().split()]
R, S, P = [int(x) for x in stdin.readline().rstrip().split()]
s = input()
ans = 0
d = {'r': P, 's': R, 'p': S}
# print(d)
temp = [0 for i in range(len(s))]
for i, v in enumerate(s):
    # print(i, v, temp)
    if i <= len(s)-K and temp[i] != 1:
        if d[s[i+K]] == d[s[i]]:
            ans += d[s[i]]
            temp[i+K] = 1
        else:
            ans += d[s[i]]
    else:
        if temp[i] != 1:
            ans += d[s[i]]
print(ans)


Fixed code:
from sys import stdin
# import math
N, K = [int(x) for x in stdin.readline().rstrip().split()]
R, S, P = [int(x) for x in stdin.readline().rstrip().split()]
s = input()
ans = 0
d = {'r': P, 's': R, 'p': S}
# print(d)
temp = [0 for i in range(len(s))]
for i, v in enumerate(s):
    # print(i, v, temp)
    if i < len(s)-K and temp[i] != 1:
        if s[i+K] == s[i]:
            ans += d[s[i]]
            temp[i+K] = 1
        else:
            ans += d[s[i]]
    else:
        if temp[i] != 1:
            ans += d[s[i]]
print(ans)
Buggy code:
"""
N K
R S P
T
"""

ln1 = input().split()
ln2 = input().split()
ln3 = input().split()

N, K = int(ln1[0]), int(ln1[1])
R, S, P = int(ln2[0]), int(ln2[1]), int(ln2[2])
T = ln3

point = 0

def janken_result(te):
    if te == "r":
        return P
    elif te == "s":
        return R
    elif te == "p":
        return S
    else:
        exit(0)

for i in range(N):
    if i < K:
        point += janken_result(T[i])
    elif T[i] != T[i-K]:
        point += janken_result(T[i])
    else:
        pass

print(point)


Fixed code:
"""
N K
R S P
T
"""

ln1 = input().split()
ln2 = input().split()
ln3 = input().split()

N, K = int(ln1[0]), int(ln1[1])
R, S, P = int(ln2[0]), int(ln2[1]), int(ln2[2])
T = ln3[0]

point = 0
result = []

def janken_result(te):
    if te == "r":
        return P
    elif te == "s":
        return R
    elif te == "p":
        return S
    else:
        exit(-1)

for i in range(N):
    if i < K:
        point += janken_result(T[i])
        result.append(1)
    elif T[i] != T[i-K]:
        point += janken_result(T[i])
        result.append(1)
    else:
        if result[i-K] == 0:
            point += janken_result(T[i])
            result.append(1)
        else:
            result.append(0)

print(point)
Buggy code:
N, K = map(int, input().split())
R, S, P = map(int, input().split())
T = input()

ret = 0
for i in range(1, K+1):
    prev = '?'
    for j in range(len(T) // K + 1):
        if i + K*j - 1 >= len(T):
            continue
        now = T[i + K*j - 1]
        print(i + K*j - 1)
        count+=1
        if prev == now:
            prev = '?'
        else:
            prev = now
            if now == 'r':  
                ret += P
            elif now == 's':
                ret += R
            else:
                ret += S
            
print(ret)

Fixed code:
N, K = map(int, input().split())
R, S, P = map(int, input().split())
T = input()

ret = 0
for i in range(1, K+1):
    prev = '?'
    for j in range(len(T) // K + 1):
        if i + K*j - 1 >= len(T):
            continue
        now = T[i + K*j - 1]
        
        if prev == now:
            prev = '?'
        else:
            prev = now
            if now == 'r':  
                ret += P
            elif now == 's':
                ret += R
            else:
                ret += S
            
print(ret)
Buggy code:
n,k=map(int,input().split())
r,s,p=map(int,input().split())
t=input()
p_list=[]
score=0
for i in range(len(t)):
    if i<k:
        if t[i]=='r':
            p_list.appned('p')
            score+=p
        elif t[i]=='s':
            p_list.appned('r')
            score+=r
        else:
            p_list.appned('s')
            score+=s
    else:
        if t[i]=='r':
            if t[i-k]=='p':
                if i+k>=len(t):
                    score+=0
                else:
                    p_list.appned(t[i+k])
            else:
                p_list.appned('p')
                score+=p
        elif t[i]=='s':
            if t[i-k]=='r':
                if i+k>=len(t):
                    score+=0
                else:
                    p_list.appned(t[i+k])
            else:
                p_list.appned('r')
                score+=r
        else:
            if t[i-k]=='s':
                if i+k>=len(t):
                    score+=0
                else:
                    p_list.appned(t[i+k])
            else:
                p_list.appned('s')
                score+=s
print(score)


Fixed code:
n,k=map(int,input().split())
r,s,p=map(int,input().split())
t=input()
p_list=[]
score=0
for i in range(len(t)):
    if i<k:
        if t[i]=='r':
            p_list.append('p')
            score+=p
        elif t[i]=='s':
            p_list.append('r')
            score+=r
        else:
            p_list.append('s')
            score+=s
    else:
        if t[i]=='r':
            if p_list[i-k]=='p':
                if i+k>=len(t):
                    p_list.append('a')
                else:
                    p_list.append(t[i+k])
            else:
                p_list.append('p')
                score+=p
        elif t[i]=='s':
            if p_list[i-k]=='r':
                if i+k>=len(t):
                    p_list.append('a')
                else:
                    p_list.append(t[i+k])
            else:
                p_list.append('r')
                score+=r
        else:
            if p_list[i-k]=='s':
                if i+k>=len(t):
                    p_list.append('a')
                else:
                    p_list.append(t[i+k])
            else:
                p_list.append('s')
                score+=s
print(score)
Buggy code:
def main():
    n, k = map(int, input().split())
    r, s, p = map(int, input().split())
    t = list(input())
    score = {"r": p, "s": r, "p": s}
    answer = 0
    for i in range(n):
        if i < k:
            answer += score[t[i]]
        elif i + k < n:
            if t[i][0] != t[i + k][0] or "*" in t[i]:
                answer += score[t[i][0]]
            else:
                t[i + k] = t[i + k] + "*"
        else:
            answer += score[t[i][0]]
    print(answer)


if __name__ == '__main__':
    main()



Fixed code:
def main():
    n, k = map(int, input().split())
    r, s, p = map(int, input().split())
    t = list(input())
    score = {"r": p, "s": r, "p": s}
    answer = 0
    for i in range(n):
        if i < k:
            answer += score[t[i]]
            if i + k < n and t[i] == t[i + k]:
                t[i + k] = t[i + k] + "*"
        elif i + k < n:
            if "*" not in t[i]:
                answer += score[t[i][0]]
                if t[i][0] == t[i + k][0]:
                    t[i + k] = t[i + k] + "*"
        else:
            if "*" not in t[i]:
                answer += score[t[i][0]]
    print(answer)


if __name__ == '__main__':
    main()
Buggy code:
N, K = map(int, input().split())
R, S, P = map(int, input().split())
T = input()

commands = [''] * N
ans = 0
for i, t in enumerate(T):
        if t = 'r':
                command = 'p'
                point = P
        elif t = 's':
                command = 'r':
                point = R
        elif t = 'p':
                command = 's':
                point = S
        if i-K >= 0 and commands[i-K] == command:
                command = ''
                point = 0
        ans += point
        commands[i] = command

print(ans)

Fixed code:
N, K = map(int, input().split())
R, S, P = map(int, input().split())
T = input()

commands = [''] * N
ans = 0
for i, t in enumerate(T):
        if t == 'r':
                command = 'p'
                point = P
        elif t == 's':
                command = 'r'
                point = R
        elif t == 'p':
                command = 's'
                point = S
        if i-K >= 0 and commands[i-K] == command:
                command = ''
                point = 0
        ans += point
        commands[i] = command

print(ans)
Buggy code:
n, k = map(int, input().split())
R, S, P = map(int, input().split())
score = [P, R, S]
t = input()

ans = 0
for i in range(k):
    t2 = ""
    j = 0
    while i + j * k <= n-1:
        t2 += t[i+j*k]
        j += 1
    m = len(t2)
    dp = [[0, 0, 0] for _ in range(m+1)]
    for x in range(m):
        for y in range(3):
            for z in range(3):
                if y != z:
                    if z == 0 and t2[x] == 'r':
                        dp[x+1][z] = dp[x][y] + score[z]
                    if z == 1 and t2[x] == 's':
                        dp[x+1][z] = dp[x][y] + score[z]
                    if z == 2 and t2[x] == 'p':
                        dp[x+1][z] = dp[x][y] + score[z]
                dp[x+1][z] = max(dp[x+1][z], dp[x][y])
    num = 0
    for z in range(3):
        num = max(num, dp[m][z])
    ans += num

print(ans)



Fixed code:
n, k = map(int, input().split())
R, S, P = map(int, input().split())
score = [P, R, S]
t = input()
INF = 10**9

ans = 0
for i in range(k):
    t2 = ""
    j = 0
    while i + j * k <= n-1:
        t2 += t[i+j*k]
        j += 1
    m = len(t2)
    dp = [[-INF, -INF, -INF] for _ in range(m+1)]
    for j in range(3):
        dp[0][j] = 0
    for x in range(m):
        for y in range(3):
            for z in range(3):
                if y != z:
                    if z == 0 and t2[x] == 'r':
                        dp[x+1][z] = max(dp[x+1][z], dp[x][y] + score[z])
                    if z == 1 and t2[x] == 's':
                        dp[x+1][z] = max(dp[x+1][z], dp[x][y] + score[z])
                    if z == 2 and t2[x] == 'p':
                        dp[x+1][z] = max(dp[x+1][z], dp[x][y] + score[z])
                    dp[x+1][z] = max(dp[x+1][z], dp[x][y])
    num = 0
    for z in range(3):
        num = max(num, dp[m][z])
    ans += num

print(ans)
Buggy code:
import math
import sys

n, k = map(int, sys.stdin.readline().rstrip().split())
r, s, p = map(int, sys.stdin.readline().rstrip().split())
t = sys.stdin.readline().rstrip()
ans = 0
sim = []
for i, ti in enumerate(t):
    if ti == 'r':
        if i >= k and sim[i - k] == 'p':
            sim.append('x')
        else:
            ans += p
            sim.append('p')
    elif ti == 's':
        if i >= k and sim[i - k] == 'r':
            sim.append('x')
        else:
            ans += r
            sim.append('r')
    else:
        if i >= k and sim[i - k] == 's':
            sim.append('x')
        else:
            ans += s
            sim.append('s')
print(sim)
print(ans)

Fixed code:
import math
import sys

n, k = map(int, sys.stdin.readline().rstrip().split())
r, s, p = map(int, sys.stdin.readline().rstrip().split())
t = sys.stdin.readline().rstrip()
ans = 0
sim = []
for i, ti in enumerate(t):
    if ti == 'r':
        if i >= k and sim[i - k] == 'p':
            sim.append('x')
        else:
            ans += p
            sim.append('p')
    elif ti == 's':
        if i >= k and sim[i - k] == 'r':
            sim.append('x')
        else:
            ans += r
            sim.append('r')
    else:
        if i >= k and sim[i - k] == 's':
            sim.append('x')
        else:
            ans += s
            sim.append('s')
# print(sim)
print(ans)
Buggy code:
#　149D
n, k = map(int, input().split())
point={}
point['s'],point['p'],point['r'] = map(int, input().split())
s = input()

ans =0
before = [0]*k
for i in range(len(s)):
    if i > k:
        if (s[i] == s[i-k]) & (before[i%k]==1):
            before[i%k] = 0
        else:
            ans += point[s[i]]
            before[i%k] = 1
    else:
        ans += point[s[i]]
        before[i%k] = 1
print(ans)

Fixed code:
#　149D
n, k = map(int, input().split())
point={}
point['s'],point['p'],point['r'] = map(int, input().split())
s = input()

ans =0
before = [0]*k
for i in range(len(s)):
    if i >= k:
        if (s[i] == s[i-k]) & (before[i%k]==1):
            before[i%k] = 0
        else:
            ans += point[s[i]]
            before[i%k] = 1
    else:
        ans += point[s[i]]
        before[i%k] = 1
print(ans)
Buggy code:
p = [int(i) for i in m]
n = input()    
m = n.split()
P = [int(i) for i in m]
n = input()
list = [""]*p[1]
for i, value in enumerate(n):
    list[i%p[1]] =list[i%p[1]] + value
A = 0
for i in list:
    able = [True,True,True]
    for j in i:
        if j == "r":
            if able[2]:
                A = A + P[2]
                able = [True,True,False]
            else:
                able = [True,True,True]
        if j == "s":
            if able[0]:
                A = A + P[0]
                able = [False,True,True]
            else:
                able = [True,True,True]
        if j == "p":
            if able[1]:
                A = A + P[1]
                able = [True,False,True]
            else:
                able = [True,True,True]

print(A)

Fixed code:
n = input()    
m = n.split()
p = [int(i) for i in m]
n = input()    
m = n.split()
P = [int(i) for i in m]
n = input()
list = [""]*p[1]
for i, value in enumerate(n):
    list[i%p[1]] =list[i%p[1]] + value
A = 0
for i in list:
    able = [True,True,True]
    for j in i:
        if j == "r":
            if able[2]:
                A = A + P[2]
                able = [True,True,False]
            else:
                able = [True,True,True]
        if j == "s":
            if able[0]:
                A = A + P[0]
                able = [False,True,True]
            else:
                able = [True,True,True]
        if j == "p":
            if able[1]:
                A = A + P[1]
                able = [True,False,True]
            else:
                able = [True,True,True]

print(A)
Buggy code:
def main():
    N, K = map(int, input().split())
    R, S, P = map(int, input().split())
    T = input()

    def play(com, player):
        if com == 'r' and player == 'p':
            return P
        elif com == 's' and player == 'r':
            return R
        elif com == 'p' and player == 's':
            return S
        else:
            return 0

    score = 0
    for n in range(N):
        if n <= K:
            score += max(play(T[n], 'r'), play(T[n], 's'), play(T[n], 'p'))
        else:
            if T[n - K] == T[n]:
                score += 0
            else:
                score += max(play(T[n], 'r'), play(T[n], 's'), play(T[n], 'p'))

    print(score)


main()


Fixed code:
def main():
    N, K = map(int, input().split())
    R, S, P = map(int, input().split())
    T = input()
    T_ = [True for _ in range(N)]

    def play(com, player):
        if com == 'r' and player == 'p':
            return P
        elif com == 's' and player == 'r':
            return R
        elif com == 'p' and player == 's':
            return S
        else:
            return 0

    score = 0
    for n in range(N):
        if n < K:
            score += max(play(T[n], 'r'), play(T[n], 's'), play(T[n], 'p'))
        else:
            if T[n - K] == T[n] and T_[n - K]:
                score += 0
                T_[n] = False
            else:
                score += max(play(T[n], 'r'), play(T[n], 's'), play(T[n], 'p'))

    print(score)


main()
Buggy code:
n,k = map(int, input().split())
r, s, p = map(int, input().split())
scores = {"r":p,"s":r,"p":s}
T = input()
import numpy as np
subT = [""] * k
for i in range(n):
    ind = i % k 
    subT[ind] += T[i]

ans = 0
for S in subT:
    cnt = 0
    prev = "0"
    for i, s in enumerate(S):
        if i == 0:
            ans += scores[s]
        elif prev == s:
                cnt += 1
                if cnt == 2:
                    ans += scores[s]
                    cnt = 0
        else:
            ans += scores[s]
        prev = s
        

print(ans)

Fixed code:
n,k = map(int, input().split())
r, s, p = map(int, input().split())
scores = {"r":p,"s":r,"p":s}
T = input()
import numpy as np
subT = [""] * k
for i in range(n):
    ind = i % k 
    subT[ind] += T[i]

ans = 0
for S in subT:
    cnt = 0
    prev = "0"
    for i, s in enumerate(S):
        if i == 0:
            ans += scores[s]
        elif prev == s:
            cnt += 1
            if cnt == 2:
                ans += scores[s]
                cnt = 0
        else:
            ans += scores[s]
            cnt = 0
        prev = s
        
        

print(ans)
Buggy code:

def solve(N,K,R,S,P,T):
    check = [0]*N
    ans = 0
    for i in range(N):
        if i < K or T[i] != T[i-K] or not check[i-K]:
            ans += P if T[i] == 'r' else R if T[i] == 's' else S
            check[i] = 1
    print(ans)

def main():
    N, K = map(int, input().split())
    R, S, P = map(int, input().split())
    T = input()
    solve()

if __name__ == "__main__":
    main()

Fixed code:

def solve(N,K,R,S,P,T):
    check = [0]*N
    ans = 0
    for i in range(N):
        if i < K or T[i] != T[i-K] or not check[i-K]:
            ans += P if T[i] == 'r' else R if T[i] == 's' else S
            check[i] = 1
    print(ans)

def main():
    N, K = map(int, input().split())
    R, S, P = map(int, input().split())
    T = input()
    solve(N,K,R,S,P,T)

if __name__ == "__main__":
    main()
Buggy code:
args=input().split()
N=int(args[0])
K=int(args[1])
args=input().split()
R=int(args[0])
S=int(args[1])
P=int(args[2])
T=input()

resSS=[]
for i in T:
  if i=="r":
    resSS.append(P)
  elif i=="s":
    resSS.append(R)
  else:
    resSS.append(S)

if N>=K:
  for i in range(N-K):
    if T[i+K]==T[i]:
      resSS[i+K]=0
res=0
for i in resSS:
  res+=i
print(res)


Fixed code:
args=input().split()
N=int(args[0])
K=int(args[1])
args=input().split()
R=int(args[0])
S=int(args[1])
P=int(args[2])
T=input()

resSS=[]
for i in T:
  if i=="r":
    resSS.append(P)
  elif i=="s":
    resSS.append(R)
  else:
    resSS.append(S)

if N>=K:
  for i in range(N-K):
    if T[i+K]==T[i] and resSS[i+K]==resSS[i]:
      resSS[i+K]=0
res=0
for i in resSS:
  res+=i
print(res)
Buggy code:
def f(x):
    if x == "r":
        return "p"
    elif x == "s":
        return "r"
    else:
        return "s"

def g(x):
    if x == "r":
        return r
    elif x == "s":
        return s
    else:
        return p 
n,k = map(int,input().split())

r,s,p = map(int,input().split())

t = str(input())
ssssppr
m = n
a = 0
ss = [' '] ** m

if m <= k:
    for i in range(m):
        a += g(f(t[i]))
    print(a)
else:
    for i in range(k):
        a += g(f(t[i]))
        ss[i] = f(t[i])
    for i in range(k,m):
        if t[i-k] != t[i]:
            a += g(f(t[i]))
            ss[i] = f(t[i])
        elif (t[i-k] == t[i]) and (ss[i-k] != f(t[i])):
            a += g(f(t[i]))
            ss[i] = f(t[i])
    print(a)
    

Fixed code:
def f(x):
    if x == "r":
        return "p"
    elif x == "s":
        return "r"
    else:
        return "s"

def g(x):
    if x == "r":
        return r
    elif x == "s":
        return s
    else:
        return p 

n,k = map(int,input().split())

r,s,p = map(int,input().split())

t = str(input())

m = n
a = 0
ss = [' '] * m

if m <= k:
    for i in range(m):
        a += g(f(t[i]))
    print(a)
else:
    for i in range(k):
        a += g(f(t[i]))
        ss[i] = f(t[i])
    for i in range(k,m):
        if t[i-k] != t[i]:
            a += g(f(t[i]))
            ss[i] = f(t[i])
        elif (t[i-k] == t[i]) and (ss[i-k] != f(t[i])):
            a += g(f(t[i]))
            ss[i] = f(t[i])
    print(a)
Buggy code:
n, k = map(int, input().split())
r, s, p = map(int, input().split())
T=list(input())

commands = [""]*n
ans = 0

for i, t in enumerate(T):
    if t == "p":
        point = s
    elif t == "s":
        point = r
    elif t == "r":
        point = p

    if(i - k) >= 0 and (commands[i-k] == command):
        point = 0

    ans += point
print(ans)


Fixed code:
n, k = map(int, input().split())
r, s, p = map(int, input().split())
T=list(input())

commands = [""]*n
ans = 0

for i, t in enumerate(T):
    if t == "p":
        command = "s"
        point = s
    elif t == "s":
        command = "r"
        point = r
    elif t == "r":
        command = "p"
        point = p

    if(i - k) >= 0 and (commands[i-k] == command):
        command = ""
        point = 0

    ans += point
    commands[i] = command
print(ans)
Buggy code:
n, k = map(int, input().split())
r, s, p = map(int, input().split())
t = str(input())
syo = n//k 
total = 0
for i in range(k):
  for j in range(i, n, k):
    if j == i or score == 0 or t[j] ?= te:
      if t[j] = 'r'
      	score = p
      	total += p
        te = 'p'
      elif t[j] = 's'
      	score = r
      	total += r
        te = 'r'
      else:
        score = s
        total += s
        te = 's'
    else:
      score = 0
      
  
print(total)

Fixed code:
n, k = map(int, input().split())
r, s, p = map(int, input().split())
t = str(input())
syo = n//k 
total = 0
for i in range(k):
  te = ''
  score = 0
  for j in range(i, n, k):
    if score == 0 or t[j] != te:
      if t[j] == 'r':
        score = p
        total += p
        te = 'r'
      elif t[j] == 's':
        score = r
        total += r
        te = 's'
      else:
        score = s
        total += s
        te = 'p'
    else:
      score = 0
      
  
print(total)