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
#include <iostream>
#include <vector>
#include <algorithm>


using namespace std;


struct Bld
{
    int64_t l, r;

    bool operator<(const Bld & rhs) const
    {
        return l < rhs.l;
    }
};


static int64_t n, m, s, iResult, iMinDist;

static bool fFound;

static vector<Bld> vBlds;

static vector<Bld> vConsolidated;


static void ReadData()
{
    for (int i = 0; i < m; ++i)
    {
        Bld bld;

        cin >> bld.l >> bld.r;

        vBlds.push_back(bld);
    }
}


static void Consolidate()
{
    sort(vBlds.begin(), vBlds.end());

    vConsolidated.push_back(vBlds[0]);

    for (int i = 1; i < m; ++i)
    {
        Bld & bld = vBlds[i];

        if (bld.l == vConsolidated.back().r + 1)
        {
            vConsolidated.back().r = bld.r;
            continue;
        }

        vConsolidated.push_back(bld);
    }
}


static inline void UpdateResult(int64_t x)
{
    if (x < 1 || x > n)
        return;

    if (!fFound)
    {
        fFound = true;
        iResult = x;
        iMinDist = abs(x - s);
        return;
    }

    int64_t iCandidate = abs(x - s);

    if (iCandidate < iMinDist)
    {
        iResult = x;
        iMinDist = iCandidate;
    }
}


static void FindResult()
{
    fFound = false;

    for (const Bld & bld : vConsolidated)
    {
        UpdateResult(bld.l - 1);
        UpdateResult(bld.r + 1);
    }
}


int main()
{
    cin >> n >> m >> s;

    ReadData();
    Consolidate();
    FindResult();

    cout << iResult;
}