For problem statement at 1000-1999/1300-1399/1370-1379/1373/problemG.txt this is a correct solution, but verifier at 1000-1999/1300-1399/1370-1379/1373/verifierG.go ends with mismatch on test 1: expected 0
0
0
1
2
9
10
11
12
13
14
15
16
17
18 got 0
0
0
0
0
4
4
4
4
4
4
4
5
6
7
exit status 1 can you fix the verifier? package main

import (
	"bufio"
	"fmt"
	"os"
)

type Node struct {
	maxA int
	lazy int
	maxV int
}

var tree []Node

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func build(node, l, r int) {
	if l == r {
		tree[node].maxA = l
		tree[node].maxV = 0
		return
	}
	mid := (l + r) / 2
	build(node*2, l, mid)
	build(node*2+1, mid+1, r)
	tree[node].maxA = max(tree[node*2].maxA, tree[node*2+1].maxA)
}

func pushDown(node int) {
	if tree[node].lazy != 0 {
		lz := tree[node].lazy
		tree[node*2].maxA += lz
		tree[node*2].lazy += lz
		tree[node*2+1].maxA += lz
		tree[node*2+1].lazy += lz
		tree[node].lazy = 0
	}
}

func updateRange(node, l, r, ql, qr, val int) {
	if ql <= l && r <= qr {
		tree[node].maxA += val
		tree[node].lazy += val
		return
	}
	pushDown(node)
	mid := (l + r) / 2
	if ql <= mid {
		updateRange(node*2, l, mid, ql, qr, val)
	}
	if qr > mid {
		updateRange(node*2+1, mid+1, r, ql, qr, val)
	}
	tree[node].maxA = max(tree[node*2].maxA, tree[node*2+1].maxA)
}

func updateMaxV(node, l, r, idx, val int) {
	if l == r {
		tree[node].maxV = val
		return
	}
	mid := (l + r) / 2
	if idx <= mid {
		updateMaxV(node*2, l, mid, idx, val)
	} else {
		updateMaxV(node*2+1, mid+1, r, idx, val)
	}
	tree[node].maxV = max(tree[node*2].maxV, tree[node*2+1].maxV)
}

func queryMaxA(node, l, r, ql, qr int) int {
	if ql <= l && r <= qr {
		return tree[node].maxA
	}
	pushDown(node)
	mid := (l + r) / 2
	res := -1
	if ql <= mid {
		res = queryMaxA(node*2, l, mid, ql, qr)
	}
	if qr > mid {
		res = max(res, queryMaxA(node*2+1, mid+1, r, ql, qr))
	}
	return res
}

func abs(x int) int {
	if x < 0 {
		return -x
	}
	return x
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	var n, k, m int
	if _, err := fmt.Fscanf(reader, "%d %d %d\n", &n, &k, &m); err != nil {
		return
	}

	N := 2 * n
	tree = make([]Node, 4*N+1)
	build(1, 1, N)

	c := make([]int, N+1)
	pawns := make(map[int64]bool)

	for i := 0; i < m; i++ {
		var x, y int
		fmt.Fscanf(reader, "%d %d\n", &x, &y)

		v := y + abs(x-k)
		key := int64(x)*300000 + int64(y)

		if pawns[key] {
			delete(pawns, key)
			c[v]--
			if c[v] == 0 {
				updateMaxV(1, 1, N, v, 0)
			}
			updateRange(1, 1, N, 1, v, -1)
		} else {
			pawns[key] = true
			c[v]++
			if c[v] == 1 {
				updateMaxV(1, 1, N, v, v)
			}
			updateRange(1, 1, N, 1, v, 1)
		}

		M := tree[1].maxV
		if M == 0 {
			fmt.Fprintln(writer, 0)
		} else {
			ans := queryMaxA(1, 1, N, 1, M) - 1 - n
			if ans < 0 {
				ans = 0
			}
			fmt.Fprintln(writer, ans)
		}
	}
}