#include <cstdio>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <climits>
#include <ctime>
#include <queue>
#include <stack>
#include <algorithm>
#include <list>
#include <vector>
#include <set>
#include <map>
#include <iostream>
#include <deque>
#include <complex>
#include <string>
#include <iomanip>
#include <sstream>
#include <bitset>
#include <valarray>
#include <functional>
#include <assert.h>
using namespace std;
typedef long long int ll;
typedef unsigned int uint;
typedef unsigned char uchar;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;

#define REP(i,x) for(int i=0;i<(int)(x);i++)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();i++)
#define RREP(i,x) for(int i=((int)(x)-1);i>=0;i--)
#define RFOR(i,c) for(__typeof((c).rbegin())i=(c).rbegin();i!=(c).rend();i++)
#define ALL(container) container.begin(), container.end()
#define RALL(container) container.rbegin(), container.rend()
#define SZ(container) ((int)container.size())
#define mp(a,b) make_pair(a, b)
#define UNIQUE(v) v.erase( unique(v.begin(), v.end()), v.end() );

template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
template<class T> ostream& operator<<(ostream &os, const vector<T> &t) {
os<<"["; FOR(it,t) {if(it!=t.begin()) os<<","; os<<*it;} os<<"]"; return os;
}
template<class T> ostream& operator<<(ostream &os, const set<T> &t) {
os<<"{"; FOR(it,t) {if(it!=t.begin()) os<<","; os<<*it;} os<<"}"; return os;
}
template<class S, class T> ostream& operator<<(ostream &os, const pair<S,T> &t) { return os<<"("<<t.first<<","<<t.second<<")";}

const double EPS = 1e-8;
const int MOD = 1000000007;



template <typename Weight>
struct MaxFlow{
	struct Edge{
		int v;
		Weight w;
		int r;
		Edge(int v, Weight w,int r=0):v(v),w(w),r(r){}
	};
	typedef vector< vector<Edge> > Graph;
	int n, source, sink;
	Graph g;
	Weight flow;
	MaxFlow(int n=0, int s=0, int t=0):n(n), g(n), flow(0), source(s), sink(t){
		
	}
	
	void add_edge(int u, int v, Weight cap, Weight revcap=0){
		g[u].emplace_back(v,cap,g[v].size());
		g[v].emplace_back(u,revcap,g[u].size()-1);
	}
	void rem_edge(int u,int v, Weight cap){
		for(auto &e : g[u])if(e.v == v){
			Weight t = min(cap, e.w);
			e.w -= t;
			cap -= t;
			if(cap == 0) return;
		}
		Weight t = cap;
		cap -= maxflow_dinic(u, v, cap);
		if(cap){
			maxflow_dinic(sink, v, cap);
			maxflow_dinic(u, source, cap);
			flow -= cap;
		}
		rem_edge(v, u, t);
	}
	
	Weight maxflow_dinic(int source, int sink, Weight limit){
		if(source == sink) return limit;
		const Weight inf = numeric_limits<Weight>::max();
		Weight flow = 0;
		while(true){
			vector<int> level(n, -1);
			queue<int> q;
			level[source] = 0;
			q.push(source);
			while(!q.empty()){
				const int u = q.front(); q.pop();
				for(const auto &e : g[u]){
					const int v = e.v;
					if(e.w <= 0 || level[v] >= 0){ continue; }
					level[v] = level[u] + 1;
					q.push(v);
				}
			}
			if(level[sink] < 0){ break; }
			vector<size_t> itr(n, 0);
			while(true){
				function<Weight(int, Weight)> dfs =
					[&](int u, Weight limit) -> Weight{
						if(u == sink) return limit;
						for(; itr[u] < g[u].size(); ++itr[u]){
							auto &e = g[u][itr[u]];
							const int v = e.v;
							if(e.w <= 0 || level[u] >= level[v]){ continue; }
							const Weight diff = dfs(v, min(e.w, limit));
							if(diff > 0){
								e.w -= diff;
								g[v][e.r].w += diff;
								return diff;
							}
						}
						return 0;
					};
				const auto f = dfs(source, limit - flow);
				if(f <= 0) break;
				if((flow += f) == limit) return flow;
			}
		}
		return flow;
	}
	Weight maxflow(){
		return flow += maxflow_dinic(source, sink, numeric_limits<Weight>::max());
	}
};

int N, E, Q;
main(){
	ios::sync_with_stdio(false);
	cin >> N >> E >> Q;
	MaxFlow<int> g(N, 0, N-1);
	REP(i, E){
		int u, v;
		cin >> u >> v;u--;v--;
		g.add_edge(u, v, 1, 1);
	}
	REP(i, Q){
		int u, v, f;
		cin >> f >> u >> v; u--; v--;
		if(f == 1){
			g.add_edge(u, v, 1, 1);
		}else{
			g.rem_edge(u, v, 1);
			g.rem_edge(v, u, 1);
		}
		cout << g.maxflow() << endl;
	}
	return 0;
}

Measured memory_bytes: 1896