/*  _              _     _                                             _       __      __      __   
   / \     _   _  | |_  | |__     ___    _ __   _    ___   _ __ ___   | | __  / /_    / /_    / /_  
  / _ \   | | | | | __| | '_ \   / _ \  | '__| (_)  / __| | '_ ` _ \  | |/ / | '_ \  | '_ \  | '_ \ 
 / ___ \  | |_| | | |_  | | | | | (_) | | |     _  | (__  | | | | | | |   <  | (_) | | (_) | | (_) |
/_/   \_\  \__,_|  \__| |_| |_|  \___/  |_|    (_)  \___| |_| |_| |_| |_|\_\  \___/   \___/   \___/ 
[Created Time:       2024-05-24 13:58:24]
[Last Modified Time: 2024-05-24 15:06:54] */
#pragma GCC optimize("Ofast", "unroll-loops")
#include<bits/stdc++.h>
#ifdef LOCAL
#include"debug.h"
#else
#define D(...) ((void)0)
#endif
using namespace std; using ll = long long;
#define For(i, j, k) for ( int i = (j) ; i <= (k) ; i++ )
#define Fol(i, j, k) for ( int i = (j) ; i >= (k) ; i-- )
namespace FastIO
{
// ------------------------------
// #define DISABLE_MMAP
// ------------------------------
#if ( defined(LOCAL) || defined(_WIN32) ) && !defined(DISABLE_MMAP)
#define DISABLE_MMAP
#endif
#ifdef LOCAL
	inline char gc() { return getchar(); }
	inline void pc(char c) { putchar(c); }
#else
#ifdef DISABLE_MMAP
	inline constexpr int _READ_SIZE = 1 << 18;
	inline static char _read_buffer[_READ_SIZE], *_read_ptr = nullptr, *_read_ptr_end = nullptr;
	inline char gc()
	{
		if ( __builtin_expect(_read_ptr == _read_ptr_end, false) )
		{
			_read_ptr = _read_buffer, _read_ptr_end = _read_buffer + fread(_read_buffer, 1, _READ_SIZE, stdin);
			if ( __builtin_expect(_read_ptr == _read_ptr_end, false) ) return EOF;
		}
		return *_read_ptr++;
	}
#else
#include<sys/mman.h>
	inline static const char *_read_ptr = (const char *)mmap(nullptr, 0x7fffffff, 1, 2, 0, 0);
	inline char gc() { return *_read_ptr++; }
#endif
	inline constexpr int _WRITE_SIZE = 1 << 18;
	inline static char _write_buffer[_WRITE_SIZE], *_write_ptr = _write_buffer;
	inline void pc(char c)
	{
		*_write_ptr++ = c;
		if ( __builtin_expect(_write_buffer + _WRITE_SIZE == _write_ptr, false) )
			fwrite(_write_buffer, 1, _write_ptr - _write_buffer, stdout), _write_ptr = _write_buffer;
	}
	inline struct _auto_flush
	{
		inline ~_auto_flush() { fwrite(_write_buffer, 1, _write_ptr - _write_buffer, stdout); }
	}	_auto_flush;
#endif
	template < class T > inline constexpr bool _is_signed = numeric_limits < T >::is_signed;
	template < class T > inline constexpr bool _is_unsigned = numeric_limits < T >::is_integer && !_is_signed < T >;
#if __SIZEOF_LONG__ == 64
	template <> inline constexpr bool _is_signed < __int128 > = true;
	template <> inline constexpr bool _is_unsigned < __uint128_t > = true;
#endif
	inline void read(char &c) { do c = gc(); while ( !isgraph(c) ); }
	inline void read_cstr(char *s)
	{
		char c = gc(); while ( !isgraph(c) ) c = gc();
		while ( isgraph(c) ) *s++ = c, c = gc(); *s = 0;
	}
	inline void read(string &s)
	{
		char c = gc(); s.clear(); while ( !isgraph(c) ) c = gc();
		while ( isgraph(c) ) s.push_back(c), c = gc();
	}
	template < class T, enable_if_t < _is_signed < T >, int > = 0 >
	inline void read(T &x)
	{
		char c = gc(); bool f = true; x = 0;
		while ( !isdigit(c) ) { if ( c == 45 ) f = false; c = gc(); }
		if ( f ) while ( isdigit(c) ) x = x * 10 + ( c & 15 ), c = gc();
		else     while ( isdigit(c) ) x = x * 10 - ( c & 15 ), c = gc();
	}
	template < class T, enable_if_t < _is_unsigned < T >, int > = 0 >
	inline void read(T &x)
	{
		char c = gc(); while ( !isdigit(c) ) c = gc();
		x = 0; while ( isdigit(c) ) x = x * 10 + ( c & 15 ), c = gc();
	}
	inline void write(char c) { pc(c); }
	inline void write_cstr(const char *s) { while ( *s ) pc(*s++); }
	inline void write(const string &s) { for ( char c : s ) pc(c); }
	template < class T, enable_if_t < _is_signed < T >, int > = 0 >
	inline void write(T x)
	{
		char buffer[numeric_limits < T >::digits10 + 1]; int digits = 0;
		if ( x >= 0 )  do buffer[digits++] =  ( x % 10 ) | 48, x /= 10; while ( x );
		else { pc(45); do buffer[digits++] = -( x % 10 ) | 48, x /= 10; while ( x ); }
		while ( digits ) pc(buffer[--digits]);
	}
	template < class T, enable_if_t < _is_unsigned < T >, int > = 0 >
	inline void write(T x)
	{
		char buffer[numeric_limits < T >::digits10]; int digits = 0;
		do buffer[digits++] = ( x % 10 ) | 48, x /= 10; while ( x );
		while ( digits ) pc(buffer[--digits]);
	}
	template < int N > struct _tuple_io_helper
	{
		template < class ...T > static inline void _read(tuple < T... > &x) { _tuple_io_helper < N - 1 >::_read(x), read(get<N - 1>(x)); }
		template < class ...T > static inline void _write(const tuple < T... > &x) { _tuple_io_helper < N - 1 >::_write(x), pc(32), write(get<N - 1>(x)); }
	};
	template <> struct _tuple_io_helper < 1 >
	{
		template < class ...T > static inline void _read(tuple < T... > &x) { read(get<0>(x)); }
		template < class ...T > static inline void _write(const tuple < T... > &x) { write(get<0>(x)); }
	};
	template < class ...T > inline void read(tuple < T... > &x) { _tuple_io_helper < sizeof...(T) >::_read(x); }
	template < class ...T > inline void write(const tuple < T... > &x) { _tuple_io_helper < sizeof...(T) >::_write(x); }
	template < class T1, class T2 > inline void read(pair < T1, T2 > &x) { read(x.first), read(x.second); }
	template < class T1, class T2 > inline void write(const pair < T1, T2 > &x) { write(x.first), pc(32), write(x.second); }
	template < class T1, class ...T2 > inline void read(T1 &x, T2 &...y) { read(x), read(y...); }
	template < class ...T > inline void read_cstr(char *x, T *...y) { read_cstr(x), read_cstr(y...); }
	template < class T1, class ...T2 > inline void write(const T1 &x, const T2 &...y) { write(x), write(y...); }
	template < class ...T > inline void write_cstr(const char *x, const T *...y) { write_cstr(x), write_cstr(y...); }
	template < class T > inline void print(const T &x) { write(x); }
	inline void print_cstr(const char *x) { write_cstr(x); }
	template < class T1, class ...T2 > inline void print(const T1 &x, const T2 &...y) { write(x), pc(32), print(y...); }
	template < class ...T > inline void print_cstr(const char *x, const T *...y) { write_cstr(x), pc(32), print_cstr(y...); }
	inline void println() { pc(10); } inline void println_cstr() { pc(10); }
	template < class ...T > inline void println(const T &...x) { print(x...), pc(10); }
	template < class ...T > inline void println_cstr(const T *...x) { print_cstr(x...), pc(10); }
}	using FastIO::read, FastIO::read_cstr, FastIO::write, FastIO::write_cstr, FastIO::println, FastIO::println_cstr;
template <class T, int N, int M> struct darry_with_radix_sort {
	struct E {int idx; T val;} e[M], f[M];
	T a[M];
	int b[N], c[2 << (std::__lg(N) / 2)], n, m, o;
	struct V {
		T *b, *e;
		V(T *b_, T *e_) : b(b_), e(e_) {}
		T* begin() const { return b; }
		T* end() const { return e; }
		T operator[](std::size_t i) const { return *(b + i); }
		std::size_t size() const { return e - b; }
	};
	void init(int n_) { n = n_, m = 0, o = std::__lg(n) / 2 + 1, std::fill(b + 1, b + n + 1, 0); }
	template <class ...U>
	void emplace(int idx, U&&... val) {
		b[idx]++, e[++m].idx = idx, std::construct_at(&e[m].val, val...);
	}
	void build() {
		std::fill(c, c + (1 << o), 0);
		for (int i = 1; i <= m; i++) c[e[i].idx & ((1 << o) - 1)]++;
		for (int i = 1; i < (1 << o); i++) c[i] += c[i - 1];
		for (int i = 1; i <= m; i++) f[c[e[i].idx & ((1 << o) - 1)]--] = std::move(e[i]);
		std::fill(c, c + (1 << o), 0);
		for (int i = 1; i <= m; i++) c[f[i].idx >> o]++;
		for (int i = 1; i < (1 << o); i++) c[i] += c[i - 1];
		for (int i = m; i; i--) a[c[f[i].idx >> o]--] = std::move(f[i].val);
		b[0] = 1;
		for (int i = 1; i <= n; i++) b[i] += b[i - 1];
	}
	V operator[](int idx) { return V(a + b[idx - 1], a + b[idx]); }
};
constexpr ll inf = numeric_limits < ll >::max() >> 1;
int n, m, q, o, u, v, id[2][200009]; ll w, d[2][200009], lim, ans; bool used[2][200009], vis[2][200009];
darry_with_radix_sort < pair < int, ll >, 200009, 3000009 > g[2]; vector < int > nd[2];
#include<ext/pb_ds/priority_queue.hpp>
__gnu_pbds::priority_queue < tuple < ll, int, int >, greater < tuple < ll, int, int > >,
							 __gnu_pbds::pairing_heap_tag > pq[2];
inline void ext(int o, int u)
{
	while ( id[o][u] < (int)g[o][u].size() )
	{
		auto [v, w] = g[o][u][id[o][u]++];
		if ( d[o][v] > d[o][u] + w )
		{
			if ( !used[o][v] ) used[o][v] = true, nd[o].push_back(v);
			pq[o].push(tuple(d[o][v] = d[o][u] + w, v, u)); return;
		}
	}
}
inline void work()
{
	For(o, 0, 1)
	{
		for ( int i : nd[o] ) used[o][i] = vis[o][i] = false, d[o][i] = inf, id[o][i] = 0;
		read(u), nd[o].clear(), used[o][u] = true, nd[o].push_back(u),
		pq[o].clear(), pq[o].push(tuple(d[o][u] = 0, u, 0));
	}
	v = 0;
	for ( int o ; pq[0].size() || pq[1].size() ; )
	{
		o = pq[0].empty() || ( pq[1].size() && (int)nd[0].size() > (int)nd[1].size() );
		auto [_, u, fr] = pq[o].top(); if ( fr ) ext(o, fr);
		if ( vis[!o][u] ) { v = u; break; } 
		pq[o].pop(); if ( vis[o][u] ) continue; vis[o][u] = true, ext(o, u);
	}
	if ( !v ) { println(-1); return; }
	ans = d[0][v] + d[1][v];
	For(o, 0, 1) for ( int i : nd[o] )
	{
		lim = ( d[o][v] - d[o][i] ) << 1;
		for ( auto [v, w] : g[o][i] ) 
		{
			if ( w > lim ) break;
			if ( used[!o][v] ) ans = min(ans, d[o][i] + d[!o][v] + w);
		}
	}
	println(ans);
}
int main()
{
	read(n, m, q);
	For(o, 0, 1) g[o].init(n);
	{
		unsigned mx = -1u / n * n, s; read(s); mt19937 rnd(s);
		const auto gen = [&] { unsigned x; do x = rnd(); while ( x >= mx ); return x % n + 1; };
		For(i, 1, m) u = gen(), v = gen(), w = rnd(), g[0].emplace(u, v, w), g[1].emplace(v, u, w);
	}
	For(o, 0, 1)
	{
		g[o].build(), nd[o].reserve(n), fill(d[o] + 1, d[o] + n + 1, inf);
		For(i, 1, n) sort(g[o][i].begin(), g[o][i].end(), [&](auto x, auto y) { return x.second < y.second; });
	}
	while ( q-- ) work();
	return 0;
}
// 想上GM捏 想上GM捏 想上GM捏 想上GM捏 想上GM捏
// 伊娜可爱捏 伊娜贴贴捏