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

#define REP(i,x,y) for(ll i=x; i<=y; i++)
#define BIT(t) (1ll << (t))
#define PER(i,y,x) for(ll i=y; i>=x; i--)
#define SIZE(v) ll(v.size())
#define vll vector<ll>
#define vvll vector<vector<ll>>
#define pll pair<ll,ll>
#define UNIQUE(v) v.erase( unique(v.begin(), v.end()), v.end() );
typedef long long ll;

// struct fraction
// {
//        ll n; ll d;  //負の場合はnを負にすること
//        bool operator<(const fraction& rhs) const {
//            return n * rhs.d < rhs.n * d;
//        }
// };

// struct line
// {
//        ll a; ll b;
//        bool operator<(const line& rhs) const {
//                if (a != rhs.a) {
//                        return a > rhs.a;
//                }
//                else {
//                        return b < rhs.b;
//                }
//        }
// };

// fraction ix(line l1, line l2){
//     if(l1.a <= l2.a){
//         swap(l1, l2);
//     }
//     return {- l1.b + l2.b, l1.a - l2.a};
// }

// struct convex_hull_trick{
//     set<pair<ll,ll>> s;
//     set<fraction> c;
//     convex_hull_trick(){
//         c.insert({})
//     }
// };

// struct CHT {
//   vector<pll> deq;              // first * x + second
//   int s,t;
//   CHT(int n) {                  // n : クエリ数
//     deq.resize(n);
//     s=0, t=0;
//   }
//   void add(int a, int b) {      // a : 単調減少
//     const pll p(a,b);
//     while(s+1<t && check(deq[t-2],deq[t-1],p)) t--;
//     deq[t++] = p;
//   }
//   int incl_query(int x) {            // x : 単調増加
//     while(s+1<t && f(deq[s], x) >= f(deq[s+1], x)) s++;
//     return f(deq[s], x);
//   }
//   int query(int x) {           // 条件なし
//     int low = s-1, high = t-1;
//     while(low+1<high) {
//       int mid = low+high>>1;
//       if (isright(deq[mid], deq[mid+1], x)) low = mid;
//       else high = mid;
//     }
//     return f(deq[high], x);
//   }
// private:
//   bool isright(const pll &p1, const pll &p2, int x) {
//     return (p1.second-p2.second) >= x * (p2.first-p1.first);
//   }
//   bool check(const pll &p1, const pll &p2, const pll &p3) {
//     return (p2.first-p1.first)*(p3.second-p2.second) >=
//       (p2.second-p1.second)*(p3.first-p2.first);
//   }
//   int f(const pll &p, int x) {
//     return p.first * x + p.second;
//   }
// };

const ll INF = LLONG_MAX;

struct CHT2 {  
  CHT2() {
    // 番兵
    S.insert({L(INF,0), L(-INF,0)});
    C.insert(cp(L(INF,0),L(-INF,0)));
  }
  // for debug
  void print() {
    cout << "S : "; for (auto it : S) printf("(%lld,%lld)", it.a, it.b); puts("");
    cout << "C : "; for (auto it : C) printf("(%lld,%lld)", it.n, it.d); puts("");
  }
  void add(ll a, ll b) {
    const L p(a,b);
    It pos = S.insert(p).first;
    if (check(*it_m1(pos), p, *it_p1(pos))) {
      S.erase(pos);
      return;
    }
    C.erase(cp(*it_m1(pos), *it_p1(pos)));
    {
      It it = it_m1(pos);
      while(it!=S.begin() && check(*it_m1(it), *it, p)) --it;
      C_erase(it, it_m1(pos));
      S.erase(++it,pos);
      pos = S.find(p);
    }
    {
      It it = it_p1(pos);
      while(it_p1(it)!=S.end() && check(p,*it, *it_p1(it))) ++it;
      C_erase(++pos, it);
      S.erase(pos, it);
      pos = S.find(p);
    }
    C.insert(cp(*it_m1(pos), *pos));
    C.insert(cp(*pos, *it_p1(pos)));
  }
  ll query(ll x) {
    const L &p = (--C.lower_bound(CP(x,1,L(0,0))))->p;
    return p.a*x + p.b;
  }
  
private:
  
  template<class T> T it_p1(T a) { return ++a; }
  template<class T> T it_m1(T a) { return --a; }  
  struct L {
    ll a, b;
    L(ll a, ll b) : a(a),b(b) {}
    bool operator<(const L &rhs) const {
      return a != rhs.a ? a > rhs.a : b < rhs.b;
    }
  };
  struct CP {
    ll n,d;
    L p;
    CP(ll _n, ll _d, const L &p) : n(_n),d(_d),p(p) {
      if (d < 0) { n *= -1; d *= -1; }
    };
    bool operator<(const CP &rhs) const {
      if (n == INF || rhs.n == -INF) return 0;
      if (n == -INF || rhs.n == INF) return 1;      
      return n * rhs.d < rhs.n * d;
    }
  };
  set<L> S;
  set<CP> C;

  typedef set<L>::iterator It;
  
  void C_erase(It a, It b) {
    for (It it=a; it!=b; ++it)
      C.erase(cp(*it, *it_p1(it)));
  }
  CP cp(const L &p1, const L &p2) {
    if (p1.a == INF) return CP(-INF,1,p2);
    if (p2.a == -INF) return CP(INF,1,p2);
    return CP(p1.b-p2.b, p2.a-p1.a, p2);
  }
  bool check(const L &p1, const L &p2, const L &p3) {
    if (p1.a==p2.a && p1.b <= p2.b) return 1;
    if (p1.a == INF || p3.a == -INF) return 0;
    return (p2.a-p1.a)*(p3.b-p2.b) >= (p2.b-p1.b)*(p3.a-p2.a);
  }
};


int main(){
    ll n, c;
    cin >> n >> c;
    vll h(n + 2), dp(n + 2);
    REP(i,1,n){
        cin >> h[i];
    }
    CHT2 cht;
    cht.add(-2 * h[1], h[1] * h[1]);
    dp[1] = 0;
    REP(i,2,n){
        dp[i] = cht.query(h[i]) + h[i] * h[i] + c;
        cht.add(-2 * h[i], dp[i] + h[i] * h[i]);
    }
    cout << dp[n] << endl;

}

Measured memory_bytes: 31488