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

using i64 = int64_t;

#define rep(i, x, y) for (i64 i = i64(x), i##_max_for_repmacro = i64(y); i < i##_max_for_repmacro; ++i)
#define debug(x) #x << "=" << (x)

#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define print(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define print(x)
#endif

const int inf = 1.01e9;
const i64 inf64 = 4.01e18;
const double eps = 1e-9;

template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
    os << "(" << p.first << ", " << p.second << ")";
    return os;
}

template <typename T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
    os << "[";
    for (const auto &v : vec) {
        os << v << ",";
    }
    os << "]";
    return os;
}

template <typename T>
bool chmin(T &a, const T &b) {
    if (a > b) {
        a = b;
        return true;
    }
    return false;
}

template <typename T>
bool chmax(T &a, const T &b) {
    if (a < b) {
        a = b;
        return true;
    }
    return false;
}

template<typename T, size_t size> void fill(T (&ary)[size], const T& val){
    fill_n((T*)ary, size, val);
}

/*
    直線集合L={f_i = a_i*x+b_i}と与えられたクエリxに対してmin(f_i(x))を求めることができる.
    この実装では追加される直線の傾きが単調である場合のみ対応している.
    
    add: O(N)
    min(クエリが単調非減少の場合): O(Q)
    min(一般の場合): O(QlogN)
    N := 直線の個数
    Q := クエリの個数

    verified by https://beta.atcoder.jp/contests/colopl2018-final-open/submissions/3644416 (クエリが単調非減少ではなくかつ最小値を求める場合),
                https://atcoder.jp/contests/dp/submissions/4715408 (クエリが単調非減少ではなくかつ最大値を求める場合),
                https://atcoder.jp/contests/dp/submissions/4715369 (クエリが単調非減少かつ最小値を求める場合),
                https://atcoder.jp/contests/dp/submissions/4715255 (クエリが単調非減少かつ最大値を求める場合)
*/

template <typename T>
struct convex_hull_trick {
    static bool ge(T a, T b) {
        return a >= b;
    }

    static bool le(T a, T b) {
        return a <= b;
    }

    bool is_monotonicx;
    int head;
    function<bool(T, T)> comp;
    vector<pair<T, T>> lines;

    // is_monotonic := クエリは単調非減少か?
    // min_or_max := trueならば最小値を求める, falseならば最大値を求める
    convex_hull_trick(bool is_monotonicx, bool min_or_max) : is_monotonicx(is_monotonicx), head(0) {
        comp = min_or_max ? ge : le;
    }

    bool need(pair<T, T> &l, pair<T, T> &m, pair<T, T> &n) {
        return (n.second - m.second) * (m.first - l.first) < (m.second - l.second) * (n.first - m.first);
    }

    // 直線f(x)=ax+bを追加する.
    // 最小値を求める場合はaは単調非増加である必要がある
    // 最大値を求める場合はaは単調非減少である必要がある
    void add(T a, T b) {
        auto line = make_pair(a, b);
        while (lines.size() >= 2 and !need(*(lines.end() - 2), lines.back(), line)) lines.pop_back();
        lines.push_back(line);
    }

    T f(int i, T x) {
        return lines[i].first * x + lines[i].second;
    }

    // f_i(x)の最小値(or最大値)
    T min(T x) {
        if (is_monotonicx) {
            while (lines.size() - head >= 2 and comp(f(head, x), f(head + 1, x))) ++head;
            return f(head, x);
        } else {
            int lb = 0, ub = lines.size();
            while (ub - lb > 1) {
                int mid = (lb + ub) / 2;
                (mid == 0 or comp(f(mid - 1, x), f(mid, x)) ? lb : ub) = mid;
            }
            return f(lb, x);
        }
    }
};

void solve() {
    //const i64 mod = 1'000'000'007;

    i64 N,C;
    cin >> N >> C;

    vector<i64> h(N);
    rep(i,0,N){
        cin >> h[i];
    }

    const i64 maxn=200000;
    static i64 dp[maxn];
    fill(dp,maxn);

    convex_hull_trick<i64> cht(false, false);

    dp[0]=0;
    cht.add(2*h[0],-h[0]*h[0]-dp[0]);
    rep(i,1,N){
        dp[i]=h[i]*h[i]+C-cht.min(h[i]);
        cht.add(2*h[i],-h[i]*h[i]-dp[i]);
    }

    cout << dp[N-1] << endl;
}

int main() {
    std::cin.tie(0);
    std::ios::sync_with_stdio(false);
    cout.setf(ios::fixed);
    cout.precision(16);
    solve();
    return 0;
}


Measured memory_bytes: 9456