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

int n, m, a[100005];

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    freopen("LCD.inp", "r", stdin);
    freopen("LCD.out", "w", stdout);
    cin >> n >> m;
    for (int i = 1; i <= n; i++) cin >> a[i];

    long long min_cost = 1e18;
    // Duyệt qua tất cả các màu có thể từ 1 đến M
    for (int x = 1; x <= m; x++) {
        long long current_cost = 0;
        for (int i = 1; i <= n; i++) {
            if (a[i] == x) continue;
            if (a[i] < x) {
                current_cost += (x - a[i]);
            } else {
                current_cost += 1LL + (m - a[i]) + x;
            }
        }
        if (current_cost < min_cost) min_cost = current_cost;
    }
    cout << min_cost << endl;
    return 0;
}

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

int main() {
    ios::sync_with_stdio(false); cin.tie(nullptr);
    freopen("LCD.inp", "r", stdin);
    freopen("LCD.out", "w", stdout);
    int n, m;
    cin >> n >> m;
    vector<int> a(n + 1);
    for (int i = 1; i <= n; i++) cin >> a[i];

    vector<ll> diff(m + 5, 0);

    // Ví dụ xử lý một cặp (u, v) với u < v:
    // Khi chọn x:
    // - Nếu x <= u: Cost = v - x (giảm dần theo x)
    // - Nếu u < x <= v: Cost = x - u (tăng dần theo x)
    // - Nếu x > v: Cost = 1 + (m - v) + x (tăng dần theo x)
    // Ta có thể cập nhật các mốc thay đổi hệ số góc và hệ số tự do của hàm cost(x) bằng Difference Array.

    ll base_val = 0;
    for (int i = 2; i <= n; i++) {
        int u = a[i-1];
        int v = a[i];
        if (u < v) {
            // Mốc thay đổi:
            // x <= u: Cost = v - x (slope -1, intercept v)
            // x > u && x <= v: Cost = x - u (slope +1, intercept -u)
            // x > v: Cost = 1 + (m - v) + x (slope +1, intercept 1 + m - v)

            // Cập nhật Difference Array cho Slope
            diff[1] += -1;
            diff[u + 1] += 2; // từ -1 sang +1 (tăng 2)
            diff[v + 1] += 0; // từ +1 sang +1 (không đổi)

            // Cập nhật Difference Array cho Intercept (hoặc giá trị cơ bản)
            // ... (Phức tạp hơn, cần tách riêng cost và slope)
        } else {
            // Logic tương tự cho u >= v
            // Cost(x):
            // x > u: Cost = 1 + (m-u) + x
            // x <= u && x > v: Cost = u - x
            // x <= v: Cost = 1 + (m-x) + v
        }
    }

    // Tính toán và tìm Min
    // ... Code tổng hợp ...
}

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

int main() {
    ios::sync_with_stdio(false); cin.tie(nullptr);
    freopen("LCD.inp", "r", stdin);
    freopen("LCD.out", "w", stdout);
    int n, m;
    cin >> n >> m;
    vector<int> a(n + 1);
    for (int i = 1; i <= n; i++) cin >> a[i];

    vector<ll> diff(m + 5, 0);
    ll base = 0;

    auto add_range = [&](int l, int r, ll slope_change) {
        if (l > r) return;
        diff[l] += slope_change;
        diff[r + 1] -= slope_change;
    };

    for (int i = 2; i <= n; i++) {
        int u = a[i - 1];
        int v = a[i];

        // Base cost contribution (constant parts)
        // ... (Detailed logic based on problem analysis) ...

        if (u < v) {
            // Region 1: x in [1, u] -> Cost = v - x (Slope = -1)
            add_range(1, u, -1);
            base += v;

            // Region 2: x in [u + 1, v] -> Cost = x - u (Slope = +1)
            add_range(u + 1, v, 2); // -1 to +1 is +2 change
            base += -(2 * u + 1);

            // Region 3: x in [v + 1, m] -> Cost = 1 + (m - v) + x (Slope = +1)
            add_range(v + 1, m, 0); // Slope remains +1
            base += (1 + m - v - v); // Adjust for constant shift
        } else {
            // Logic for u >= v
            // ... Complex ...
        }
    }

    ll min_cost = 1e18;
    ll curr_slope = 0;
    ll curr_const = base;

    // Calculating exact cost requires careful tracking of base changes
    // This snippet shows the structure, exact coefficients depend on derivation.
    for (int x = 1; x <= m; x++) {
        curr_slope += diff[x];
        // Cost formula might be: curr_slope * x + curr_const
        // But curr_const also needs dynamic updates or pre-calculation
        // This is why the full logic in Solution 1 & 2 is complex.
    }

    cout << min_cost;
    return 0;
}