#ifndef ENV_AC
    #define ENV_AC
    #include <stdio.h>
    #include <stdlib.h>
    #include <assert.h>
    #include <fstream>
    #include <iostream>
    #include <sstream>
    #include <iomanip>
    #include <algorithm>
    #include <bitset>
    #include <array>
    #include <vector>
    #include <queue>
    #include <set>
    #include <cmath> // 変数名にy1が使えなくなるかも…。
    #include <map>
    #include <unordered_map>
    #include <unordered_set>
    #include <limits>
    #include <functional>
    #include <string>
    #include <ext/rope>

    using int128_t = __int128_t;
    std::istream &operator>>(std::istream& input, int128_t& value) { // int128_tの入力。入力が64bitに収まる前提。
        int64_t tmp; input >> tmp; value = tmp;
        return input;
    }
    std::ostream &operator<<(std::ostream& output, const int128_t value) { // int128_tの出力。出力が64bitに収まる前提。
        output << (int64_t)value;
        return output;
    }

    namespace std {
        template<> class hash<int128_t>{
            public:
            size_t operator () ( const int128_t &x ) const {
                int64_t INF64 = std::numeric_limits<int64_t>::max();
                int64_t y1 = x / INF64;
                int64_t y2 = x % INF64;
                return hash<int64_t>()(y1) ^ hash<int64_t>()(y2);
            }
        };
    }

    int128_t imax(const int128_t a, const int128_t b) { return std::max(a, b); } // std::max, std::min は型が違うとエラーになるため、ラッパーを作る。
    int128_t imin(const int128_t a, const int128_t b) { return std::min(a, b); }
    int128_t iabs(const int128_t x) { return 0 <= x ? x : -x; }
    int128_t ipow(const int128_t x, const int128_t n) { int128_t ret = 1; for (int i = 0; i < n; i++) { ret *= x; } return ret; }

    #define rep(i, begin, end) for(int64_t i = ((int64_t)begin); i <= ((int64_t)end); i++) // (int64_t)end としておくと、end = v.size() - 2 みたいな入力で、v.size()が1でも正常(end = -1になる）に挙動する。
    #define rev(i, begin, end) for(int64_t i = ((int64_t)begin); ((int64_t)end) <= i; i--) // int128_tにすると、3重ループでコンパイルエラーになったのでint64_tにしておく。

    #define input1(begin, end, v1) v1.resize((end)+1); for (int i = (begin); i <= (end); i++) { std::cin >> v1[i]; }
    #define input2(begin, end, v1, v2) v1.resize((end)+1); v2.resize((end)+1); for (int i = (begin); i <= (end); i++) { std::cin >> v1[i] >> v2[i]; } 
    #define input3(begin, end, v1, v2, v3) v1.resize((end)+1); v2.resize((end)+1); v3.resize((end)+1); for (int i = (begin); i <= (end); i++) { std::cin >> v1[i] >> v2[i] >> v3[i]; }
    #define input4(begin, end, v1, v2, v3, v4) v1.resize((end)+1); v2.resize((end)+1); v3.resize((end)+1); v4.resize((end)+1); for (int i = (begin); i <= (end); i++) { std::cin >> v1[i] >> v2[i] >> v3[i] >> v4[i]; } 
    #define input5(begin, end, v1, v2, v3, v4, v5) v1.resize((end)+1); v2.resize((end)+1); v3.resize((end)+1); v4.resize((end)+1); v5.resize((end)+1); for (int i = (begin); i <= (end); i++) { std::cin >> v1[i] >> v2[i] >> v3[i] >> v4[i] >> v5[i]; }  
    // input_arrayはbegin = 0のときのみ動作確認。Aの要素の型をテンプレートにして関数にしたほうが丁寧かもしれない。
    #define input_array(begin, N, M, A) A.resize((begin)+(N)); for (int i = 0; i < (begin)+(N); i++) { A[i].resize((begin)+(M)); } for (int i = begin; i < (begin)+(N); i++) { for (int j = begin; j < (begin)+(M); j++) { std::cin >> A[i][j]; }}

    std::vector<int> irange(const int begin, const int end) {
        std::vector<int> ret; for (int i = begin; i <= end; i++) { ret.push_back(i); }
        return ret;
    }

    template <typename T>
    std::vector<T> accumulate_vec(const std::vector<T>& vec, const bool reverse = false) {
        std::vector<T> ret; ret.resize(vec.size());
        if (reverse == false) {
            ret[0] = vec[0];
            for (int i = 1; i < ret.size(); i++) {
                ret[i] = ret[i-1] + vec[i];
            }
        } else {
            ret[ret.size()-1] = vec[ret.size()-1];
            for (int i = ret.size() - 2; 0 <= i; i--) {
                ret[i] = ret[i+1] + vec[i];
            }
        }
        return ret;
    }

    template <typename T>
    void printvec(const std::vector<T>& vec) {
        for (int i = 0; i < vec.size(); i++) { std::cout << vec[i] << " "; } std::cout << std::endl;
    }
#endif

class Convex_Hull_Trick {
    public:
    using line = std::pair<int128_t, int128_t>;
    //__gnu_cxx::rope<line> D;
    __gnu_cxx::rope<int128_t> A;
    __gnu_cxx::rope<int128_t> B;

    line L(const int i) { return line({A[i], B[i]}); }
    int128_t value(const int i, const int128_t x) { return x * A[i] + B[i]; }
    void insert(const int i, const int128_t a, const int128_t b) {
        A.insert(A.mutable_begin() + i, a);
        B.insert(B.mutable_begin() + i, b);
    }
    void erase(const int i) { 
        A.erase(A.mutable_begin() + i);
        B.erase(B.mutable_begin() + i);
    }
    void replace(const int i, const int128_t a, const int128_t b) {
        A.replace(A.mutable_begin() + i, a); // convex_hull_trick ではAのreplaceは不要だが一応。
        B.replace(B.mutable_begin() + i, b);
        //line l; l.first = a, l.second = b;
        //D.replace(D.mutable_begin() + i, l); // エラー
    }

    // l1, l2がある時ltが必要か判定。ただし、l1.first > lt.first > l2.first が成り立っている前提。必要ならtrue
    bool judge(const line& l1, const line& lt, const line& l2) {
        return (lt.first - l2.first) * (lt.second - l1.second) < (l1.first - lt.first) * (l2.second - lt.second);
    }

    void truncate(int pos) {
        while (pos + 2 < A.size() && !judge(L(pos), L(pos+1), L(pos+2))) {
            erase(pos + 1);
        }
        while (0 <= pos - 2 && !judge(L(pos-2), L(pos-1), L(pos))) {
            erase(pos - 1); pos--;
        }
    }

    void update(const int128_t a, const int128_t b) {
        int lb = 0, ub = A.size();
        if (ub == 0 || A.back() > a) { 
            insert(ub, a, b);
            truncate(ub); 
            return;
        }
        if (a > A.front()) { 
            insert(lb, a, b);
            truncate(lb);
            return;
        }

        while (lb + 1 < ub) {
            const int mid = (lb + ub) / 2;
            if (A[mid] >= a) { lb = mid; }
            else { ub = mid; }
        }

        if (A[lb] == a) {
            if (B[lb] <= b) { return; }
            replace(lb, a, b);
            truncate(lb);
        } else {
            assert(A[lb] > a && a > A[ub]);
            if (!judge(L(lb), line({a, b}), L(ub))) { return; }
            insert(ub, a, b);
            truncate(ub);
        }
    }
    
    int128_t query(const int128_t x) {
        assert(0 < A.size());
        if (A.size() == 1) { return value(0, x); }

        int lb = 0, ub = A.size();
        if (value(lb, x) <= value(lb + 1, x)) { return value(lb, x); } // 単調増加
        if (value(ub - 2, x) >= value(ub - 1, x)) { return value(ub - 1, x); } // 単調減少
        
        while (lb + 1 < ub) {
            const int mid = (lb + ub) / 2;
            assert(0 < mid);
            if (value(mid - 1, x) > value(mid, x)) {
                lb = mid;
            } else {
                ub = mid;
            }
        }
        return value(lb, x);
    }
};

//--code begin--

int128_t N, C;
std::vector<int128_t> h;
//std::vector<std::vector<int128_t>> a;
//std::string K;
//std::vector<std::string> a;
//double X;
//std::vector<double> p;

const int128_t MAX_N = 2e5 + 10;
//const int128_t MOD = 1e9 + 7;
//const int128_t INF = std::numeric_limits<int64_t>::max();
//const double EPS = 1.0e-15;

int128_t dp[MAX_N] = {};

int main(int argc, char **argv) {
    std::cin.tie(0);
   	std::ios::sync_with_stdio(false);
    std::cout << std::fixed << std::setprecision(15);

    std::cin >> N >> C;
    input1(1, N, h);

    Convex_Hull_Trick cht;
    cht.update(-h[1]*2, h[1]*h[1] + dp[1]);

    rep (i, 2, N) {
        dp[i] = cht.query(h[i]) + h[i]*h[i] + C;
        if (i != N) {
            cht.update(-h[i]*2, h[i]*h[i] + dp[i]);
        }
        //std::cout << i << " " << dp[i] << std::endl;
    }

    /*
    rep (i, 0, cht.A.size() - 1) {
        std::cout << "l:" << cht.A[i] << " " << cht.B[i] << " ";
        if (0 <= i - 1 && i + 1 < cht.A.size()) {
            std::cout << cht.judge(cht.L(i-1), cht.L(i), cht.L(i+1));
        }
        std::cout << std::endl;
    }
    */

    std::cout << dp[N] << std::endl;
    

    return 0;
}

Measured memory_bytes: 18304