Problem:
"Local search" is a powerful method for finding a high-quality solution. In this method, instead of constructing a solution from scratch, we try to find a better solution by slightly modifying the already found solution. If the solution gets better, update it, and if it gets worse, restore it. By repeating this process, the quality of the solution is gradually improved over time. The pseudo-code is as follows.                solution = compute an initial solution (by random generation, or by applying other methods such as greedy) while the remaining time > 0:     slightly modify the solution (randomly)     if the solution gets worse:         restore the solution   For example, in this problem, we can use the following modification: pick the date d and contest type q at random and change the type of contest to be held on day d to q. The pseudo-code is as follows.                t[1..D] = compute an initial solution (by random generation, or by applying other methods such as greedy) while the remaining time > 0:     pick d and q at random     old = t[d] # Remember the original value so that we can restore it later     t[d] = q     if the solution gets worse:         t[d] = old   The most important thing when using the local search method is the design of how to modify solutions.    1. If the amount of modification is too small, we will soon fall into a dead-end (local optimum) and, conversely, if the amount of modification is too large, the probability of finding an improving move becomes extremely small.   2. In order to increase the number of iterations, it is desirable to be able to quickly calculate the score after applying a modification.  In this problem C, we focus on the second point. The score after the modification can, of course, be obtained by calculating the score from scratch. However, by focusing on only the parts that have been modified, it may be possible to quickly compute the difference between the scores before and after the modification. From another viewpoint, the impossibility of such a fast incremental calculation implies that a small modification to the solution affects a majority of the score calculation. In such a case, we may need to redesign how to modify solutions, or there is a high possibility that the problem is not suitable for local search. Let's implement fast incremental score computation. It's time to demonstrate the skills of algorithms and data structures you have developed in ABC and ARC!  In this kind of contest, where the objective is to find a better solution instead of the optimal one, a bug in a program does not result in a wrong answer, which may delay the discovery of the bug. For early detection of bugs, it is a good idea to unit test functions you implemented complicated routines. For example, if you implement fast incremental score calculation, it is a good idea to test that the scores computed by the fast implementation match the scores computed from scratch, as we will do in this problem C.

Incorrect submission (verdict: Wrong Answer):
0

Fixed, accepted submission:
from numba import njit
from numpy import int64,zeros
@njit('i8(i8[:],i8[:])',cache=True)
def func(s,x):
    last=zeros(26,int64)
    score=0
    for i,v in enumerate(x,1):
        last[v]=i
        c=0
        for j in range(26):
            c+=s[j]*(i-last[j])
        score+=s[i*26+v]-c
    return score
def main():
    d,*s=map(int,open(0).read().split())
    s=int64(s)
    x=s[26*-~d:d*27+26]-1
    for d,q in s[27*-~d:].reshape(-1,2):
        x[d-1]=q-1
        print(func(s,x))
main()