////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/multiprecision/cpp_int.hpp>

#include <boost/rational.hpp>
*/
//#include <atcoder/all>
#include <bits/stdc++.h>
using namespace std;
//using namespace atcoder;
#define _GLIBCXX_DEBUG
#define rep(i,t) for (ll i = (ll)(0); i < (ll)(t); i++)
#define rep2(i,s,t) for (ll i = (ll)(s); i < (ll)(t); i++)
#define rep3(i,t) for (ll i = (ll)(1); i <= (ll)(t); i++)
#define rep4(i,s,t) for (ll i = (ll)(s); i <= (ll)(t); i++)
#define repr(i,t) for (ll i = (t-1); i>=(0);i--)
#define repr2(i,s,t) for (ll i = (t-1); i>=(s);i--)
#define repr3(i,t) for (ll i = (t); i>=(1);i--)
#define repr4(i,s,t) for (ll i = (t); i>=(s);i--)
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using uint = unsigned;
using pcc =pair<char,char>;
using pll = pair<ll,ll>;
using pii = pair<int,int>;
using pdd = pair<double,double>;
using tuplis = array<ll,3>;
template<class T> using pq = priority_queue<T,vector<T>,greater<T>>;
const ll LINF = 1e18;
const ll MINF = 1e15;
const int INF = 1e9+1e5;
const int mod=1000000007;
//const int mod=998244353;



const ld DINF = numeric_limits<ld>::infinity();
const ld EPS=1e-9;
const ld PI=acos(-1);
//const ll dx[] ={0,1,0,-1,1,-1,1,-1};
//const ll dy[] ={1,0,-1,0,1,1,-1,-1};
bool ingrid(const int i,const int j,const int H,const int W){return i>=0&&i<H&&j>=0&&j<W;}
const ll dx[] ={0,1,0,-1};
const ll dy[] ={1,0,-1,0};
bool is_low(char c){ return('a'<=c)&&(c<='z');}
bool is_upp (char c) {return('A'<=c)&&(c<='Z');}
#define each1(i,a) for(auto&& i:a)
#define each2(x,y,a) for(auto&& [x,y]:a)
#define each3(x,y,z,a) for(auto&& [x,y,z]:a)
#define rrep(n) for(ll i=(n);i--;)
#define stlen(s) ll s.size()-1
#define all(v) begin(v), end(v)
#define range(v,a) begin(v),begin(v)+a
#define range2(v,a,b) begin(v)+a,begin(v)+b
#define range3(v,a) begin(v)+1,begin(v)+a+1
#define range4(v,a,b) begin(v)+a+1,begin(v)+b+1
#define allr(v) rbegin(v), v.rend(v)
#define ranger(v,a) rbegin(v),rbegin(v)+a
#define ranger2(v,a,b) rbegin(v)+a,rbegin(v)+b
#define ranger3(v,a) rbegin(v)+1,rbegin(v)+a+1
#define ranger4(v,a,b) rbegin(v)+a+1,rbegin(v)+b+1
#define cout(n) cout<<std::fixed<<std::setprecision(n)
//#define sum(...) accumulate(all(__VA_ARGS__),0LL)
#define dsum(...) accumulate(all(__VA_ARGS__),0.0L)
#define elif else if
#define unless(a) if(!(a))
#define mp make_pair
#define mt make_tuple
#define INT(...) int __VA_ARGS__; in(__VA_ARGS__)
#define LL(...) ll __VA_ARGS__; in(__VA_ARGS__)
#define ULL(...) ull __VA_ARGS__; in(__VA_ARGS__)
#define STR(...) string __VA_ARGS__; in(__VA_ARGS__)
#define CHR(...) char __VA_ARGS__; in(__VA_ARGS__)
#define DBL(...) double __VA_ARGS__; in(__VA_ARGS__)
#define LD(...) ld __VA_ARGS__; in(__VA_ARGS__)
#define Sort(a) sort(all(a))
#define Rev(a) reverse(all(a))
#define Uniq(a) sort(all(a)); a.erase(unique(all(a)),end(a));
#define vec(type,name,...) vector<type> name(__VA_ARGS__)
#define VEC(type,name,size) vector<type> name(size); in(name)
#define vv(type,name,h,...) vector<vector<type>> name(h,vector<type>(__VA_ARGS__))
#define VV(type,name,h,w) vector<vector<type>> name(h,vector<type>(w)); in(name)
template<class T> inline const auto min(const T& a){ return *min_element(all(a));}
template<class T> inline const auto max(const T& a){ return *max_element(all(a));}
inline const ll popcnt(const ull a){return __builtin_popcountll(a);}
inline const ll gcd(ll a,ll b){while(b){ll c=b; b=a%b;a=c;}return a;}
inline const ll lcm(ll a,ll b){unless(a&&b) return 0;return a*b/gcd(a,b);}
inline const ll intpow(ll a,ll b){ll ans=1; while(b){if(b&1)ans*=a;a *=a; b/=2;}return ans;}
//inline const ll modpow(ll a,ll b, ll p=mod){ll ans=1; while(b){if(b&1)(ans*=a)%=p;(a*=a)%=p;b/=2;}return ans;}
template<class T,class U>inline const bool chmin(T& a,const U& b){if(a>b){a=b;return 1;}return 0;}
template<class T,class U>inline const bool chmax( T& a,const U& b){if(a<b){a=b;return 1;}return 0;}
inline const vector<ll> iota(const ll n){vector<ll> a(n); iota(all(a),0);return a;}
inline const vector<pll> factor(ull x){vector<pll> ans; for(ull i=2;i*i<=x;i++)if(x%i==0){ans.push_back({i,1});while((x/=i)%i==0)ans.back().second++;}if(x!=1)ans.push_back({x,1});return ans;}
inline const map<ll,ll> factor_map(ull x){map<ll,ll> ans; for(ull i=2; i*i<=x;i++)if(x%i==0){ans[i]=1;while((x/=i)%i==0)ans[i]++;}if(x!=1)ans[x]=1;return ans;}
inline const vector<ll> divisor(ull x){vector<ll> ans; for(ull i=2;i*i<=x;i++)if(x%i==0)ans.push_back(i);rrep(ans.size()-(ans.back()*ans.back()==x))ans.push_back(x/ans[i]);return ans;}
inline const int scan() {return getchar();}
inline const void scan(int &a){scanf("%d", &a);}
inline const void scan(unsigned& a){scanf("%u",&a);}
inline const void scan(long& a){scanf("%ld",&a);}
inline const void scan(long long& a){scanf("%lld", &a);}
inline const void scan(char& a){ do{a=getchar();}while(a==' '||a=='\n');}
inline const void scan(float& a){ scanf("%f",&a);}
inline const void scan(double& a){ scanf("%lf",&a);}
inline const void scan(long double& a){ scanf("%Lf",&a);}
inline const void scan( string& a){cin>> a;}
template<class T>inline const void scan( vector<T>& a){for(auto&& i:a)scan(i);}
template<class T,size_t size>inline const void scan(array<T, size>& a){for(auto&& i:a)scan(i);}
template<class T,class L>inline const void scan( pair<T,L>&p){scan(p.first);scan(p.second);}
template<class T,size_t size>inline const void scan( T (&a)[size]){ for(auto&& i:a)scan(i);}
inline const void in(){}
template <class Head,class... Tail>inline const void in( Head& head, Tail&... tail){scan(head);in(tail...);}
inline const int ctoi(const char c){if(c>='a'&&c<='z'){return c-'a';} if(c>='A'&&c<='Z'){return c-'A';}if(c>='0'&&c<='9'){return c-'0';}return -1;}
inline const void print(){putchar(' ');}
inline const void print(const bool a){printf("%d", a);}
inline const void print(const int a){printf("%d",a);}
inline const void print(const unsigned a){ printf("%u",a);}
inline const void print(const long a){printf("%ld",a);}
inline const void print(const unsigned long long a){printf("%llu",a);}
inline const void print(const char a){ printf("%c",a);}
inline const void print(const double a){printf("%.15f",a);}
inline const void print(const long double a){printf("%.15Lf",a);}
inline const void print(const string&a){for(auto&&i :a)print(i);}
template<class T> inline const void print(const vector<T> &a){if(a.empty())return ;print(a[0]);for(auto i=a.begin();++i!=a.end();){putchar(' ');print(*i);}}
template<class T> inline const void print(const deque<T>&a ){if(a.empty())return;print(a[0]);for(auto i=a.begin(); ++i!=a.end();){putchar(' ');print(*i);}}
template<class T, size_t size>inline const void print(const T (&a)[size]){print(a[0]);for(auto i=a;++i!=end(a);){putchar(' ');print(*i);}}
template<class T>inline const void print(const T& a){cout<<a;}
inline const int out(){putchar('\n');return 0;}
template<class T> inline const int out(const T& t){print(t);putchar('\n');return 0;}
template<class Head,class... Tail>inline const int out(const Head& head,const Tail&... tail){print(head);putchar(' ');out(tail...);return 0;}
inline const int first(const bool i){return out(i?"first":"second");}
inline const int yes(const bool i){return out(i?"yes":"no");}
inline const int Yes(const bool i){return out(i?"Yes":"No");}
inline const int YES(const bool i){return out(i?"YES":"NO");}
inline const int possible(const bool i){return out(i?"possible":"impossible");}
inline const int Possible(const bool i){return out(i?"Possible":"Impossible");}
inline const int POSSIBLE(const bool i){return out(i?"POSSIBLE":"IMPOSSIBLE");}

 
using Graph = vector<vector<int>>;
using Graphw = vector<vector<pair<ll,int>>>;
using mat = vector<vector<ll>>;
using vec = vector<ll>;


/*
namespace mp = boost::multiprecision;
// 任意長整数型
using Bint = mp::cpp_int;
// 仮数部長が32の浮動小数点数型
using Real32 = mp::number<mp::cpp_dec_float<32>>;
// 仮数部長が1024の浮動小数点数型
using Real1024 = mp::number<mp::cpp_dec_float<1024>>;
// 有理数型
using Rat = boost::rational<Bint>;
*/


template <class Tp>
class lines {
  // based on Li Chao tree
  std::map<Tp, size_t> enc;
  std::vector<Tp> dec;
  std::vector<std::pair<Tp, Tp>> c;
  size_t m = 1;
  Tp inf = std::numeric_limits<Tp>::max() / 8;
 
private:
  void init_resize(size_t n) {
    while (m < n+n) m <<= 1;
    c.assign(m, {0, inf});
  }
 
  void inspect() const {
    for (size_t i = 1; i < m; ++i) {
      std::string s = (c[i].first < inf? std::to_string(c[i].first) : "inf");
      std::string t = (c[i].second < inf? std::to_string(c[i].second) : "inf");
      fprintf(stderr, "(%s, %s)%c", s.c_str(), t.c_str(), (i&(i+1))? ' ':'\n');
    }
  }
 
public:
  template <class ForwardIt>
  lines(ForwardIt first, ForwardIt last): dec(first, last) {
    static_assert(std::is_same<typename ForwardIt::value_type, Tp>::value, "Type mismatch");
    std::sort(dec.begin(), dec.end());
    size_t n = dec.size();
    init_resize(n);
    while (dec.size() < m/2) dec.push_back(dec.back()+1);
    // dec.resize(m/2, dec.back());
    for (size_t i = 0; i < m/2; ++i) enc.emplace(dec[i], i);
  }
 
  void append(Tp a, Tp b) {
    // fprintf(stderr, "append: %jdx%+jd\n", a, b);
    size_t l = 0;
    size_t j = 1;
    size_t h = 1;
    size_t w = m/2;
    while (w > 1 && l+w-1 < dec.size()) {
      // fprintf(stderr, "l: %zu, h: %zu, w: %zu\n", l, h, w);
      Tp xl = dec.at(l);
      Tp xm = dec.at(l+w/2);
      Tp xr = dec.at(l+w-1);
 
      // fprintf(stderr, "xs: (%jd, %jd, %jd)\n", xl, xm, xr);
 
      Tp a0, b0;
      std::tie(a0, b0) = c[j];
 
      Tp yl0 = a0*xl + b0;
      Tp ym0 = a0*xm + b0;
      Tp yr0 = a0*xr + b0;
 
      Tp yl = a*xl + b;
      Tp ym = a*xm + b;
      Tp yr = a*xr + b;
 
      // fprintf(stderr, "(yl0, ym0, yr0): (%jd, %jd, %jd)\n", yl0, ym0, yr0);
      // fprintf(stderr, "(yl, ym, yr): (%jd, %jd, %jd)\n", yl, ym, yr);
 
      if (yl0 <= yl && yr0 <= yr) {
        // fprintf(stderr, "broken 0\n");
        break;
      }
      if (yl0 >= yl && yr0 >= yr) {
        c[j] = {a, b};
        // fprintf(stderr, "[%zu] <- (%jd, %jd)\n", h+l, a, b);
        // fprintf(stderr, "broken 1\n");
        break;
      }
 
      if (ym0 >= ym) {
        if (yr0 >= yr) {
          c[j] = {a, b};
          a = a0;
          b = b0;
          j <<= 1;
        } else {
          c[j] = {a, b};
          a = a0;
          b = b0;
          j = j << 1 | 1;
          l += w/2;
        }
      } else {
        if (yr0 >= yr) {
          j = j << 1 | 1;
          l += w/2;
        } else {
          j <<= 1;
        }
      }
 
      h <<= 1;
      w >>= 1;
    }
    // inspect();
    // fprintf(stderr, "\n");
  }
 
  Tp min_at(Tp x) const {
    size_t i = enc.at(x) + m/2;
    Tp y = inf;
    while (i > 0) {
      Tp a, b;
      std::tie(a, b) = c[i];
      y = std::min(y, a*x+b);
      i >>= 1;
    }
    // fprintf(stderr, "min_at(%jd): %jd\n", x, y);
    return y;
  }
};
/*
construct:
lines<intmax_t> CHT(all(a));// aは座標列vector

func:
append(Tp a,Tp b)  (add line ax+b)
min_at(Tp x) (min f(x) at x)
*/
signed main(){

INT(N);
LL(C);
vector<intmax_t> h(N);
rep(i,N)cin>>h[i];
lines<intmax_t> CHT(all(h));
vector<intmax_t> dp(N);
dp[0]=0;
rep(i,N){
    if(i)dp[i]=CHT.min_at(h[i])+C+h[i]*h[i];
    CHT.append(-2*h[i],h[i]*h[i]+dp[i]);
}
out(dp[N-1]);

}

Measured memory_bytes: 32992