<|instruction|>
Solve the below problem. The solution should start with an abridged problem statement. Then key observations. Then full solution based on the observations. Then C++ and Python implementations with comments.

523. Elevator
Time limit per test: 0.25 second(s)
Memory limit: 262144 kilobytes
input: standard
output: standard

The Berland State Building is the highest building in the capital of Berland. Curious Polikarp was studying the principle of operation of an elevator in the Berland State Building for a quite a while. Recently he has finally understood the algorithm behind its operation, in case a person enters the elevator on the floor f and presses the floor buttons e1, e2,..., en one by one. The buttons are pressed sequentially but very quickly while the elevator is still located on the floor f. All the pressed buttons are distinct and differ from the floor f. No other button pressings are considered in this problem.

After the buttons e1, e2,..., en have been pressed, all of them become highlighted and the elevator starts moving according the following rules:


The elevator starts moving towards the floor, the button of which is highlighted and pressed first among all highlighted buttons. Say, it's floor/button a.

If on its way to a the elevator passes the floor b, the button of which is highlighted, it stops there, the light goes out for the button b unhighlighting it, and the floor b is considered visited. Then the elevator continues moving towards the floor a. It is possible that there will be more than one floor such as b on the way to floor a — all these floors will be passed one by one according to the described algorithm.

Having reached the floor a, the elevator stops there, the light goes out for the button a unhighlighting it, and the floor a is considered visited. Then the elevator starts to move towards the floor, the button of which has been pressed the earliest among the currently highlighted buttons. That floor becomes a new value of a. The elevator continues moving according to the rules described in the previous paragraph. If it's impossible to find a new value for a because there are no highlighted floor buttons, it means that all floors have been visited and the elevator stops.


Now, when the principle of the elevator's operation is clear, Polikarp wants to experiment with the elevator's movements without the elevator itself. He wants to write a program that simulates elevator's operation. Unfortunately, he didn't attend any programming lessons and it's a challenge for him. Can you please help Polikarp and write a program which will simulate movements of the elevator?

Input
The first line of input contains a pair of integers n, f (1 ≤ n, f ≤ 100), where n — amount of pressings made, f — index of the current floor where all these pressings were made. The second line contains distinct integers e1, e2,..., en (1 ≤ ei ≤ 100, ei ≠q f) — buttons indices in the order they were pressed.

Output
Output all the floors where the elevator stops, in a chronological order of the stops.

Example(s)
sample input
sample output
4 5
10 9 2 1
9 10 2 1

sample input
sample output
4 3
2 4 1 5
2 4 1 5

<|response|>
1. Abridged Problem Statement
You have an elevator initially at floor f. A sequence of n distinct buttons e₁,…,eₙ (none equal to f) is pressed in order; these floors become "highlighted." The elevator then visits all highlighted floors according to this rule:
- Always head toward the earliest-pressed remaining highlighted floor a.
- Move one floor at a time; whenever you reach any highlighted floor b (whether it's on the direct path to a or b=a), you stop there, unhighlight b, and record that stop.
- After unhighlighting a, pick the next earliest-pressed highlighted floor as the new target and repeat, until no highlighted floors remain.

Output the floors in the exact order the elevator stops.

2. Key Observations
- The "pending stops" always form the list of unvisited highlighted floors, kept in the original press order.
- At each stage, the elevator has:
  • A current floor `f`.
  • A target floor `tgt` = the first element of the pending list.
- The elevator moves in steps of ±1 toward `tgt`.
- If `f` matches any pending floor, you immediately stop there, remove it from the pending list, output it, and—if it was `tgt`—reset `tgt` to the new first element.
- You repeat this until the pending list is empty.

3. Full Solution Approach
- Read `n, f`. Read array `a` of size n (the pressed floors in order).
- Initialize:
  f = starting floor
  tgt = a[0]
  ans = empty list of stops
- While `a` is nonempty:
  1. Inner loop: while `f` appears in `a`, record `f` (first occurrence only) and erase all such entries. Because all buttons are distinct, at most one entry matches.
  2. If `tgt == f`, update `tgt = a[0]` (unless `a` is now empty, in which case break).
  3. Move one step: if `tgt > f`, do `f++`; else `f--`.
- Print the recorded stops in `ans`.

Time complexity is O(n * (search + removal + floor moves)), all bounded by ≤100, so it's efficient for n,f ≤100.

4. C++ Solution

```cpp
#include <bits/stdc++.h>

using namespace std;

template<typename T1, typename T2>
ostream& operator<<(ostream& out, const pair<T1, T2>& x) {
    return out << x.first << ' ' << x.second;
}

template<typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& x) {
    return in >> x.first >> x.second;
}

template<typename T>
istream& operator>>(istream& in, vector<T>& a) {
    for(auto& x: a) {
        in >> x;
    }
    return in;
};

template<typename T>
ostream& operator<<(ostream& out, const vector<T>& a) {
    for(auto x: a) {
        out << x << ' ';
    }
    return out;
};

int n, f;
vector<int> a;

void read() {
    cin >> n >> f;
    a.resize(n);
    cin >> a;
}

void solve() {
    // Direct simulation of the elevator. The pressed buttons stay in their
    // press order in the vector a, so the current destination tgt is always
    // a[0] (the earliest pressed among the still-highlighted buttons). We move
    // the current floor f one step at a time towards tgt; whenever some
    // highlighted button equals the current floor we record a stop there and
    // remove it. When we reach tgt we pick the next a[0] as the new
    // destination, stopping once no highlighted buttons remain.

    int tgt = a[0];
    vector<int> ans;
    while(!a.empty()) {
        bool added = false;
        while(true) {
            auto it = find(a.begin(), a.end(), f);
            if(it != a.end()) {
                if(!added) {
                    ans.push_back(f);
                }
                added = true;
                a.erase(it);
            } else {
                break;
            }
        }

        if(tgt == f) {
            if(a.empty()) {
                break;
            } else {
                tgt = a[0];
            }
        }

        if(tgt > f) {
            f++;
        } else {
            f--;
        }
    }

    cout << ans << '\n';
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int T = 1;
    // cin >> T;
    for(int test = 1; test <= T; test++) {
        read();
        // cout << "Case #" << test << ": ";
        solve();
    }

    return 0;
}
```

5. Python Implementation with Detailed Comments
```python
def main():
    import sys

    data = sys.stdin.read().split()
    n, cur = map(int, data[:2])
    pending = list(map(int, data[2:]))

    tgt = pending[0]  # current target = first pressed floor
    ans = []          # to record the stops

    # Loop until no pending floors remain
    while pending:
        # If we're on a pending floor, visit it immediately
        if cur in pending:
            ans.append(cur)
            was_target = (cur == tgt)
            pending.remove(cur)
            if not pending:
                break
            if was_target:
                # update target to next earliest-pressed
                tgt = pending[0]

        # Move one floor toward the target if needed
        if pending:
            if cur < tgt:
                cur += 1
            elif cur > tgt:
                cur -= 1
            # if cur == tgt, next iteration will remove it

    # Print the result
    print(' '.join(map(str, ans)))

if __name__ == "__main__":
    main()
```
