Dynamic Sum Pair Queries

You are given two arrays of integers a and b, and an array queries, the elements of which are queries you are required to process. Every queries[i] can have one of the following two forms:
[0, i, x]. In this case, you need to assign a[i] the value of x (a[i] = x).
[1, x]. In this case, you need to find the total number of pairs of indices i and j such that a[i] + b[j] = x.
Perform the given queries in order and return an array containing the results of the queries of the type [1, x].

Function
solution(a: int[], b: int[], queries: int[][]) → long[]

Examples
Example 1
a = [3,4]
b = [1,2,3]
queries = [[1,5],[0,0,1],[1,5]]
return = [2,1]
For a = [3, 4], b = [1, 2, 3], and queries = [[1, 5], [0, 0, 1], [1, 5]], the output should be solution(a, b, queries) = [2, 1].
The arrays look like this initially:
a = [3, 4] and b = [1, 2, 3]
For the query [1, 5], there are two ways to form a sum of 5 using an element from each array: 5 = 3 + 2 = a[0] + b[1] and 5 = 4 + 1 = a[1] + b[0]. So the result is 2.
The query [0, 0, 1] re-assigns the value of a[0] to 1, so the arrays now look like this:
a = [1, 4] and b = [1, 2, 3]
For the final [1, 5] query, there's now only one way to form a sum of 5 using an element from each array: 5 = 4 + 1 = a[1] + b[0]. So the result is 1.
Since the two queries of type [1, x] gave results of 2 and 1 respectively, the answer is [2, 1].
Example 2
a = [2,3]
b = [1,2,2]
queries = [[1,4],[0,0,3],[1,5]]
return = [3,4]
For a = [2, 3], b = [1, 2, 2], and queries = [[1, 4], [0, 0, 3], [1, 5]], the output should be solution(a, b, queries) = [3, 4].
The arrays look like this initially:
a = [2, 3] and b = [1, 2, 2]
The remainder of this explanation is cropped from the source image.

Constraints
FastPrep execution-adapter constraints (not shown in the source image):
a and b are non-empty integer arrays.
queries is non-empty.
Every query is either [0, i, x] or [1, x].
Every update index i is valid for a.

The trick is to count values, not indices. Build a hash map of counts for b once, since b never changes. Keep a hash map of counts for a too. For a type 1 query with target x, loop over the distinct values v in a's map and add countA[v] * countB[x - v]. For a type 0 query, decrement the count of the old a[i], increment the count of the new x, and write a[i] = x. The common pitfall is forgetting that duplicates multiply, as Example 2 shows with b = [1,2,2]. Another is overflow: the return type is long, so use 64-bit math. If the query count is large and a has many distinct values, consider flipping the loop to iterate whichever map is smaller. If you freeze mid-OA, StealthCoder can supply the map-based solution while you keep your head clear.

The honest play: practice the pattern, and have StealthCoder ready for the one you didn't see coming.