#include<algorithm>
#include<iostream>
#include<complex>
#include<cstdlib>
#include<cstring>
#include<utility>
#include<bitset>
#include<cstdio>
#include<string>
#include<time.h>
#include<vector>
#include<cmath>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
using namespace std;
const int N=2e5+5;
int a[2][N],t[N],x[N],y[N],l[N],c,e[2][N];
long long d[2][N];
int lsh(int x)
{
	return lower_bound(l+1,l+c+1,x)-l;
}
int lb(int x)
{
	return -x&x;
}
void add(bool w,int x,int v,int f)
{
	int y=c-x+1;
	while(x<=c)
	{
		e[w][x]+=f;
		x+=lb(x);
	}
	while(y<=c)
	{
		d[w][y]+=f*v;
		y+=lb(y);
	}
}
pair<int,long long> ask(bool w,int x)
{
	int an=0,y=c-x;
	long long as=0;
	while(x)
	{
		an+=e[w][x];
		x-=lb(x);
	}
	while(y)
	{
		as+=d[w][y];
		y-=lb(y);
	}
	return pair<int,long long>(an,as);
}
int main()
{
	int n,m,q,s,g;
	long long an=0;
	scanf("%d%d%d",&n,&m,&q);
	l[++c]=0;
	for(int i=1;i<=q;i++)
	{
		scanf("%d%d%d",&t[i],&x[i],&y[i]);
		t[i]--;
		l[++c]=y[i];
	}
	sort(l+1,l+c+1);
	c=unique(l+1,l+c+1)-l-1;
	for(int i=1;i<=n;i++)
		add(0,1,0,1);
	for(int i=1;i<=m;i++)
		add(1,1,0,1);
	for(int i=1;i<=q;i++)
	{
		s=lsh(a[t[i]][x[i]]);
		g=lsh(y[i]);
		add(t[i],s,l[s],-1);
		add(t[i],g,y[i],1);
		pair<int,long long>p=ask(t[i]^1,s);
		pair<int,long long>r=ask(t[i]^1,g);
		a[t[i]][x[i]]=y[i];
		an+=1ll*r.first*y[i]+r.second-1ll*p.first*l[s]-p.second;
		printf("%lld\n",an);
	}
}
#include <bits/stdc++.h>
#define f first
#define s second
#define fore(i,a,b) for(int i = (a), ThxMK = (b); i < ThxMK; ++i)
#define pb push_back
#define all(s) begin(s), end(s)
#define _ ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define sz(s) int(s.size())
#define ENDL '\n'
using namespace std;
typedef long double ld;
typedef long long lli;
typedef pair<lli,lli> ii;
typedef vector<lli> vi;
#define deb(x) cout << #x": " << (x) << endl;

struct SegmentTree {
    #define mid (l + r) / 2
    #define left(u) (u + 1)
    #define right(u) (u + ((mid - l + 1) << 1 ))

    struct Node{
        lli s, cnt;
        Node(lli s = 0, lli cnt = 0): s(s), cnt(cnt){}
        Node operator+(const Node &n) const {
              return Node(s + n.s, cnt + n.cnt);
        }
    };

    int n;
    Node z;
    vector<Node> st;

    SegmentTree(int n): n(n) {
        st.resize(2 * n);
    }

    void update(int u, int l, int r, int kth, lli val, lli c) {
      if(l == r) {
          st[u].s += val;
          st[u].cnt += c;
          return;
      }
      if(kth <= mid) update(left(u), l, mid, kth, val, c);
      else update(right(u), mid + 1, r, kth, val, c);
      st[u] = st[left(u)] + st[right(u)];
    }
    Node query(int u, int l, int r, int ll, int rr) {
       if(r < ll or rr < l or r < l) return z;
       if(ll <= l and r <= rr) return st[u];
       return query(left(u), l, mid, ll, rr) + query(right(u), mid + 1, r, ll, rr);
   }
};

lli n, m, q, sz, ans = 0;
vi vn;
vi vm;
vector<SegmentTree> vs;
vector<pair<bool, ii>> query;

set<lli> st;
map<lli, lli> mp;

void comp() {
  sz = 0;
  for(auto it : st) mp[it] = sz++;
}

lli get(int id, lli x) {
  lli l = (vs[id].query(0, 0, sz, 0, mp[x]).cnt) * x;
  lli r = vs[id].query(0, 0, sz, mp[x] + 1, sz).s;
  //if(id == 0) deb(vs[id].query(0, 0, sz, 1, sz).s);
  return l + r;
}

int main(){ _
  cin >> n >> m >> q;
  vn.resize(n);
  vm.resize(m);
  query.resize(q);
  lli t, x, y;
  st.insert(0);
  fore(i, 0, q) {
    cin >> t >> x >> y; --x; st.insert(y);
    query[i].f = t == 1;
    query[i].s = {x, y};
  }
  comp();
  vs = vector<SegmentTree>(2, SegmentTree(sz));
  --sz;
  fore(i, 0, n) vs[0].update(0, 0, sz, 0, 0, 1);
  fore(i, 0, m) vs[1].update(0, 0, sz, 0, 0, 1);
  for(auto it : query) {
    x = it.s.f; y = it.s.s;
    if(it.f) {
      ans -= get(1, vn[x]);
      vs[0].update(0, 0, sz, mp[vn[x]], -vn[x], -1);
      vn[x] = y;
      vs[0].update(0, 0, sz, mp[y], vn[x], 1);
      ans += get(1, vn[x]);
    }
    else {
      ans -= get(0, vm[x]);
      vs[1].update(0, 0, sz, mp[vm[x]], -vm[x], -1);
      vm[x] = y;
      vs[1].update(0, 0, sz, mp[y], vm[x], 1);
      ans += get(0, vm[x]);
    }
    cout << ans << ENDL;
  }
  return 0;
}
