#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return true; } return false; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return true; } return false; }
#define all(x) (x).begin(),(x).end()
#define fi first
#define se second
#define mp make_pair
#define si(x) int(x.size())
const int mod=1000000007,MAX=100005;
const ll INF=1000000000000000000LL;
template<typename T,typename E>
struct LazySegmentTree{
    using F=function<T(T,T)>;
    using G=function<T(T,E)>;
    using H=function<E(E,E)>;
    
    int n;
    vector<T> dat;
    vector<E> lazy;
    F f;
    G g;
    H h;
    T ti;
    E ei;
    
    LazySegmentTree(int n_,F f,G g,H h,T ti,E ei) :f(f),g(g),h(h),ti(ti),ei(ei){
        n=1;
        while(n<n_) n*=2;
        dat.assign(2*n-1,ti);
        for(int i=n-2;i>=0;i--) dat[i]=f(dat[i*2+1],dat[i*2+2]);
        
        lazy.assign(2*n-1,ei);
    }
    
    LazySegmentTree(int n_,vector<T> &v,F f,G g,H h,T ti,E ei) :f(f),g(g),h(h),ti(ti),ei(ei){
        n=1;
        while(n<n_) n*=2;
        dat.assign(2*n-1,ti);
        
        for(int i=n-1;i-(n-1)<v.size();i++) dat[i]=v[i-(n-1)];
        
        for(int i=n-2;i>=0;i--) dat[i]=f(dat[i*2+1],dat[i*2+2]);
        
        lazy.assign(2*n-1,ei);
    }
    
    inline void eval(int k,int l,int r){
        
        if(lazy[k]==ei) return;
        
        dat[k]=g(dat[k],lazy[k]);
        
        if(r-l>1){
            lazy[k*2+1]=h(lazy[k*2+1],lazy[k]);
            lazy[k*2+2]=h(lazy[k*2+2],lazy[k]);
        }
        
        lazy[k]=ei;
    }
    
    void update_(int a,int b,E x,int k,int l,int r){
        
        eval(k,l,r);
        
        if(r<=a||b<=l) return;
        
        if(a<=l&&r<=b){
            lazy[k]=h(lazy[k],x);
            eval(k,l,r);
        }
        
        else{
            update_(a,b,x,2*k+1,l,(l+r)/2);
            update_(a,b,x,2*k+2,(l+r)/2,r);
            dat[k]=f(dat[2*k+1],dat[2*k+2]);
        }
        
    }
    
    void update(int a,int b,E x){
        return update_(a,b,x,0,0,n);
    }
    
    T query_(int a,int b,int k,int l,int r){
        
        eval(k,l,r);
        
        if(r<=a||b<=l) return ti;
        if(a<=l&&r<=b) return dat[k];
        
        T vl=query_(a,b,2*k+1,l,(l+r)/2);
        T vr=query_(a,b,2*k+2,(l+r)/2,r);
        return f(vl,vr);
    }
    
    T query(int a,int b){
        return query_(a,b,0,0,n);
    }
    
    void set(int k,T x){
        dat[n-1+k]=x;
    }
    
    void built(){
        for(int i=n-2;i>=0;i--) dat[i]=f(dat[i*2+1],dat[i*2+2]);
    }
    
};

int main(){
    
    std::ifstream in("text.txt");
    std::cin.rdbuf(in.rdbuf());
    cin.tie(0);
    ios::sync_with_stdio(false);
    
    int N,Q,A,B;cin>>N>>Q>>A>>B;
    A--;B--;
    if(A>B) swap(A,B);
    vector<ll> S(Q+1);
    for(int i=0;i<Q;i++){
        cin>>S[i+1];
        S[i+1]--;
    }
    S[0]=A;
    
    vector<LazySegmentTree<ll,ll>> seg(3,LazySegmentTree<ll,ll>(N,
                                                                [](ll a,ll b){return min(a,b);},
                                                                [](ll a,ll b){return a+b;},
                                                                [](ll a,ll b){return a+b;},
                                                                INF,
                                                                0LL));
    
    for(int i=0;i<N;i++){
        if(i!=B){
            seg[0].set(i,1e15);
            seg[1].set(i,1e15-i);
            seg[2].set(i,1e15+i);
        }else{
            seg[0].set(i,0);
            seg[1].set(i,-i);
            seg[2].set(i,i);
        }
    }
    
    for(int j=0;j<3;j++){
        seg[j].built();
    }
    
    for(int q=1;q<=Q;q++){
        ll a=S[q]+seg[1].query(0,S[q]+1);
        ll b=seg[2].query(S[q],N)-S[q];
        
        ll to=min(a,b);
        
        for(int j=0;j<3;j++){
            seg[j].update(0,N,abs(S[q]-S[q-1]));
        }
        
        ll diff=to-seg[0].query(S[q-1],S[q-1]+1);
        
        if(diff<0){
            for(int j=0;j<3;j++){
                seg[j].update(S[q-1],S[q-1]+1,diff);
            }
        }
    }
    
    cout<<seg[0].query(0,N)<<endl;
    
}


Measured memory_bytes: 34688