import java.io.*;
import java.util.*;

/**
 * Covered Walkway
 * @author vanb
 * 
 * This problem would be pretty easy, if it weren't for the size of the data sets.
 * If the data sets were small, a simple DP solution would suffice:
 * 
 * Let best[i] be the best you can do covering A[0]..A[i]. 
 * Then best[i] = MIN{best[j] + C + (A[i]-A[j+1])^2} for j<i
 * and best[n-1] is your solution.
 * 
 * The simple solution would be to implement two loops:
 * for( int i=0; i<n; i++ ) to compute each best[i], 
 * and for( int j=0; j<i; j++ ) to find that minimum. 
 * But, that would be O(n^2), and when n can be as large as a million,
 * that's too much. 
 * 
 * This solution will use that basic concept, but we'll find a more efficient way
 * of finding that minimum.
 * 
 * Suppose we're at A[i], and we're trying to choose whether it's best to break 
 * at A[j] or A[k] (j<k<i). Note that since the input is guaranteed to be in 
 * increasing order, A[j]<A[k]<A[i]. So, we've got to compare:
 * best[j] + C + (A[i]-A[j+1])^2 to best[k] + C + (A[i]-A[k+1])^2
 * best[j] + C + A[i]^2 - 2*A[i]*A[j+1] + A[j+1]^2 to best[k] + C + A[i]^2 - 2*A[i]*A[k+1] + A[k+1]^2
 * 
 * Since C and A[i] will be the same for any j & k, then we're comparing
 * best[j] - 2*A[i]*A[j+1] + A[j+1]^2 to best[k] - 2*A[i]*A[k+1] + A[k+1]^2.
 * 
 * If we look at this as a function of A[i] (in fact, let x=A[i]), it looks like this:
 * -2*a[j+1]*x + (best[j]+a[j+1]^2) compared to -2*a[k+1]*x + (best[k]+a[k+1]^2)
 * 
 * So, for any A[i], if we want to know if splitting between A[j] and A[j+1] is better
 * than splitting between A[k] and A[k+1], then all we have to do is plug A[i] in
 * for x in this linear equation, and see which is smaller (since smaller is better).
 * 
 * But, since these are linear, we can take some shortcuts. Think of them as lines,
 * in y=mx+b form, with m(j)=-2*A[j+1], and b(j)=(best[j]+a[j+1]^2). Look at that slope (m(j)).
 * As j increases, so does A[j+1], and so that slope becomes more intensely negative. 
 * That means that, if j<k, once k becomes a better breakpoint, j will never be better again.
 * That is, if j<k and m(k)*x+b(k) < m(j)*x+b(j) for some x, 
 * then m(k)*w+b(k) < m(j)*w+b(j) for all w>x.
 * Once k becomes better, we never have to look at j again.
 * 
 * We'll maintain a linked list of breakpoints, and remember their m's and b's.
 * We'll walk forward through this list, and never have to go back. Any new 
 * breakpoint we add will have the most negative slope, so it will need to be
 * added to the end of the list. But, it may shunt off some other breakpoints.
 * So, we'll add it to the end of the list and remove any breakpoints that it 
 * shunts off. If we do that, then we won't have to go through the whole list to find
 * the minimum. Every breakpoint will either get walked over once, or shunted off once.
 * Either way, we've reduced that process of finding the minimum to O(n) prorated
 * over the entire algorithm, making the whole thing O(n).
 *  
 */
public class covered
{
    public Scanner sc;
    public PrintStream ps;
    
    public static final int MAX = 1000000;
    
    /**
     * This represents a breakpoint between A[i-1] and A[i]
     * 
     * @author vanb
     */
    public class Breakpoint
    {
        // i
        public int index;
        
        // Slope, y-intercept of the line
        public long m, b;
        
        // Doubly linked list
        public Breakpoint next, prev;
        
        /**
         * Build a breakpoint
         * 
         * @param i Index
         * @param x A[i]
         * @param best best[i-1]
         */
        public Breakpoint( int i, long x, long best )
        {
            index = i;
            m = -2L * x;
            b = x*x + best;
            next = prev = null;
        }
        
        /**
         * A cusp between two breakpoints. This is the point where
         * 'this' stops being best and 'bp' starts being best.
         * That's just the intersection of the two lines.
         * This method returns the smallest integer greater than
         * or equal to the cusp.
         * 
         * @param bp Another Breakpoint to compare
         * @return The smallest integer greater than or equal to the cusp.
         */
        public long cusp( Breakpoint bp )
        {
            // we're looking for the intersection of two lines,
            // where m1*x+b1 = m2*x+b2. A little algebra yields
            // x = (b1-b2)/(m2-m1).
            long numerator = bp.b - b;
            long denominator = m - bp.m;
            long quotient = numerator / denominator;
            long remainder = numerator % denominator;
            return remainder==0 ? quotient : quotient+1;
        }
         
        /**
         * The value of y at any given point x on the line
         * representing this breakpoint. The smaller y,
         * the better this breakpoint is.
         * 
         * @param x X
         * @return Y
         */
        public long y( long x )
        {
            return m*x + b;
        }   
    }
    
    /**
     * Do it!
     * @throws Exception
     */
    public void doit() throws Exception
    {
        sc = new Scanner( System.in ); //new File( "covered.in" ) );
        ps = System.out; //new PrintStream( new FileOutputStream( "covered.out" ) );
        
        // Allocate arrays beforehand
        long a[] = new long[MAX];
        long best[] = new long[MAX];
        
        for(;;)
        {
            int n = sc.nextInt(); 
            long c = sc.nextLong();
            if( n==0 ) break;
            
            Breakpoint head=null, tail=null;
            a[0] = sc.nextLong();
            
            // We can cover A[0] with cost C, and that's all we can do.
            best[0] = c;
            head = tail = new Breakpoint( 0, a[0], 0L );

            for( int i=1; i<n; i++ )
            {
                a[i] = sc.nextLong();
                
                // Advance forward to the next breakpoint
                Breakpoint bp = head;
                while( bp.next!=null && bp.cusp( bp.next ) <= a[i] )
                {
                    bp=bp.next;
                }
                
                // Adjust the head of the list
                head = bp.prev==null ? bp : bp.prev;
                head.prev = null;
                
                // The result is the minimum of breaking at this breakpoint,
                // and covering all of 0..i-1 with one big cover. and then just covering A[i].
                int j = bp.index;
                best[i] = Math.min( c + (j==0?0:best[j-1]) + (a[i]-a[j])*(a[i]-a[j]), best[i-1]+c );
                    
                // Creating a new breakpoint
                Breakpoint newbp = new Breakpoint( i, a[i], best[i-1] );
                
                // Shunt off BPs from the tail of the list that get beaten by this one
                while( tail.prev!=null )
                {
                    long x = tail.cusp( tail.prev );
                    if( newbp.y( x ) >= tail.y( x ) ) break;
                    tail = tail.prev;
                }
                
                // Put this new BP at the tail
                newbp.prev = tail;
                tail.next = newbp;
                tail = newbp;
                
                // Did this go so far as to shunt off the head?
                if( tail.prev == head && head.y( a[i] )>=tail.y( a[i] ) ) 
                {
                    head = tail;
                    head.prev = null;
                }
            }
            
            ps.println( best[n-1] );
        }
    }
    
    /**
     * Main
     * @param args Unused
     * @throws Exception
     */
    public static void main( String[] args ) throws Exception
    {
        new covered().doit();
    }
}