1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
#include<iostream>
#include<algorithm>

struct Interval {
    long long start;
    long long end;
};

bool compareIntervals(const Interval &a, const Interval &b) {
    return a.start < b.start;
}


int main()
{
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(NULL);
    long long n;
    std::cin >> n;
    int m;
    std::cin >> m;
    long long s;
    std::cin >> s;

    Interval intervals[m];
    
    for (int i = 0; i < m; i++) {
        std::cin >> intervals[i].start;
        std::cin >> intervals[i].end;
    }

    std::sort(intervals, intervals + m, compareIntervals);    


    long long currentMin = n + 1;

    if (intervals[0].start > 1) {
        currentMin = s - (intervals[0].start - 1);
    }

    if (intervals[m - 1].end < n) {
        currentMin = std::min(currentMin, intervals[m - 1].end + 1 - s);
    }

    int leftInterval = -1;
    int rightInterval = -1;

    for (int i = 0; i < m; i++) {
        if (intervals[i].start <= std::max(s - 1, 1LL) && intervals[i].end >= std::min(s - 1, n)) {
            leftInterval = i;
        }

        if (intervals[i].start <= std::max(s + 1, 1LL) && intervals[i].end >= std::min(s + 1, n)) {
            rightInterval = i;
        }
    }

    if (leftInterval == -1) {
        std::cout << s - 1 << "\n";
        return 0;
    }

    if (rightInterval == -1) {
        std::cout << s + 1 << "\n";
        return 0;
    }

    for (int i = leftInterval; i > 0; i--) {
        if (intervals[i - 1].end + 1 != intervals[i].start) {
            currentMin = std::min(currentMin, s - (intervals[i].start - 1));
            break;
        }
    }

    for (int i = rightInterval; i < m - 1; i++) {
        if (intervals[i].end + 1 != intervals[i + 1].start) {
            currentMin = std::min(currentMin, intervals[i].end + 1 - s);
            break;
        }
    }

    bool isLeft = s - currentMin > 0;

    if (s - currentMin > 0) {
        for (int i = 0; i < m; i++) {
            if (intervals[i].start <= s - currentMin && intervals[i].end >= s - currentMin) {
                isLeft = false;
                break;
            }
        }
    }

    if (isLeft) {
        std::cout << s - currentMin << "\n";
        return 0;
    }


    bool isRight = s + currentMin <= n;

    if (s + currentMin <= n) {
        for (int i = 0; i < m; i++) {
            if (intervals[i].start <= s + currentMin && intervals[i].end >= s + currentMin) {
                isRight = false;
                break;
            }
        }
    }

    if (isRight) {
        std::cout << s + currentMin << "\n";
        return 0;
    }


    std::cout << currentMin << "\n";
    return 0;
}