//???[????????????, ??????????????????]??????????????§????????????????????????????????????[????????????x, ??????????????????y]?????????????????????????§????(x, y, ?????°)??????????????§??¨?????????O(NM)
//??????????????????????§??????????????????¨???[??????????????????, ??????????????????]??§???????§????????°??????????????????¶?????????????????§??¨????????????O(K^2logK)
//??¢????¨?????????§??£??\?????????????????????s1, s2???????§????????????????????¨?????????§??£??\???????????????????????°??????????????£????????????????????¨????????????????????????
//???????¨?????????§??£??\??????????????????(??????4???)????????????????????£????????????????????????O(KlogK)????????????
//????£??????????
//???{ int r, c; int switchIndex; }??????????§??????????2????????????????????°???????§?????????????????????????
//??????????????¨???????????§??¬????????°???????§????????????????
//?????????????????°???????§??????????????????§?????????????????????????????????????????§?¨?????????????????????????????????§?¨??????????????????°???????????§???
//???????????????????????????{????????¨?????????} + {????????¨?????????}????????????
//?§??????????????????????????????´????????????????¨???????????§??????§??????????????§??¨???

#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <tuple>
#include <map>
#include <unordered_map>
#define int long long
using namespace std;

int h, w, n;
int x[200000], y[200000];

vector<int> sc[100000];						//sc[r] = {r??????????????????????????????(???)????\?????????±??????????????????}, ?¨???????
vector<int> sr[100000];						//sr[c] = {c??????????????????????????????(???)?????????????????????????????????}, ?????????
unordered_map<int, int> cost[2][100000];	//cost[][r][c]???[???0,?¨?1]????????§??????(r, c)????¨????????????§???????°???????

void Dijkstra(bool sflag){
	typedef tuple<int, int, int, int> T;	//(?????????, ??????, r, c)
	static priority_queue<T, vector<T>, greater<T> > que;
	que.push(T(0, 0, 0, 0));
	if( sflag )
		que.push(T(1, 1, 0, 0));
		
	while( !que.empty() ){
		T state = que.top();
		int cst = get<0>(state);
		int dir = get<1>(state);
		int r = get<2>(state);
		int c = get<3>(state);
		que.pop();
		if( cost[dir][r].find(c) != cost[dir][r].end() && cost[dir][r][c] <= cst )
			continue;
		//cout << cst << " " << dir << " " << r << " " << c << endl;
		cost[dir][r][c] = cst;
		
		//???(r+), ???(r-), ???(c+), ???(c-) (??????(????????¨????¨???£????????????)????§??????????)
		int pr = upper_bound(sr[c].begin(), sr[c].end(), r) - sr[c].begin();
		int mr = lower_bound(sr[c].begin(), sr[c].end(), r) - sr[c].begin(); mr--;
		int pc = upper_bound(sc[r].begin(), sc[r].end(), c) - sc[r].begin();
		int mc = lower_bound(sc[r].begin(), sc[r].end(), c) - sc[r].begin(); mc--;
		
		if( 0 <= pr && pr < (int)sr[c].size() ){
			pr = sr[c][pr];
			que.push(T(cst + pr - r + dir, 0, pr, c));
		}
		if( 0 <= mr && mr < (int)sr[c].size() ){
			mr = sr[c][mr];
			que.push(T(cst + r - mr + dir, 0, mr, c));
		}
		//?§???????????????¨???????¨??????????????????´????????????
		if( r == 0 && c == 0 && !sflag ){
			continue;
		}
		
		if( 0 <= pc && pc < (int)sc[r].size() ){
			pc = sc[r][pc];
			que.push(T(cst + pc - c + (!dir), 1, r, pc));
		}
		if( 0 <= mc && mc < (int)sc[r].size() ){
			mc = sc[r][mc];
			que.push(T(cst + c - mc + (!dir), 1, r, mc));
		}
	}
}

signed main(){
	int i;
	bool sflag = false;	//???????????????????????????????????????
	bool gflag = false;	//??´?????????????????????????????????
	
	cin >> w >> h >> n;
	for( i = 0; i < n; i++ ){
		cin >> x[i] >> y[i];
		x[i]--; y[i]--;		//0-indexed?????????
		sc[y[i]].push_back(x[i]);
		sr[x[i]].push_back(y[i]);
		if( x[i] == 0 && y[i] == 0 )
			sflag = true;
		if( x[i] == w-1 && y[i] == h-1 )
			gflag = true;
	}
	//??´??????????¨??????????
	if( !gflag ){
		sc[h-1].push_back(w-1);
		sr[w-1].push_back(h-1);
	}
	
	for( i = 0; i < h; i++ )
		if( sc[i].size() > 0 )
			sort(sc[i].begin(), sc[i].end());
	for( i = 0; i < w; i++ )
		if( sr[i].size() > 0 )
			sort(sr[i].begin(), sr[i].end());
	
	Dijkstra(sflag);
	
	int ans = 1e+12;
	if( cost[0][h-1].find(w-1) != cost[0][h-1].end() )
		ans = min(ans, cost[0][h-1][w-1]);
	if( cost[1][h-1].find(w-1) != cost[1][h-1].end() )
		ans = min(ans, cost[1][h-1][w-1]);
	
	if( ans == 1e+12 )
		cout << -1 << endl;
	else
		cout << ans << endl;
	return 0;
}

Measured memory_bytes: 52144