#include <bits/stdc++.h>

using namespace std;

#define REP(var, n)  for (int var = 0; var < (n); var++)
#define RREP(var, n)  for (auto var = n - 1; var != static_cast<int>(-1); var--)
#define FOR(var, a, b)  for (auto var = (a); var < (b); var++)
#define RFOR(var, a, b)  for (auto var = b - 1; var != a; var--)

typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef pair<int, int> pii;

#define all(c) begin(c),end(c)

#define D(x) do { std::cerr << x << " "; } while (0)
#define D2(x) do { std::cerr << #x << ": " << x << std::endl; } while (0)


template<typename T>
std::ostream &operator<<(std::ostream &out, const std::vector<T> &v) {
    if (!v.empty()) {
        out << '[';
        std::copy(v.begin(), v.end(), std::ostream_iterator<T>(out, ", "));
        out << "\b\b]";
    }
    return out;
}


template<typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
    return os << '(' << p.first << ',' << p.second << ')';
}


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;
}

int MOD = (int) 1e9 + 7;

#include <algorithm>
#include <functional>
#include <utility>
#include <vector>

template<typename T>
class ConvexHullTrick {
private:
    // 直線群(配列)
    std::vector<std::pair<T, T>> lines;
    // 最小値(最大値)を求めるxが単調であるか
    bool isMonotonicX;
    // 最小/最大を判断する関数
    std::function<bool(T l, T r)> comp;

public:
    // コンストラクタ ( クエリが単調であった場合はflag = trueとする )
    ConvexHullTrick(bool flagX = false, std::function<bool(T l, T r)> compFunc = [](T l, T r) { return l >= r; })
            : isMonotonicX(flagX), comp(compFunc) {
        lines.emplace_back(0, 0);
    };

    // 直線l1, l2, l3のうちl2が不必要であるかどうか
    bool check(std::pair<T, T> l1, std::pair<T, T> l2, std::pair<T, T> l3) {
        if (l1 < l3) std::swap(l1, l3);
        return (l3.second - l2.second) * (l2.first - l1.first) >= (l2.second - l1.second) * (l3.first - l2.first);
    }

    // 直線y=ax+bを追加する
    void add(T a, T b) {
        std::pair<T, T> line(a, b);
        while (lines.size() >= 2 && check(*(lines.end() - 2), lines.back(), line))
            lines.pop_back();
        lines.emplace_back(line);
    }

    // i番目の直線f_i(x)に対するxの時の値を返す
    T f(int i, T x) {
        return lines[i].first * x + lines[i].second;
    }

    // i番目の直線f_i(x)に対するxの時の値を返す
    T f(std::pair<T, T> line, T x) {
        return line.first * x + line.second;
    }

    // 直線群の中でxの時に最小(最大)となる値を返す
    T get(T x) {
        // 最小値(最大値)クエリにおけるxが単調
        if (isMonotonicX) {
            static int head = 0;
            while (lines.size() - head >= 2 && comp(f(head, x), f(head + 1, x)))
                ++head;
            return f(head, x);
        } else {
            int low = -1, high = lines.size() - 1;
            while (high - low > 1) {
                int mid = (high + low) / 2;
                (comp(f(mid, x), f(mid + 1, x)) ? low : high) = mid;
            }
            return f(high, x);
        }
    }
};


auto solve() {
    int N;
    ll C;
    cin >> N >> C;
    vll h(N);
    for (auto &&e:h)cin >> e;

    ConvexHullTrick<ll> cht(true);

    const ll LINF = 1ll << 60;
    vll dp(N, LINF);
    dp[0] = 0;
    REP(i, N - 1) {
        cht.add(-2 * h[i], h[i] * h[i] + dp[i]);
        dp[i + 1] = cht.get(h[i + 1]) + h[i + 1] * h[i + 1] + C;
    }

    return dp[N - 1];
}


int main() {
    cout.precision(30);
    cin.tie(0);
    ios::sync_with_stdio(false);

//    cout << (solve() ? "Heisei" : "TBD") << endl;
//    cout << (solve() ? "YES" : "NO") << endl;
    cout << solve() << endl;
//    solve();

    return 0;
}

Measured memory_bytes: 9328