#include <bits/stdc++.h>
using namespace std;

#define fs first
#define sc second
#define pb emplace_back
#define mp make_pair
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()

constexpr int mod = 1e9 + 7;
constexpr int32_t inf = 1001001001;
constexpr int64_t infll = 1001001001001001001ll;
constexpr int dx[] = {0, -1, 1, 0, -1, 1, -1, 1}, dy[] = {-1, 0, 0, 1, -1, -1, 1, 1};
const string YES = "YES", NO = "NO", Yes = "Yes", No = "No", yes = "yes", no = "no";

// clang-format off
// ostream &operator<<(ostream &os, __int128_t value) { if (ostream::sentry(os)) { __uint128_t tmp = value < 0 ? -value : value; char buffer[64]; char *d = end(buffer); do { --d; *d = "0123456789"[tmp % 10]; tmp /= 10; } while (tmp != 0); if (value < 0) { --d; *d = '-'; } int len = end(buffer) - d; if (os.rdbuf()->sputn(d, len) != len) { os.setstate(ios_base::badbit); }} return os; }
// istream &operator>>(istream &is, __int128_t &value) { string in; is >> in; value = 0; for (const char &c : in) { if ('0' <= c && c <= '9') value = 10 * value + (c - '0'); } if (in[0] == '-') value *= -1; return is; }
// ostream &operator<<(ostream &os, __uint128_t value) { if (ostream::sentry(os)) { char buffer[64]; char *d = end(buffer); do { --d; *d = "0123456789"[value % 10]; value /= 10; } while (value != 0); int len = end(buffer) - d; if (os.rdbuf()->sputn(d, len) != len) { os.setstate(ios_base::badbit); }} return os; }
// istream &operator>>(istream &is, __uint128_t &value) { string in; is >> in; value = 0; for (const char &c : in) { if ('0' <= c && c <= '9') value = 10 * value + (c - '0'); } return is; }
template <typename T> ostream &operator<<(ostream &os, vector<T> &v) { os << v[0]; for (int i = 1; i < v.size(); ++i) os << " " << v[i]; return os; }
template <typename T> istream &operator>>(istream &is, vector<T> &v) { for (T &in : v) is >> in; return is; }
template <typename T1, typename T2> ostream &operator<<(ostream &os, pair<T1, T2> p) { os << p.fs << " " << p.sc; return os; }
template <typename T1, typename T2> istream &operator>>(istream &is, pair<T1, T2> &p) { is >> p.fs >> p.sc; return is; }

struct IoSetup { IoSetup(){ cin.tie(0); ios::sync_with_stdio(0); cout << fixed << setprecision(10); cerr << fixed << setprecision(10); } } iosetup;

inline int64_t in() { int64_t x = 0; cin >> x; return x; }

template <typename T> void sort(vector<T> &v) { sort(all(v)); }
template <typename T> vector<T> make_v(size_t a, T b) { return vector<T>(a, b); }
template <typename... Ts> auto make_v(size_t a, Ts... ts) { return vector<decltype(make_v(ts...))>(a, make_v(ts...)); }
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) { return a > b && (a = b, true); }
// clang-format on

template <typename Monoid, typename OperatorMonoid = Monoid> struct LazySegmentTree {
  using F = function<Monoid(Monoid, Monoid)>;
  using G = function<Monoid(Monoid, OperatorMonoid)>;
  using H = function<OperatorMonoid(OperatorMonoid, OperatorMonoid)>;
  using P = function<OperatorMonoid(OperatorMonoid, int)>;

  size_t sz;
  vector<Monoid> data;
  vector<OperatorMonoid> lazy;
  const F f;
  const G g;
  const H h;
  const P p;
  const Monoid M1;
  const OperatorMonoid OM0;

  LazySegmentTree(size_t n, const F f, const G g, const H h, const P p, const Monoid &M1, const OperatorMonoid &OM0) : sz(1 << (32 - __builtin_clz(n - 1))), f(f), g(g), h(h), p(p), M1(M1), OM0(OM0) {
    data.assign(2 * sz, M1);
    lazy.assign(2 * sz, OM0);
  }

  void set(int k, const Monoid &x) {
    data[k + sz] = x;
  }

  void build() {
    for (int k = sz - 1; k; --k) {
      data[k] = f(data[2 * k], data[2 * k + 1]);
    }
  }

  void propagate(int k, int length) {
    if (lazy[k] != OM0) {
      if (k < sz) {
        lazy[2 * k + 0] = h(lazy[2 * k + 0], lazy[k]);
        lazy[2 * k + 1] = h(lazy[2 * k + 1], lazy[k]);
      }

      data[k] = g(data[k], p(lazy[k], length));
      lazy[k] = OM0;
    }
  }

  void update(int k, Monoid x) {
    query(k, k + 1);
    k += sz;
    data[k] = x;
    while (k) {
      k >>= 1;
      data[k] = f(data[k * 2], data[k * 2 + 1]);
    }
  }

  Monoid update(int a, int b, const OperatorMonoid &x) {
    return update(a, b, x, 1, 0, sz);
  }

  Monoid update(int a, int b, const OperatorMonoid &x, int k, int l, int r) {
    propagate(k, r - l);

    if (r <= a || b <= l) {
      return data[k];
    } else if (a <= l && r <= b) {
      lazy[k] = h(lazy[k], x);
      propagate(k, r - l);
      return data[k];
    } else {
      return data[k] = f(update(a, b, x, 2 * k, l, (l + r) >> 1), update(a, b, x, 2 * k + 1, (l + r) >> 1, r));
    }
  }

  Monoid query(int a, int b) {
    return query(a, b, 1, 0, sz);
  }

  Monoid query(int a, int b, int k, int l, int r) {
    propagate(k, r - l);

    if (r <= a || b <= l) {
      return M1;
    } else if (a <= l && r <= b) {
      return data[k];
    } else {
      return f(query(a, b, 2 * k, l, (r + l) >> 1), query(a, b, 2 * k + 1, (r + l) >> 1, r));
    }
  }
};

signed main(int argc, char *argv[]) {
  int n = in(), q = in(), a = in() - 1, b = in() - 1;

  auto f = [](int64_t a, int64_t b) { return min(a, b); };
  auto g = [](int64_t a, int64_t b) { return a + b; };
  auto h = [](int64_t a, int64_t b) { return (a < 0 ? 0 : a) + b; };
  auto p = [](int64_t a, int b) { return a; };
  LazySegmentTree<int64_t> dp1(n, f, g, h, p, infll, -1), dp2(n, f, g, h, p, infll, -1);

  auto update = [&](int k, int64_t x) {
    dp1.update(k, x - k);
    dp2.update(k, x + k);
  };

  auto get = [&](int k) { return min(dp1.query(0, k + 1) + k, dp2.query(k, n) - k); };

  update(a, 0);
  for (int i = 0; i < q; ++i) {
    int x = in() - 1;
    int64_t mini = get(x);

    // auto debug = [n](auto &seg) {
    //   for (int i = 0; i < n; ++i) {
    //     cerr << seg.query(i, i + 1) << (i + 1 == n ? "\n" : " ");
    //   }
    // };
    // debug(dp1);
    // debug(dp2);

    dp1.update(0, n, abs(x - b));
    dp2.update(0, n, abs(x - b));
    update(b, mini);

    b = x;
  }

  int64_t ans = infll;
  for (int i = 0; i < n; ++i) {
    chmin(ans, get(i));
  }

  cout << ans << endl;
}


Measured memory_bytes: 18688