@file:Suppress("NOTHING_TO_INLINE", "EXPERIMENTAL_FEATURE_WARNING", "OVERRIDE_BY_INLINE")
//@file:OptIn(ExperimentalStdlibApi::class)

import java.io.PrintWriter
import java.util.Arrays
import java.util.NoSuchElementException
import java.util.TreeSet
import kotlin.math.*
import kotlin.random.Random
import kotlin.collections.sort as _sort
import kotlin.collections.sortDescending as _sortDescending
import kotlin.io.println as iprintln


/** @author Spheniscine */
fun main() { _writer.solve(); _writer.flush() }

fun PrintWriter.solve() {
//    val startTime = System.nanoTime()

    val numCases = 1//readInt()
    case@ for(case in 1..numCases) {
        //print("Case #$case: ")

        val D = readInt()

        val C = readIntArray(26)
        val S = Array(D) { readIntArray(26) }

        var v = 0L
        val last = IntArray(26)
        val L = Array(26) { IntTreeSet().also {
            it.add(-1)
            it.add(D)
        } }
        val T = IntArray(D) { readInt()-1 }
        repeat(D) { d ->
            val t = T[d]

            v += S[d][t]
            last[t] = d+1
            for(i in 0 until 26) {
                v -= C[i] * (d+1 - last[i])
            }

            L[t].add(d)
        }

        val M = readInt()
        repeat(M) {
            val d = readInt()-1
            val q = readInt()-1

            val t = T[d]
            v += S[d][q] - S[d][t]

            L[t].remove(d)
            var a = L[t].floor(d)
            var b = L[t].ceiling(d)
            v -= C[t] * (d-a) * (b-d)

            a = L[q].floor(d)
            b = L[q].ceiling(d)
            v += C[q] * (d-a) * (b-d)
            L[q].add(d)

            T[d] = q
            println(v)
        }
    }

//    iprintln("Time: ${(System.nanoTime() - startTime) / 1000000} ms")
}

typealias IntTreeSet = _Ez_Int_TreeSet

class _Ez_Int_TreeSet @JvmOverloads constructor(capacity: Int = DEFAULT_CAPACITY) {
    // Arrays are 1-indexed. Index 0 is a null node.
    private /*C*/  var key: IntArray
    private var left: IntArray
    private var right: IntArray
    private var p: IntArray
    private var color: BooleanArray
    private var size = 0
    private var root = 0
    private var returnedNull = false

    constructor( /*C*/
        srcArray: IntArray
    ) : this(srcArray.size) {
        for ( /*C*/
        /*C*/element in srcArray) {
            add(element)
        }
    }

    fun size(): Int {
        return size
    }

    val isEmpty: Boolean
        get() = size == 0

    operator fun contains( /*C*/
        /*C*/element: Int
    ): Boolean {
        var x = root
        while (x != NULL) {
            x = if (element < key[x]) {
                left[x]
            } else if (element > key[x]) {
                right[x]
            } else {
                return true
            }
        }
        return false
    }

    operator fun iterator() = _Ez_Int_TreeSetIterator() as IntIterator

    /*C*/   fun toArray(): IntArray {
        /*C*/
        val result = IntArray(size)
        var i = 0
        var x = firstNode()
        while (x != NULL) {
            result[i] = key[x]
            x = successorNode(x)
            i++
        }
        return result
    }

    fun add( /*C*/
        /*C*/element: Int
    ): Boolean {
        var y = NULL
        var x = root
        while (x != NULL) {
            y = x
            x = if (element < key[x]) {
                left[x]
            } else if (element > key[x]) {
                right[x]
            } else {
                return false
            }
        }
        if (size == color.size - 1) {
            enlarge()
        }
        val z = ++size
        key[z] = element
        p[z] = y
        if (y == NULL) {
            root = z
        } else {
            if (element < key[y]) {
                left[y] = z
            } else {
                right[y] = z
            }
        }
        left[z] = NULL
        right[z] = NULL
        color[z] = RED
        fixAfterAdd(z)
        return true
    }

    fun remove( /*C*/
        /*C*/element: Int
    ): Boolean {
        var z = root
        while (z != NULL) {
            z = if (element < key[z]) {
                left[z]
            } else if (element > key[z]) {
                right[z]
            } else {
                removeNode(z)
                return true
            }
        }
        return false
    }

    private fun removeNode(z: Int) {
        val y =
            if (left[z] == NULL || right[z] == NULL) z else successorNode(
                z
            )
        val x = if (left[y] != NULL) left[y] else right[y]
        p[x] = p[y]
        if (p[y] == NULL) {
            root = x
        } else {
            if (y == left[p[y]]) {
                left[p[y]] = x
            } else {
                right[p[y]] = x
            }
        }
        if (y != z) {
            key[z] = key[y]
        }
        if (color[y] == BLACK) {
            fixAfterRemove(x)
        }
        // Swap with last
        if (y != size) {
            // copy fields
            key[y] = key[size]
            left[y] = left[size]
            right[y] = right[size]
            p[y] = p[size]
            color[y] = color[size]
            // fix the children's parents
            p[left[size]] = y
            p[right[size]] = y
            // fix one of the parent's children
            if (left[p[size]] == size) {
                left[p[size]] = y
            } else {
                right[p[size]] = y
            }
            // fix root
            if (root == size) {
                root = y
            }
        }
        size--
    }

    private fun successorNode(x: Int): Int {
        var x = x
        return if (right[x] != NULL) {
            x = right[x]
            while (left[x] != NULL) {
                x = left[x]
            }
            x
        } else {
            var y = p[x]
            while (y != NULL && x == right[y]) {
                x = y
                y = p[y]
            }
            y
        }
    }

    private fun fixAfterAdd(z: Int) {
        var z = z
        while (color[p[z]] == RED) {
            if (p[z] == left[p[p[z]]]) {
                val y = right[p[p[z]]]
                if (color[y] == RED) {
                    color[p[z]] = BLACK
                    color[y] = BLACK
                    color[p[p[z]]] = RED
                    z = p[p[z]]
                } else {
                    if (z == right[p[z]]) {
                        z = p[z]
                        rotateLeft(z)
                    }
                    color[p[z]] = BLACK
                    color[p[p[z]]] = RED
                    rotateRight(p[p[z]])
                }
            } else {
                val y = left[p[p[z]]]
                if (color[y] == RED) {
                    color[p[z]] = BLACK
                    color[y] = BLACK
                    color[p[p[z]]] = RED
                    z = p[p[z]]
                } else {
                    if (z == left[p[z]]) {
                        z = p[z]
                        rotateRight(z)
                    }
                    color[p[z]] = BLACK
                    color[p[p[z]]] = RED
                    rotateLeft(p[p[z]])
                }
            }
        }
        color[root] = BLACK
    }

    private fun fixAfterRemove(x: Int) {
        var x = x
        while (x != root && color[x] == BLACK) {
            if (x == left[p[x]]) {
                var w = right[p[x]]
                if (color[w] == RED) {
                    color[w] = BLACK
                    color[p[x]] = RED
                    rotateLeft(p[x])
                    w = right[p[x]]
                }
                if (color[left[w]] == BLACK && color[right[w]] == BLACK) {
                    color[w] = RED
                    x = p[x]
                } else {
                    if (color[right[w]] == BLACK) {
                        color[left[w]] = BLACK
                        color[w] = RED
                        rotateRight(w)
                        w = right[p[x]]
                    }
                    color[w] = color[p[x]]
                    color[p[x]] = BLACK
                    color[right[w]] = BLACK
                    rotateLeft(p[x])
                    x = root
                }
            } else {
                var w = left[p[x]]
                if (color[w] == RED) {
                    color[w] = BLACK
                    color[p[x]] = RED
                    rotateRight(p[x])
                    w = left[p[x]]
                }
                if (color[left[w]] == BLACK && color[right[w]] == BLACK) {
                    color[w] = RED
                    x = p[x]
                } else {
                    if (color[left[w]] == BLACK) {
                        color[right[w]] = BLACK
                        color[w] = RED
                        rotateLeft(w)
                        w = left[p[x]]
                    }
                    color[w] = color[p[x]]
                    color[p[x]] = BLACK
                    color[left[w]] = BLACK
                    rotateRight(p[x])
                    x = root
                }
            }
        }
        color[x] = BLACK
    }

    private fun rotateLeft(x: Int) {
        val y = right[x]
        right[x] = left[y]
        if (left[y] != NULL) {
            p[left[y]] = x
        }
        p[y] = p[x]
        if (p[x] == NULL) {
            root = y
        } else {
            if (x == left[p[x]]) {
                left[p[x]] = y
            } else {
                right[p[x]] = y
            }
        }
        left[y] = x
        p[x] = y
    }

    private fun rotateRight(x: Int) {
        val y = left[x]
        left[x] = right[y]
        if (right[y] != NULL) {
            p[right[y]] = x
        }
        p[y] = p[x]
        if (p[x] == NULL) {
            root = y
        } else {
            if (x == right[p[x]]) {
                right[p[x]] = y
            } else {
                left[p[x]] = y
            }
        }
        right[y] = x
        p[x] = y
    }

    fun clear() {
        color[NULL] = BLACK
        size = 0
        root = NULL
    }

    private fun enlarge() {
        val newLength =
            Math.max(color.size + 1, (color.size * ENLARGE_SCALE).toInt())
        key = Arrays.copyOf(key, newLength)
        left = Arrays.copyOf(left, newLength)
        right = Arrays.copyOf(right, newLength)
        p = Arrays.copyOf(p, newLength)
        color = Arrays.copyOf(color, newLength)
    }

    private fun firstNode(): Int {
        var x = root
        while (left[x] != NULL) {
            x = left[x]
        }
        return x
    }

    private fun lastNode(): Int {
        var x = root
        while (right[x] != NULL) {
            x = right[x]
        }
        return x
    }

    /*C*/  /*C*/
    val first: Int
        get() {
            if (root == NULL) {
                returnedNull = true
                return DEFAULT_NULL_ELEMENT
            }
            val x = firstNode()
            returnedNull = false
            return key[x]
        }

    /*C*/  /*C*/
    val last: Int
        get() {
            if (root == NULL) {
                returnedNull = true
                return DEFAULT_NULL_ELEMENT
            }
            val x = lastNode()
            returnedNull = false
            return key[x]
        }

    /*C*/   fun  /*C*/removeFirst(): Int {
        if (root == NULL) {
            returnedNull = true
            return DEFAULT_NULL_ELEMENT
        }
        val x = firstNode()
        returnedNull = false
        val   /*C*/removedElement = key[x]
        removeNode(x)
        return removedElement
    }

    /*C*/   fun  /*C*/removeLast(): Int {
        if (root == NULL) {
            returnedNull = true
            return DEFAULT_NULL_ELEMENT
        }
        val x = lastNode()
        returnedNull = false
        val   /*C*/removedElement = key[x]
        removeNode(x)
        return removedElement
    }

    /*C*/   fun  /*C*/floor( /*C*/
        /*C*/element: Int
    ): Int {
        var x = root
        while (x != NULL) {
            if (element > key[x]) {
                if (right[x] != NULL) {
                    x = right[x]
                } else {
                    returnedNull = false
                    return key[x]
                }
            } else if (element < key[x]) {
                if (left[x] != NULL) {
                    x = left[x]
                } else {
                    var y = p[x]
                    while (y != NULL && x == left[y]) {
                        x = y
                        y = p[y]
                    }
                    return if (y == NULL) {
                        returnedNull = true
                        DEFAULT_NULL_ELEMENT
                    } else {
                        returnedNull = false
                        key[y]
                    }
                }
            } else {
                returnedNull = false
                return key[x]
            }
        }
        returnedNull = true
        return DEFAULT_NULL_ELEMENT
    }

    /*C*/   fun  /*C*/ceiling( /*C*/
        /*C*/element: Int
    ): Int {
        var x = root
        while (x != NULL) {
            if (element < key[x]) {
                if (left[x] != NULL) {
                    x = left[x]
                } else {
                    returnedNull = false
                    return key[x]
                }
            } else if (element > key[x]) {
                if (right[x] != NULL) {
                    x = right[x]
                } else {
                    var y = p[x]
                    while (y != NULL && x == right[y]) {
                        x = y
                        y = p[y]
                    }
                    return if (y == NULL) {
                        returnedNull = true
                        DEFAULT_NULL_ELEMENT
                    } else {
                        returnedNull = false
                        key[y]
                    }
                }
            } else {
                returnedNull = false
                return key[x]
            }
        }
        returnedNull = true
        return DEFAULT_NULL_ELEMENT
    }

    /*C*/   fun  /*C*/lower( /*C*/
        /*C*/element: Int
    ): Int {
        var x = root
        while (x != NULL) {
            if (element > key[x]) {
                if (right[x] != NULL) {
                    x = right[x]
                } else {
                    returnedNull = false
                    return key[x]
                }
            } else {
                if (left[x] != NULL) {
                    x = left[x]
                } else {
                    var y = p[x]
                    while (y != NULL && x == left[y]) {
                        x = y
                        y = p[y]
                    }
                    return if (y == NULL) {
                        returnedNull = true
                        DEFAULT_NULL_ELEMENT
                    } else {
                        returnedNull = false
                        key[y]
                    }
                }
            }
        }
        returnedNull = true
        return DEFAULT_NULL_ELEMENT
    }

    /*C*/   fun  /*C*/higher( /*C*/
        /*C*/element: Int
    ): Int {
        var x = root
        while (x != NULL) {
            if (element < key[x]) {
                if (left[x] != NULL) {
                    x = left[x]
                } else {
                    returnedNull = false
                    return key[x]
                }
            } else {
                if (right[x] != NULL) {
                    x = right[x]
                } else {
                    var y = p[x]
                    while (y != NULL && x == right[y]) {
                        x = y
                        y = p[y]
                    }
                    return if (y == NULL) {
                        returnedNull = true
                        DEFAULT_NULL_ELEMENT
                    } else {
                        returnedNull = false
                        key[y]
                    }
                }
            }
        }
        returnedNull = true
        return DEFAULT_NULL_ELEMENT
    }

    fun returnedNull(): Boolean {
        return returnedNull
    }

    override fun equals(o: Any?): Boolean {
        if (this === o) return true
        if (o == null || javaClass != o.javaClass) return false
        val that = o as _Ez_Int_TreeSet
        if (size != that.size) {
            return false
        }
        var x = firstNode()
        var y = that.firstNode()
        while (x != NULL) {
            if (key[x] != that.key[y]) {
                return false
            }
            x = successorNode(x)
            y = that.successorNode(y)
        }
        return true
    }

    override fun toString(): String {
        val sb = StringBuilder()
        sb.append('[')
        var x = firstNode()
        while (x != NULL) {
            if (sb.length > 1) {
                sb.append(", ")
            }
            sb.append(key[x])
            x = successorNode(x)
        }
        sb.append(']')
        return sb.toString()
    }

    private inner class _Ez_Int_TreeSetIterator constructor() : IntIterator() {
        private var x: Int
        override fun hasNext(): Boolean {
            return x != NULL
        }

        /*C*/   override fun  /*C*/nextInt(): Int {
            if (x == NULL) {
                throw NoSuchElementException("Iterator doesn't have more elements")
            }
            val   /*C*/result = key[x]
            x = successorNode(x)
            return result
        }

        init {
            x = firstNode()
        }
    }

    companion object {
        private const val DEFAULT_CAPACITY = 10
        private const val ENLARGE_SCALE = 2.0
        private const val HASHCODE_INITIAL_VALUE = -0x7ee3623b
        private const val HASHCODE_MULTIPLIER = 0x01000193
        private const val BLACK = false
        private const val RED = true
        private const val NULL = 0
        private  /*C*/ val   /*C*/DEFAULT_NULL_ELEMENT = IntArray(1)[0]
    }

    init {
        var capacity = capacity
        require(capacity >= 0) { "Capacity must be non-negative" }
        capacity++
        key = IntArray(capacity)
        left = IntArray(capacity)
        right = IntArray(capacity)
        p = IntArray(capacity)
        color = BooleanArray(capacity)
        color[NULL] = BLACK
        size = 0
        root = NULL
        returnedNull = false
    }
}

/** IO */
//@JvmField val INPUT = File("input.txt").inputStream()
//@JvmField val OUTPUT = File("output.txt").outputStream()
@JvmField val INPUT = System.`in`
@JvmField val OUTPUT = System.out

const val _BUFFER_SIZE = 1 shl 16
@JvmField val _buffer = ByteArray(_BUFFER_SIZE)
@JvmField var _bufferPt = 0
@JvmField var _bytesRead = 0

tailrec fun readChar(): Char {
    if(_bufferPt == _bytesRead) {
        _bufferPt = 0
        _bytesRead = INPUT.read(_buffer, 0, _BUFFER_SIZE)
    }
    return if(_bytesRead < 0) Char.MIN_VALUE
    else {
        val c = _buffer[_bufferPt++].toChar()
        if (c == '\r') readChar()
        else c
    }
}

fun readLine(): String? {
    var c = readChar()
    return if(c == Char.MIN_VALUE) null
    else buildString {
        while(c != '\n' && c != Char.MIN_VALUE) {
            append(c)
            c = readChar()
        }
    }
}
fun readLn() = readLine()!!

fun read() = buildString {
    var c = readChar()
    while(c <= ' ') {
        if(c == Char.MIN_VALUE) return@buildString
        c = readChar()
    }
    do {
        append(c)
        c = readChar()
    } while(c > ' ')
}
fun readInt() = read().toInt()
fun readDouble() = read().toDouble()
fun readLong() = read().toLong()
fun readStrings(n: Int) = List(n) { read() }
fun readLines(n: Int) = List(n) { readLn() }
fun readInts(n: Int) = List(n) { read().toInt() }
fun readIntArray(n: Int) = IntArray(n) { read().toInt() }
fun readDoubles(n: Int) = List(n) { read().toDouble() }
fun readDoubleArray(n: Int) = DoubleArray(n) { read().toDouble() }
fun readLongs(n: Int) = List(n) { read().toLong() }
fun readLongArray(n: Int) = LongArray(n) { read().toLong() }

@JvmField val _writer = PrintWriter(OUTPUT, false)

/** shuffles and sort overrides to avoid quicksort attacks */
private inline fun <T> _shuffle(rnd: Random, get: (Int) -> T, set: (Int, T) -> Unit, size: Int) {
    // Fisher-Yates shuffle algorithm
    for (i in size - 1 downTo 1) {
        val j = rnd.nextInt(i + 1)
        val temp = get(i)
        set(i, get(j))
        set(j, temp)
    }
}

@JvmField var _random: Random? = null
val random get() = _random ?: Random(0x594E215C123 * System.nanoTime()).also { _random = it }

fun IntArray.shuffle(rnd: Random = random) = _shuffle(rnd, ::get, ::set, size)
fun IntArray.sort() { shuffle(); _sort() }
fun IntArray.sortDescending() { shuffle(); _sortDescending() }

fun LongArray.shuffle(rnd: Random = random) = _shuffle(rnd, ::get, ::set, size)
fun LongArray.sort() { shuffle(); _sort() }
fun LongArray.sortDescending() { shuffle(); _sortDescending() }

fun DoubleArray.shuffle(rnd: Random = random) = _shuffle(rnd, ::get, ::set, size)
fun DoubleArray.sort() { shuffle(); _sort() }
fun DoubleArray.sortDescending() { shuffle(); _sortDescending() }

fun CharArray.shuffle(rnd: Random = random) = _shuffle(rnd, ::get, ::set, size)
inline fun CharArray.sort() { _sort() }
inline fun CharArray.sortDescending() { _sortDescending() }

inline fun <T: Comparable<T>> Array<out T>.sort() = _sort()
inline fun <T: Comparable<T>> Array<out T>.sortDescending() = _sortDescending()
inline fun <T: Comparable<T>> MutableList<out T>.sort() = _sort()
inline fun <T: Comparable<T>> MutableList<out T>.sortDescending() = _sortDescending()

fun `please stop removing these imports IntelliJ`() { iprintln(max(1, 2)) }

/** additional commons */
inline fun <T> Iterable<T>.sumByLong(func: (T) -> Long) = fold(0L) { acc, t -> acc + func(t) }
inline fun <T> Sequence<T>.sumByLong(func: (T) -> Long) = fold(0L) { acc, t -> acc + func(t) }
inline fun <T> Array<T>.sumByLong(func: (T) -> Long) = fold(0L) { acc, t -> acc + func(t) }
fun IntArray.sumLong() = fold(0L, Long::plus)


Measured memory_bytes: 53908