#include <bits/stdc++.h>

using namespace std;
typedef long long lli;
typedef unsigned long long int uli;
typedef long double Lf;

#define fastIO  std::ios::sync_with_stdio(false);cin.tie(NULL)
#define mod 1000000007
#define BIGL = 999999999999999999
#define BIGI = 99999999
#define N 100005
#define NN 25
#define SZ(x) ((lli) (x).size())
#define vi vector<int>
#define vl vector<long>
#define vll vector<long long>
#define vc vector<char>
#define ii <int, int>
#define ll <long, long>
#define lll <long long, long long>
#define loop(i,s,n) for(int (i)=(s);(i)<(n);(i)++)
#define loopr(i,n,s) for(int (i)=(n)-1;(i)>=(s);(i)--)
#define pb push_back
#define o2(a,b) cout<<(a)<<" "<<(b)<<endl
#define o3(a,b,c) cout<<(a)<<" "<<(b)<<" "<<(c)<<endl
#define o4(a,b,c,d) cout<<(a)<<" "<<(b)<<" "<<(c)<<" "<<(d)<<endl
#define cl cout<<endl
#define r0 return 0
#define x first
#define y second


inline lli modadd(lli n,lli m){
    return ((n+m)%mod+mod)%mod;
}

inline lli modsub(lli n,lli m){
    return ((n-m+mod)%mod+mod)%mod;
}

inline lli modpro(lli n,lli m){
    return ((n*m)%mod+mod)%mod;
}




inline uli powe(lli x,lli y){
    uli res = 1;
    while (y > 0) {
        if (y & 1)
            res = res * x;
        y = y >> 1;
        x = x * x;
    }
    return res;
}



inline lli powmod(lli x,lli y){
    lli res = 1;
    while (y > 0) {
        if (y & 1)
            res = modpro(res , x);
        y = y >> 1;
        x = modpro(x , x);
    }
    return res;
}

inline lli modadd3(lli x, lli y, lli z){
    return modadd(modadd(x,y),z);
}

inline lli modadd4(lli x, lli y, lli z, lli w){
    return modadd(modadd(x,y),modadd(z,w));
}

template <typename T>
inline T max3(T x, T y, T z){
    return max(max(x,y),z);
}

template <typename T>
inline T max4(T x, T y, T z, T w){
    return max(max3(x,y,w),z);
}

template <typename T>
inline T min3(T x, T y, T z){
    return min(min(x,y),z);
}

template <typename T>
inline T min4(T x, T y, T z, T w){
    return min(min3(x,y,w),z);
}


template <typename T>
void printArr(T *arr, int n){
    for(int i=0;i<n;i++){

        cout<<arr[i]<<" ";
    }cout<<endl;
}





//
//
//template <class T, class U>
//bool comparep(const pair<T, U>&i, const pair<T, U>&j)
//{
//    return i.first > j.first;
//}
//
//template <class T, class U>
//bool compair2(const pair<T, U>&i, const pair<T, U>&j)
//{
//    return ((i.second < j.second)||((i.second == j.second)&&i.first < j.first));
//}
//
//

//template <typename T>
//T gcd(T a, T b)
//{
//    if (a == 0)
//        return b;
//    if(b==0)
//        return a;
//    T t;
//    while((a>0)&&(b>0)){
//     t = a;
//     a=b%a;
//     b=t;
// }
//
// return max(a,b);
//}
//


//template <typename T>
//T maxof(T n_args, ...)
//{
//    va_list ap;
//    va_start(ap, n_args);
//    T big = va_arg(ap, T);
//    for(int i = 2; i <= n_args; i++) {
//        T a = va_arg(ap, T);
//        if(a > big) big = a;
//    }
//    va_end(ap);
//    return big;
//}
//
//
//
//
//template <typename T>
//T gcdarr(T a[], int n){
//    T gc = gcd<T>(a[0],a[1]);
//    loop(i,2,n) {
//        gc = gcd<T>(gc,a[i]);
//    }
//    return gc;
//}
//
//
//template <typename T>
//T maxarr(T a[], int n){
//    T big = a[0];
//    loop(i,1,n) {
//        big = max(big, a[i]);
//    }
//    return big;
//}
//
//
//
//template <typename T>
//T minarr(T a[], int n){
//    T small = a[0];
//    loop(i,1,n) {
//        small = min(small, a[i]);
//    }
//    return small;
//}
//
//uli choose(uli n, uli k){
//uli res = 1;
//
//    // Since C(n, k) = C(n, n-k)
//    if ( k > n - k )
//        k = n - k;
//
//    // Calculate value of
//    // [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1]
//    for (uli i = 0; i < k; ++i)
//    {
//        res *= (n - i);
//        res /= (i + 1);
//    }
//
//    return res;
//}
//

vector<int> v[N];
bool visited[N];
//lli a[N],b[N];
//queue<int> q;
//int color[N];

class Graph{

 public:
    int V;



    Graph(int V)
{
    this->V = V;

}

    void addEdge(int a, int b)
{
    v[a].pb(b);
    //v[b].pb(a);
}

void dfs(int x){
    visited[x]=1;
    for(auto u:v[x]){
        if(!visited[u]){
            dfs(u);
        }
    }
}

//void dfsTree(int x, int p){
//    for(int u:v[x]){
//        if(u!=p) dfs(u,x);
//    }
//
//}



//void bfs(int x){
//    visited[x]=1;
//    q.push(x);
//    while(!q.empty())
//    {
//        int s = q.front();
//        q.pop();
//
//        for(int u : v[s]){
//            if(visited[u]==1) continue;
//            visited[u]=1;
//            //cout<<u<<endl;
//            q.push(u);}}}

//int connectedcomponents(int n){
//    int ans=0;
//    loop(i,1,n+1){
//        if(!visited[i]){
//            ans++;
//            dfs(i);
//        }
//
//    }
//    return ans;
//}

};


//
//
//vector<int> parent, rank_;
//
//void makeSet(int x){
//	parent[x]=x;
//	rank_[x]=0;
//}
//
//int findSet(int x){
//	if(x!=parent[x])
//		parent[x]=findSet(parent[x]);
//
//	return parent[x];
//}
//
//void unionSets(int x, int y){
//	int px = findSet(x);
//	int py = findSet(y);
//
//	if(rank_[px]<rank_[py]){
//		parent[px]=py;
//		mm[py]=max(mm[px],mm[py]);
//	}
//	else if(rank_[py]<rank_[px]){
//		parent[py]=px;
//		mm[px]=max(mm[px],mm[py]);
//	}
//	else{
//		parent[py]=px;
//		mm[px]=max(mm[px],mm[py]);
//		rank_[px]++;
//	}
//
//}
//










//
//template <typename T>
//T findpowerfactorial(T n,T p)
//{
//    T x = 0;
//    while (n)
//    {
//        n /= p;
//        x += n;
//    }
//    return x;
//}
//
//template <typename T>
//int getibit(T n, int i){
//    //cout<<(n&(1LL<<i))<<endl;
//    return (n&(1LL<<i))?1:0;
//}
//
//template <typename T>
//int findbits(T n, T p){
//    int x=0;
//    while(n>0){
//        n/=p;
//        x++;
//    }
//    return x;
//}
//
//
//void primeFactors(int n)
//{
//    while (n % 2 == 0)
//    {
//        cout << 2 << " ";
//        n = n/2;
//    }
//
//
//    for (int i = 3; i <= sqrt(n); i = i + 2)
//    {
//        while (n % i == 0)
//        {
//            cout << i << " ";
//            n = n/i;
//        }
//    }
//    if (n > 2)
//        cout << n << " ";
//}
//
//
//
//



// bool c2(pair<lli, lli> p, pair<lli, lli> q){
// 	return p.x<q.x||((p.x==q.x)&&(p.y>q.y));
// }


//vll v[4];
//
//lli gcd(lli a, lli b){
//    int ta=max(a,b),tb=min(a,b);
//int tr,td;
//    while(ta>0&&tb>0){
//
//        tr = ta%tb;
//        td = ta/tb;
//        o4(ta,tb,tr,td);cout<<"x";
//        v[0].pb(ta);v[1].pb(td);v[2].pb(tb);v[3].pb(tr);
//        ta=tb;
//        tb=tr;
//
//    }
//    return max(ta,tb);
//}
//
//
//lli wb,wd;
//void fa(int w,int x){
//    lli a,b,c,d;
//    int n=v[0].size();
//    lli temp;
//    cout<<n<<"%";
//    if(n==1){
//        a=1;b=w; c=w/x-1;d=x;
//    }
//    else {b=v[0][n-2];a=1;c=-1*v[1][n-2];d=v[2][n-2];
//    loopr(i,v[0].size()-2,0){
//        o4(a,b,c,d);
//        d=b;
//        temp = c;
//        c = a-c*v[1][i];
//        a=temp;
//        b=v[0][i];
//    }}
//    cout<<"hi";
//    o4(a,b,c,d);
//    wb=b,wd=d;
//
//}



//lli gcd(lli a, lli b)
//{
//    if (a == 0)
//        return b;
//    if(b==0)
//        return a;
//    lli t;
//    while((a>0)&&(b>0)){
//     t = a;
//     tr = b%a;
//
//     a=b%a;
//     b=t;
// }
//
// return max(a,b);
//}



// Returns n^(-1) mod p
//int modInverse(int n, lli p)
//{
//    return powmod(n, p-2, p);
//}
//
//
//lli fac[N];
//void facinit(int n){
//    fac[0]=1;
//    for (int i=1 ; i<=n; i++)
//        fac[i] = fac[i-1]*i%mod;
//}
//int nCrModPFermat(int n, int r, lli p)
//{
//   // Base case
//   if (r==0)
//      return 1;
//
//
//    return (fac[n]* modInverse(fac[r], p) % p *
//            modInverse(fac[n-r], p) % p) % p;
//}


/*BITMASK
for( int inum = 0 ; inum < ( 1 << n ) ; ++ inum ) {
                 for ( int pos = 0; pos < n ; ++pos ) {
                     if ( ( inum & ( 1 << pos ) ) != 0 )
                          results[inum] += s [pos] ; //DO SOMETHING
                     }
                 }
           }
*/

int main(){
    fastIO;
    int erer=1;
    //cin>>erer;
    loop(erer2,1,erer+1){

        int n;
        cin>>n;
        int a[N];
        loop(i,0,n)cin>>a[i];

        lli dp[N];
        dp[n-1]=0;
        dp[n-2]=abs(a[n-1]-a[n-2]);
        loopr(i,n-2,0){
            //if((a[i]<=a[i+1]&&a[i+1]<=a[i+2])||(a[i]>=a[i+1]&&a[i+1]>=a[i+2]))
            {
                dp[i]=min(dp[i+2]+abs(a[i]-a[i+2]),dp[i+1]+(abs(a[i]-a[i+1])));
            }
        }

        cout<<dp[0];

    }
    return 0;
}


Measured memory_bytes: 3840