/*==========================================================================================*\
**                        _           _ _   _     _  _         _                            **
**                       | |__  _   _/ | |_| |__ | || |  _ __ | |__                         **
**                       | '_ \| | | | | __| '_ \| || |_| '_ \| '_ \                        **
**                       | |_) | |_| | | |_| | | |__   _| | | | | | |                       **
**                       |_.__/ \__,_|_|\__|_| |_|  |_| |_| |_|_| |_|                       **
\*==========================================================================================*/
//=====================================
//Solution Briefing - Foreword



//=====================================
//Libraries and namespaces
//#include <bits/stdc++.h>
#include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <fstream>
#include <functional>
#include <iostream>
#include <iomanip>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
#include <utility>

#if __cplusplus >= 201103L
#include <unordered_map>
#include <unordered_set>
#include <random>
#include <chrono>
#endif // __cplusplus

using namespace std;

//#define DEBUG
#define OPTIONAL_FEATURE

//=====================================
//Macroes
#define sp ' '
#define el '\n'
#define task ""
#define maxinp ()
#define fi first
#define se second
#define pb push_back
#define whole(x) x.begin(),x.end()
#define whole_1(x) x.begin()+1,x.end()
#define r_whole(x) x.rbegin(),x.rend()
#define FOR(i, x, y) for(auto i=x; i<=y; ++i)
#define FORl(i, x, y) for(auto i=x; i<y; ++i)
#define FORb(i, x, y) for(auto i=x; i>=y; --i)
#define FORlb(i, x, y) for(auto i=x; i>y; --i)
#define MEMS(x, val) memset(x, val, sizeof(x))
#define what_is(x) cerr << #x << " is " << x << endl;
#define FILEOP()                        \
{                                       \
    freopen(task".inp", "r", stdin);    \
    freopen(task".out", "w", stdout);   \
}
#define FILEOP_DEBUG()                  \
{                                       \
    freopen(task".inp", "r", stdin);    \
    freopen(task".out", "w", stdout);   \
    freopen(task".err", "w", stderr);   \
}

//Macroes - Optional
#ifdef OPTIONAL_FEATURE
    #define pc(x) putchar(x)
    #define gc() getchar()
#endif



//=====================================
//Auxilary Functions and Fast I/O
#ifdef OPTIONAL_FEATURE
    template<class T, class R> T max(const T &__X, const R &__Y)
    {
        return __X > __Y ? __X : __Y;
    }
    template<class T, class R> T min(const T &__X, const R &__Y)
    {
        return __X < __Y ? __X : __Y;
    }
    template<class T, class R> void maximize(T &__X, R __Y)
    {
        __X = __X > __Y ? __X : __Y;
    }
    template<class T, class R> void minimize(T &__X, R __Y)
    {
        __X = __X < __Y ? __X : __Y;
    }
    template<class T> int getBit(T &__X, int __i)
    {
        return ((__X >> __i) & 1) == 1;
    }
    template<class T> bool inRange(T __L, T __R, T __X)
    {
        return __L <= __X && __X <= __R;
    }
    template<class T> T __abs(T __X)
    {
        return (__X < 0) ? -__X : __X;
    }
    template<class T> T __sqr(T __X)
    {
        return __X * __X;
    }
#endif
//Fast I/O
template<class T> inline void scan(T &__ret)
{
    __ret = T();
    char c = 0;
    bool neg = 0;

    while(isdigit(c) == 0 && c != '-') c = getchar();
    if(c == '-')
    {
        neg = 1;
        c = getchar();
    }

    for(; isdigit(c) != 0; c = getchar()) __ret = __ret * 10 + c - '0';
    __ret = (neg) ? -__ret : __ret;
}
template<class T> void print(T __X)
{
    if(__X < 0)
    {
        putchar('-');
        __X *= -1;
    }

    if(__X > 9) print(__X / 10);
    putchar(__X % 10 + '0');
}

//=====================================
//Constants



//=====================================
//Typedefs
//template<class T> struct ConvexHullOpt
//{
//    typedef long double ld;
//    typedef pair<T, T> tt;
//    typedef deque<ld> dld;
//    typedef deque<tt> dtt;
//
//    #define a first
//    #define b second
//
//    dtt dq;
//    dld x;
//
//    T query(T x_query)
//    {
//        if(dq.empty()) return T();
//
//        while(x.size() > 1 && x.front() <= x_query) x.pop_front(), dq.pop_front();
//        x.pop_front(); x.push_front(x_query);
//
//        return T(1) * dq.front().a * x_query + dq.front().b;
//    }
//    void update(T new_a, T new_b)
//    {
//        ld new_x = -1e18;
//
//        while(!dq.empty())
//        {
//            if(dq.back().a == new_a) return;
//
//            new_x = 1.0 * (dq.back().b - new_b) / (new_a - dq.back().a);
//            if(dq.size() == 1 || new_x >= x.back()) break;
//
//            dq.pop_back(); x.pop_back();
//        }
//
//        dq.emplace_back(new_a, new_b);
//        x.push_back(new_x);
//    }
//
//
//    ConvexHullOpt() {}
//};

template<class T> class ConvexHullOpt
{
private:
    typedef long double ld;
    typedef deque<ld> dqld;
    typedef deque<T> dqll;

    dqld x;
    dqll a, b;

    void pop_front()
    {
        assert(!x.empty()); x.pop_front();
        assert(!a.empty()); a.pop_front();
        assert(!b.empty()); b.pop_front();
    }
    void pop_back()
    {
        assert(!x.empty()); x.pop_back();
        assert(!a.empty()); a.pop_back();
        assert(!b.empty()); b.pop_back();
    }

public:
    T query(T x_query)        //Get the optimal value from constructed set of lines with x = a[i]
    {
        if(x.empty()) return 0LL;

        while(x.size() > 1 && x[1] <= x_query) pop_front();
        x[0] = x_query;

        return (1LL * a.front() * x_query + b.front());
    }
    void update(T new_a, T new_b)     //Add a line to the set
    {
        ld new_x = -1e18;
        while(!x.empty())
        {
            if(new_a == a.back()) return;

            new_x = 1.0 * (b.back() - new_b) / (new_a - a.back());
            if(x.size() == 1 || new_x >= x.back()) break;

            pop_back();
        }

        a.emplace_back(new_a);
        b.emplace_back(new_b);
        x.emplace_back(new_x);
    }

    ConvexHullOpt() {}
};

//=====================================
//Typedefs
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> ii;
typedef vector<bool> vb;
typedef vector<ll> vi;
typedef vector<ii> vii;
typedef vector<vi> vvi;
typedef vector<vb> vvb;
typedef vector<vii> vvii;
vi dp, a;
int n;
ll C;
//=====================================
//Functions and procedures
//File I/O and utilities
void FileInit()
{
    FILEOP()
}
void FileDebug()
{
    #ifdef DEBUG
        FILEOP_DEBUG()
    #else
        FILEOP()
    #endif
}
void FileClose()
{
    fclose(stdin);
    fclose(stdout);
}


//Enter
void Enter()
{
	scan(n);
	scan(C);

	a = dp = vi(n+1, 0LL);
	FOR(i, 1, n) scan(a[i]);
}

//Check
void Solve()
{
    ConvexHullOpt<ll> ctb;
    FOR(i, 2, n)
    {
        ctb.update(-2 * a[i-1], dp[i-1] + __sqr(a[i-1]));
        dp[i] = ctb.query(a[i]) + __sqr(a[i]) + C;
    }
    cout << dp[n] << el;
}

//Main Procedure
int main()
{
    Enter();
    Solve();
    return 0;
}

//=============================================================================//
/**    CTB, you are always in my heart and in my code <3       #30yearsCTB    **/
//=============================================================================//


Measured memory_bytes: 7808