#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<LL, LL> PII;

// chmax, chmin
template <class T>
inline bool chmax(T& a, T b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
  if (a > b) {
    a = b;
    return 1;
  }
  return 0;
}

template <typename T>
function<T(T, T)> op_max = [](T a, T b) -> T { return max(a, b); };
template <typename T>
function<T(T, T)> op_min = [](T a, T b) -> T { return min(a, b); };

template <typename T>
function<T(T, T)> op_sum = [](T a, T b) -> T { return a + b; };

namespace detail {
template <typename T, std::size_t NDIMS>
struct vector_builder {
  using type = std::vector<typename vector_builder<T, NDIMS - 1>::type>;

  static type make(std::vector<std::size_t> dims, const T& v = {}) {
    const auto vec = std::vector<T>(dims.empty() ? 0 : dims.back(), v);
    if (!dims.empty()) dims.pop_back();
    return vector_builder<std::vector<T>, NDIMS - 1>::make(dims, vec);
  }
};

template <typename T>
struct vector_builder<T, 1> {
  using type = std::vector<T>;

  static type make(std::vector<std::size_t> dims, const T& v = {}) {
    return type(dims.empty() ? 0 : dims.back(), v);
  }
};
}  // namespace detail

template <typename T, typename... SIZE_T>
auto exvector(const T& v, SIZE_T... dims) {
  static_assert(sizeof...(dims) != 0, "invalid dimension");
  std::vector<std::size_t> vec_dims{dims...};
  return detail::vector_builder<T, sizeof...(dims)>::make(vec_dims, v);
}

using namespace std;
//********************  dumps ************************//

template <typename T>
void dump(const T& data, vector<int>& iter) {
  cout << data << " ";
}
template <typename T>
void dump(const vector<T>& data, vector<int>& iter) {
  for (auto elem : data) dump(elem, iter);
  cout << endl;
}

template <typename T>
void dump(const vector<vector<T>>& data, vector<int>& iter) {
  for (auto elem : iter) {
    cout << "[" << elem << "]";
  }
  cout << endl;
  for (int i = 0; i < data.size(); i++) {
    iter.push_back(i);
    dump(data[i], iter);
    iter.pop_back();
  }
  cout << endl;
}

template <typename T>
void dump(const vector<T>& data, int dummy) {
  for (int i = 0; i < data.size(); i++) {
    cout << "[" << i << "] " << data[i] << endl;
  }
}
template <typename T>
void dump(const T& data) {  // T : data, U = base type val.
  vector<int> iter;
  dump(data, iter);
}
struct TDummy {
  LL val;
  LL a;
  LL b;
};

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

 public:
  void main_setting(bool flagX, function<bool(T, T)> compFunc = [](T l, T r) {
    return l >= r;
  }) {
    isMonotonicX = flagX;
    comp = compFunc;
    lines.emplace_back(PII(0, 1LL << 41));
  }

  ConvexHullTrick() {}
  ConvexHullTrick(vector<TElement> vals) {
    main_setting(false);
    vector<PII> lines;
    transform(vals.begin(), vals.end(), back_inserter(lines),
              [](TElement val) { return PII(val.a, val.b); });
    sort(lines.begin(), lines.end());
    for (auto line : lines) {
      add(line.first, line.second);
    }
  }
  // コンストラクタ ( クエリが単調であった場合はflag = trueとする )
  ConvexHullTrick(bool flagX, function<bool(T, T)> compFunc = [](T l, T r) {
    return l >= r;
  }) {
    main_setting(flagX, compFunc);
  }

  // 直線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);
    }
  }
  T query(TQuery input) { return get(input.val); }
};

int main() {
  LL N, C;
  cin >> N >> C;
  vector<LL> dp(N, 0);
  ConvexHullTrick<LL> cht(false);
  for (int i = 0; i < N; i++) {
    LL h;
    cin >> h;
    if (i == 0)
      dp[i] = 0;
    else {
      LL val = cht.get(-2 * h);
      val += h * h;
      val += C;
      dp[i] = val;
    }
    cht.add(h, dp[i] + h * h);
  }
  cout << dp.back() << endl;

  return 0;
}

Measured memory_bytes: 8048