#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstdio>
#include <vector>
#include <cmath>
#include <string>
#include <algorithm>
#include <string>
#include <deque>
#include <iomanip>

#define F first
#define S second

using namespace std;

const long double eps2 = 0.0000005;
const long double eps1 = 1e-5;
const long double pi = 3.1415926535897932;

vector <pair <int, int> > otr;
int dp[100010][2];
int tree[400004];

void query(int v, int l, int r, int ql, int qr, int i)
{
    if (l == ql && r == qr)
    {
        tree[v] = i;
        return;
    }

    int m = (l + r) / 2;

    if (qr <= m)
        return query(2 * v + 1, l, m, ql, qr, i);

    if (ql >= m)
        return query(2 * v + 2, m, r, ql, qr, i);

    query(2 * v + 1, l, m, ql, m, i);
    query(2 * v + 2, m, r, m, qr, i);

}

int findprep(int v, int l , int r, int i)
{
    if (l +1 == r)
        return tree[v];

    int m = (l + r) / 2;

    int ans;
    if (i < m)
        ans = findprep(2 * v + 1, l, m, i);
    else
        ans = findprep(2 * v + 2, m, r, i);

    return max(ans, tree[v]);
}

int main()
{
    ios_base::sync_with_stdio(0);
    freopen("input.txt", "r", stdin);
    //      freopen("output.txt", "w", stdout);

    int n, s, k;
    cin >> n >> s >> k;
    s--;

    int l, r;
    for (int i = 0; i < k; i++)
    {
        cin >> l >> r;
        l--; r--;
        otr.push_back(make_pair(l, r));

    }

    for (int i = 0; i < 100010; i++)
        for (int j = 0; j < 2; j++)
            dp[i][j] = 0;
    int v1, v2;

    for (int i = k - 1; i >= 0; i--)
    {
        v1 = findprep(0, 0, n, otr[i].F - 1); v1 = k - (v1-1);
        v2 = findprep(0, 0, n, otr[i].S + 1); v2 = k - (v2-1);

        if (otr[i].F > 0)
        {
            if (v1 > 0 && v1 <= k)
            {
                v1--;
                if (dp[v1][0] >= 0 && dp[v1][1] >= 0)
                    dp[i][0] = min(dp[v1][0] + abs(otr[v1].F - otr[i].F), dp[v1][1] + abs(otr[v1].S - otr[i].F + 2));
                else
                    if (dp[v1][0] >= 0)
                        dp[i][0] = dp[v1][0] + abs(otr[v1].F - otr[i].F);
                    else
                        dp[i][0] = dp[v1][1] + abs(otr[v1].S - otr[i].F + 2);
            }
        }
        else
            dp[i][0] = -1;

        if (otr[i].S < n - 1)
        {
            if (v2 > 0 && v2 <= k)
            {
                v2--;
                if (dp[v2][0] >= 0 && dp[v2][1] >= 0)
                    dp[i][1] = min(dp[v2][0] + abs(otr[i].S - otr[v2].F + 2), dp[v2][1] + abs(otr[i].S - otr[v2].S));
                else
                    if (dp[v2][0] >= 0)
                        dp[i][1] = dp[v2][0] + abs(otr[i].S - otr[v2].F + 2);
                    else
                        dp[i][1] = dp[v2][1] + abs(otr[i].S - otr[v2].S);
            }
        }
        else
            dp[i][1] = -1;
        query(0, 0, n, otr[i].first, otr[i].second + 1, k - /*(i + 1)*/ i);
    }

    int v = findprep(0, 1, n + 1, s);
    v--;

    if (dp[v][0] >= 0 && dp[v][1] >= 0)
        cout << min(dp[v][0] + s - otr[v].F + 1, dp[v][1] + otr[v].S + 1) << endl;
    else
    {
        if (dp[v][0] >= 0)
            cout << dp[v][0] + s - otr[v].F + 1 << endl;
        else
            cout << dp[v][1] + otr[v].S + 1 << endl;
    }

    cout << endl;
    cout << v << endl;

    return 0;
}