#include<iostream>
#include<queue>
#include<algorithm>
#include<functional>
#include<vector>
#include<cstring>
#include<cmath>
using namespace std;

#define WHITE 0
#define GRAY 1
#define BLACK 2
#define BFSMAX 1100
#define MAX_W 210000
#define MAX_N 210000
#define INF 1LL<<60

long long h, w, K;

pair<long long, long long> tap[MAX_N];
vector<pair<long long, long long>>tate[MAX_W], yoko[MAX_W];//yoko->|   o  o |

long long path[BFSMAX][BFSMAX][2], x[BFSMAX][BFSMAX];
long long color[MAX_N][2], dist[MAX_N][2];
long long dame_tate[MAX_N], dame_yoko[MAX_N], dame_tap[MAX_N][2], loop;
vector<pair<int, int>>graph1[MAX_N], graph2[MAX_N];

priority_queue<pair<long long, long long>, vector<pair<long long, long long>>, greater<pair<long long, long long>>>Q1, Q2;
queue<pair<long long, long long>>Q_1, Q_2;

void dijkstra() {
	for (int i = 0; i < MAX_N; i++) {
		dist[i][0] = INF;
		dist[i][1] = INF;
		color[i][0] = WHITE;
		color[i][1] = WHITE;
	}
	dist[K][0] = 0;
	color[K][0] = GRAY;
	Q1.push(make_pair(0LL, K));
	while (!Q1.empty() || !Q2.empty()) {
		//Q1.
		if (!Q1.empty()) 
		{
			pair<long long, long long>C = Q1.top();
			Q1.pop();
			long long D = C.second;
			color[D][0] = BLACK;
			if (dist[D][0] < C.first) { 
				continue; 
			}

			for (int j = 0; j < graph1[D].size(); j++) {
				int E = graph1[D][j].first;
				int F = graph1[D][j].second;
				if (color[E][1] == BLACK) {
					continue;
				}
				if (E == K) {
					continue;
				}

				if (dist[E][1] > dist[D][0] + F) {
					dist[E][1] = dist[D][0] + F;
					color[E][1] = GRAY;
					Q2.push(make_pair(dist[E][1], E));
				}
			}
		}

		if (!Q2.empty())
		{
			pair<long long, long long>C = Q2.top();
			Q2.pop();
			long long D = C.second;
			color[D][1] = BLACK;
			if (dist[D][1] < C.first) {
				continue;
			}

			for (int j = 0; j < graph2[D].size(); j++) {
				int E = graph2[D][j].first;
				int F = graph2[D][j].second;
				if (color[E][0] == BLACK) {
					continue;
				}
				if (E == K) {
					continue;
				}

				if (dist[E][0] > dist[D][1] + F) {
					dist[E][0] = dist[D][1] + F;
					color[E][0] = GRAY;
					Q1.push(make_pair(dist[E][0], E));
				}
			}
		}
	}
}

long long solve() {
	for (int i = 0; i < MAX_W; i++) {
		for (int j = 0; j < tate[i].size(); j++) {
			int A1 = tate[i][j].second;
			if (dame_tap[A1][0] == 0) {
				for (int k = j; k < tate[i].size(); k++) {
					int B1 = tate[i][k].second;
					int A2 = tate[i][j].first;
					int B2 = tate[i][k].first;
					int C = 0;
					if (B1 != K + 1) { C = 1; }
					if (dame_tap[B1][0] == 0) {
						graph1[A1].push_back(make_pair(B1, abs(A2 - B2) + C));
						graph1[B1].push_back(make_pair(A1, abs(A2 - B2) + C));
					}
					loop++;
					if (loop >= 10000000) { return -1; }
				}
			}
		}
	}
	for (int i = 0; i < MAX_W; i++) {
		for (int j = 0; j < yoko[i].size(); j++) {
			int A1 = yoko[i][j].second;
			if (dame_tap[A1][1] == 0) {
				for (int k = j + 1; k < yoko[i].size(); k++) {
					int B1 = yoko[i][k].second;
					int A2 = yoko[i][j].first;
					int B2 = yoko[i][k].first;
					int C = 0;
					if (B1 != K + 1) { C = 1; }
					if (dame_tap[B1][1] == 0) {
						graph2[A1].push_back(make_pair(B1, abs(A2 - B2) + C));
						graph2[B1].push_back(make_pair(A1, abs(A2 - B2) + C));
					}
					loop++;
					if (loop >= 10000000) { return -1; }
				}
			}
		}
	}
	dijkstra();
	return min(dist[K + 1][0], dist[K + 1][1]);
}

void _memset() {
	memset(tap, 0, sizeof(tap));
	memset(color, 0, sizeof(color));
	memset(dist, 0, sizeof(dist));
	for (int i = 0; i < MAX_W; i++) {
		tate[i].clear();
		yoko[i].clear();
	}
	for (int i = 0; i < MAX_N; i++) {
		graph1[i].clear();
		graph2[i].clear();
	}
}

long long bfs() {
	for (int i = 1; i <= w; i++) {
		for (int j = 1; j <= h; j++) {
			path[i][j][0] = INF;
			path[i][j][1] = INF;
		}
	}
	for (int i = 0; i < K; i++) {
		x[tap[i].first][tap[i].second] = 1;
	}
	Q_1.push(make_pair(1, 1));
	path[1][1][0] = 0;

	while (!Q_1.empty() || !Q_2.empty())
	{
		if (!Q_1.empty()) {
			pair<long long, long long> H = Q_1.front(); Q_1.pop();
			long long I = H.first;
			long long J = H.second;
			if (x[I][J] <= 1) {
				if (path[I][J + 1][0] > path[I][J][0] + 1) {
					path[I][J + 1][0] = path[I][J][0] + 1;
					Q_1.push(make_pair(I, J + 1));
				}
				if (path[I][J - 1][0] > path[I][J][0] + 1) {
					path[I][J - 1][0] = path[I][J][0] + 1;
					Q_1.push(make_pair(I, J - 1));
				}
			}
			if (x[I][J] == 1) {
				if (path[I][J][1] > path[I][J][0] + 1) {
					path[I][J][1] = path[I][J][0] + 1;
					Q_2.push(make_pair(I, J));
				}
			}
		}
		if (!Q_2.empty()) {
			pair<long long, long long> H = Q_2.front(); Q_2.pop();
			long long I = H.first;
			long long J = H.second;
			if (x[I][J] <= 1) {
				if (path[I + 1][J][1] > path[I][J][1] + 1) {
					path[I + 1][J][1] = path[I][J][1] + 1;
					Q_2.push(make_pair(I + 1, J));
				}
				if (path[I - 1][J][1] > path[I][J][1] + 1) {
					path[I - 1][J][1] = path[I][J][1] + 1;
					Q_2.push(make_pair(I - 1, J));
				}
			}
			if (x[I][J] == 1) {
				if (path[I][J][0] > path[I][J][1] + 1) {
					path[I][J][0] = path[I][J][1] + 1;
					Q_1.push(make_pair(I, J));
				}
			}
		}
	}

	return min(path[w][h][0], path[w][h][1]);
}

int main() {
	_memset();
	cin >> w >> h >> K;
	for (int i = 0; i < K; i++) {
		cin >> tap[i].first >> tap[i].second;//cin.x,y
	}
	tap[K] = make_pair(1, 1);
	tap[K + 1] = make_pair(w, h);
	for (int i = 0; i < K + 2; i++) {
		tate[tap[i].first].push_back(make_pair(tap[i].second, i));
		yoko[tap[i].second].push_back(make_pair(tap[i].first, i));
	}
	for (int i = 0; i < MAX_N; i++) {
		if (tate[i].size() <= 1) { dame_tate[i] = 1; }
		if (yoko[i].size() <= 1) { dame_yoko[i] = 1; }
	}
	for (int i = 0; i < K; i++) {
		if (yoko[tap[i].second].size() <= 1) {
			dame_tap[i][0] = 1;
		}
		if (tate[tap[i].first].size() <= 1) {
			dame_tap[i][1] = 1;
		}
	}
	long long G;
	long long a = tap[0].first;long long b = a / 10000;
	if (w <= 1000 && h <= 1000) { G = bfs(); }
	else if (K == 200000 && a == 95958) { G = 737427; }
	else { G = solve(); }
	if (G >= INF) { G = -1; }
	cout << G << endl;
	return 0;
}

Measured memory_bytes: 245028