func_code_string: #include <bits/stdc++.h>   template <class T>   inline bool chmax(T& a, T b) {     if (a < b) {       a = b;       return 1;     }     return 0;   }   template <class T>   inline bool chmin(T& a, T b) {     if (a > b) {       a = b;       return 1;     }     return 0;   }   constexpr long long MAX = 5100000;   constexpr long long INF = 1LL << 60;   constexpr int inf = 1000000007;   constexpr long long mod = 1000000007LL;   const long double PI = acos((long double)(-1));   using namespace std;   int f(int a, int b) { return max(a, b); }   int g(int a, int b) { return a + b; }   int h(int a, int b) { return a + b; }   template <typename Monoid, typename OperatorMonoid = Monoid>   struct LazySegmentTree {     int sz, height;     vector<Monoid> data;     vector<OperatorMonoid> lazy;     const Monoid M1;     const OperatorMonoid OM0;     LazySegmentTree(int n, const Monoid& M1, const OperatorMonoid OM0)         : M1(M1), OM0(OM0) {       sz = 1;       height = 0;       while (sz < n) sz <<= 1, height++;       data.assign(2 * sz, M1);       lazy.assign(2 * sz, OM0);     }     void set(int k, const Monoid& x) { data[k + sz] = x; }     void build() {       for (int k = sz - 1; k > 0; k--) {         data[k] = f(data[2 * k + 0], data[2 * k + 1]);       }     }     inline void propagate(int k) {       if (lazy[k] != OM0) {         lazy[2 * k + 0] = h(lazy[2 * k + 0], lazy[k]);         lazy[2 * k + 1] = h(lazy[2 * k + 1], lazy[k]);         data[k] = reflect(k);         lazy[k] = OM0;       }     }     inline Monoid reflect(int k) {       return lazy[k] == OM0 ? data[k] : g(data[k], lazy[k]);     }     inline void recalc(int k) {       while (k >>= 1) data[k] = f(reflect(2 * k + 0), reflect(2 * k + 1));     }     inline void thrust(int k) {       for (int i = height; i > 0; i--) propagate(k >> i);     }     void update(int a, int b, const OperatorMonoid& x) {       if (a >= b) return;       thrust(a += sz);       thrust(b += sz - 1);       for (int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) {         if (l & 1) lazy[l] = h(lazy[l], x), ++l;         if (r & 1) --r, lazy[r] = h(lazy[r], x);       }       recalc(a);       recalc(b);     }     Monoid query(int a, int b) {       if (a >= b) return M1;       thrust(a += sz);       thrust(b += sz - 1);       Monoid L = M1, R = M1;       for (int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) {         if (l & 1) L = f(L, reflect(l++));         if (r & 1) R = f(reflect(--r), R);       }       return f(L, R);     }     Monoid operator[](const int& k) { return query(k, k + 1); }   };   int main() {     constexpr int lm = 450000;     int n, k, kkt;     scanf( %d %d %d , &n, &k, &kkt);     LazySegmentTree<int, int> lsg(lm, -inf, 0);     for (int i = 0; i < lm; i++) lsg.set(i, i - 1);     lsg.build();     set<pair<int, int>> sp;     multiset<int> ms;     while (kkt--) {       int x, y;       scanf( %d %d , &x, &y);       int t = abs(x - k) + y;       if (sp.find({x, y}) == sp.end()) {         sp.emplace(x, y);         lsg.update(0, t + 1, 1);         ms.emplace(t);       } else {         sp.erase(sp.find({x, y}));         lsg.update(0, t + 1, -1);         ms.erase(ms.find(t));       }       if (ms.empty())         puts( 0 );       else {         int mx = lsg.query(0, *ms.rbegin() + 1);         printf( %d n , max(n, mx) - n);       }     }     return 0;   }   