#include <iostream>
#include <vector>
#include <algorithm>
#include <tuple>
#include <queue>

using namespace std;
struct graph {

    graph(size_t nodes)
            : m_adjacency_list(nodes) {
    }

    size_t number_of_nodes() const {
        return m_adjacency_list.size();
    }

    vector<size_t> const &neighbours_of(size_t node) const {
        return m_adjacency_list.at(node);
    }

    void add_edge(size_t from, size_t to) {
        vector<size_t> &al = m_adjacency_list.at(from);
        if (to >= m_adjacency_list.size())
            throw runtime_error("Tried to add edge to non-existant node");
        for (size_t i = 0; i < al.size(); ++i) if (al[i] == to) return;
        al.push_back(to);
    }

private:

    vector<vector<size_t>> m_adjacency_list;
};
int main() {
    int left = 0; // Broj pjesackih na lijevoj strani
    int right = 0; // Broj pjesackih na desnoj strani
    int middle = 0; // Broj pjesackih koji povezuju lijevu i desnu stranu
    int f = 7; // Kucni broj na koji treba dostaviti
    int targetPos = 0;
    int itterator = 0;

    std::cin >> left >> right >> middle;
    std::vector<int> inputs(left+right+middle);

    // Input za lijevu stranu
    for (auto &a : inputs) {
        std::cin >> a;
    }
    std::cin >> targetPos;

    // Kreiranje Grafa

    graph g(left+right+middle);
    std::cout<<"LIJEVI"<<std::endl;
    for (itterator; itterator<left; itterator++){
        g.add_edge(itterator, itterator+1);
        g.add_edge(itterator+1, itterator);
        std::cout << "addingGraph(" << itterator << "," << itterator+1 << ");" << std::endl;
        std::cout << "addingGraph(" << itterator+1 << "," << itterator << ");" << std::endl;
    }
    std::cout<<std::endl;
    std::cout<<"DESNI"<<std::endl;
    for (itterator; itterator<left+right; itterator++){
        g.add_edge(itterator+1, itterator+1+1);
        g.add_edge(itterator+1+1, itterator+1);
        std::cout << "addingGraph(" << itterator+1 << "," << itterator+1+1 << ");" << std::endl;
        std::cout << "addingGraph(" << itterator+1+1 << "," << itterator+1 << ");" << std::endl;
    }
    std::cout<<std::endl;

    for (int i = left + right; i < left + right + middle; ++i) {
        auto as_tuple = [&, i](int e) {
            return std::make_tuple(e < inputs[i], std::abs(e - inputs[i]));
        };
        auto comparer = [&, i](int lhs, int rhs){
            return as_tuple(lhs) < as_tuple(rhs);
        };
        auto it1 = std::min_element(inputs.begin(), inputs.begin() + left, comparer);
        auto it2 = std::min_element(inputs.begin() + left,
                                    inputs.begin() + left + right,
                                    comparer);
        // Assuming non-empty ranges: else check left, right with 0
        std::cout << *it1 << ", " << *it2
                  << " --> index "
                  << std::distance(inputs.begin(), it1) << ", "
                  << std::distance(inputs.begin(), it2) << std::endl;
        int leftIndex = 0;
        int rightIndex = 0;
        if(*it1<inputs[i]){
            leftIndex = std::distance(inputs.begin(), it1)+1;
        }
        else if(*it1>=inputs[i]){
            leftIndex = std::distance(inputs.begin(), it1);
        }
        if(*it2<inputs[i]){
            rightIndex = std::distance(inputs.begin(), it2)+left+1;
        }
        else if(*it1>=inputs[i]){
            rightIndex = std::distance(inputs.begin(), it2+left);
        }
        g.add_edge(leftIndex, rightIndex);
        g.add_edge(rightIndex, leftIndex);
        std::cout << "addingGraph(" << leftIndex << "," << rightIndex << ");" << std::endl;

    }
    std::cout<<std::endl;
    std::cout << '\n';

    // BFS
    vector<size_t> reached_by(g.number_of_nodes(), g.number_of_nodes());
    queue<size_t> q;
    size_t start = 0;

    int i = 5;
    auto as_tuple = [&, i](int e) { return std::make_tuple(e < targetPos,
                                                           std::abs(e - targetPos));};
    auto comparer = [&, i](int lhs, int rhs){ return as_tuple(lhs) < as_tuple(rhs); };
    auto it1 = std::min_element(inputs.begin(), inputs.begin() + left, comparer);
    auto it2 = std::min_element(inputs.begin() + left,
                                inputs.begin() + left + right,
                                comparer);
    std::cout << *it1 << ", " << *it2
              << " --> index "
              << std::distance(inputs.begin(), it1) << ", "
              << std::distance(inputs.begin(), it2) << std::endl;
    int targetIndex = 0;
    if(targetPos<=*it2){
        targetIndex = std::distance(inputs.begin(), it2)+1;

    }
    else{
        targetIndex = std::distance(inputs.begin(), it2);
    }
    std::cout<<"TARGET: "<<targetIndex;
    size_t target = targetIndex;
    reached_by[start] = start;
    q.push(start);
    while (!q.empty()) {
        size_t node = q.front();
        q.pop();
        for (size_t i = 0; i < g.neighbours_of(node).size(); ++i) {
            size_t candidate = g.neighbours_of(node)[i];
            if (reached_by[candidate] == g.number_of_nodes()) {
                reached_by[candidate] = node;
                if (candidate == target) break;
                q.push(candidate);
            }
        }
    }

    if (reached_by[target] == g.number_of_nodes())
        cout << "No path to " << target << " found!" << endl;
    else {
        int totalCount = 0;
        for (size_t node = target; node != start; node = reached_by[node]) {
            totalCount++;
        }
        std::cout<<std::endl;
        cout << totalCount << endl;
    }
}