// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

#define ll long long

#define ld long double

#define sf scanf

#define pf printf

#define pb push_back

#define llu unsigned long long

#define U unsigned int

#define SIZE 1000002

#define pie 3.14159265358979323

#define minuss 1e-6

#define FAST ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)

 

#define BIG 100000000

 

ll  lcm(ll a,ll b)

{

    ll GCD=__gcd(a,b);

    ll lcm=(a*b)/GCD;

    return lcm;

}

ll dp[100005];

ll weight[1000005],value[1000005];

ll total,val;

ll call(ll n)

{

    if(n>=total)

        return 0;

 

    if(dp[n]!=-1)

        return dp[n];

 

    ll res1=BIG,res2=BIG;

 

   // if(weight[n]+c<=val)

    res1=abs(weight[n]-weight[n+1]) + call(n+1);

    if(n+2<=total) res2=abs(weight[n]-weight[n+2]) + call(n+2);

    //cout<<n<<" "<<res1<<" "<<res2<<endl;

    dp[n]=min(res1,res2);

    return dp[n];

 

}

int main()

{

    cin>>total;

    for ( int i = 1; i <=total; ++i )

        cin>>weight[i];

 

    memset(dp, -1, sizeof(dp));

    ll ret=call(1);

    cout<<ret<<endl;

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.8018793332761052x):
#include <bits/stdc++.h>

//#pragma GCC optimize ("O3")

 

#define pb push_back

#define mp make_pair

#define fi first

#define se second

#define ll long long

#define pii pair<int,int>

#define point pair<double,double>

#define segment pair<point,point>

#define circle pair<point,double> //titik pusat, radius

#define line pair<double,double> //m,c

#define ins insert

#define er erase

 

#define FORU(a,b,c) for(int a=b; a<=c; a++)

#define FORD(a,b,c) for(int a=b; a>=c; a--)

#define FOR(a,b) for(int a=1; a<=b; a++)

#define FORA(a,b) for(auto (a) : (b))

 

const double EPS = 1e-9;

const double PI = acos(-1);

const int MOD = 1e9+7;

 

#define yu using

#define don namespace

#define sei std

 

yu don sei;

 

typedef vector<int> vi;

typedef vector<vi> vvi;

typedef vector<vector<pii>> vvii;

 

//const int nPrime=100000;

//bool isprime[nPrime];

//vector<int>prime;

//

//void pre()

//{

//  memset(isprime,1,sizeof(isprime));

//  isprime[1]=0;

//  for(int i=2;i*i<=nPrime;i++)

//  {

//      for(int j=i*i;j<nPrime;j+=i)

//      {

//          isprime[j]=0;

//      }

//  }

//  for(int i=2;i<nPrime;i++)

//  {

//      if(isprime[i])prime.pb(i);

//  }

//}

 

// ll pwr(ll b,ll e)

// {

//  if(e==0)return 1;

//  if(e==1)return b;

//  ll temp=pwr(b,e/2);

//  if(e%2==0)

//  {

//      return (temp*temp);

//  }

//  else

//  {

//      return (temp*temp*b);

//  }

// }

 

// ll modpow(ll b,ll e)

// {

//  b%=MOD;

//  if(e==0)return 1;

//  if(e==1)return b%MOD;

//  ll temp=modpow(b,e/2);

//  if(e%2==0)

//  {

//      return (temp*temp) %MOD;

//  }

//  else

//  {

//      return ((temp*temp %MOD )*b)%MOD;

//  }

// }

 

ll gcd(ll a,ll b)

{

    if(b==0)return a;

    return gcd(b,a%b);

}

 

//int n,m;

 

//bool valid(int x,int y)

//{

//  if(x<0)return 0;

//  if(y<0)return 0;

//  if(x>=n)return 0;

//  if(y>=m)return 0;

//  return 1;

//}

 

//int p[]={-1,0,1,0};

//int q[]={0,1,0,-1};

 

//int p[]={-1,-1,-1,0,0,1,1,1};

//int q[]={-1,0,1,-1,1,-1,0,1};

 

point add(point a,point b)

{

    return {a.fi+b.fi,a.se+b.se};

}

 

point sub(point a,point b)

{

    return {a.fi-b.fi,a.se-b.se};

}

 

//double dist(point a,point b)

//{

//    return ((a.fi-b.fi)*(a.fi-b.fi) + (a.se-b.se)*(a.se-b.se));

//}

 

double dist(point a,point b)

{

    return sqrt((a.fi-b.fi)*(a.fi-b.fi) + (a.se-b.se)*(a.se-b.se));

}

 

//double distPS(point a,segment b)//heron formula, extreemely prone to precison error

//{

//    double AB=rdist(a,b.fi);

//    double AC=rdist(a,b.se);

//    double BC=rdist(b.fi,b.se);

//    double s=AB+AC+BC;

//    s/=2.0;

//    return 2*sqrt(s*(s-AB)*(s-BC)*(s-AC))/BC;

//}

 

double dabs(double a)

{

    if(a+EPS>0)return a;

    return -a;

}

 

double dotProduct(point a,point b)

{

    return a.fi*b.fi + a.se*b.se;

}

 

double crossProduct(point a,point b)

{

    return a.fi*b.se - a.se*b.fi;

}

 

int ccw(point a,point b,point c)// -1 CCW 0 COL 1 CW

{

    double tmp=crossProduct(sub(b,a),sub(c,a));

    if(tmp>EPS)

    {

        return -1;

    }

    else if(tmp<-EPS)

    {

        return 1;

    }

    else

    {

        return 0;

    }

}

 

point intLiLi(point a,point b,point c,point d)

{

    return mp(((a.fi*b.se-b.fi*a.se)*(c.fi-d.fi) - (a.fi-b.fi)*(c.fi*d.se-d.fi*c.se))/((a.fi-b.fi)*(c.se-d.se) - (a.se-b.se)*(c.fi-d.fi) ),

        ((a.fi*b.se-b.fi*a.se)*(c.se-d.se)-(a.se-b.se)*(c.fi*d.se-d.fi*c.se))/((a.fi-b.fi)*(c.se-d.se) - (a.se-b.se)*(c.fi-d.fi) ));

}









int H[100010];

int n;

int memo[100010];



// f(i) = min(f(i+1) + cost, f(i+2) + cost)

int f(int index)

{

    // cout << "lagi di f(" << index << ")" << endl;

    if(index > n-1)return 100000000;

    if(index == n-1)return 0; // base case

    if(memo[index]!=-1) return memo[index]; //memo

    memo[index] = min(f(index+1) + abs(H[index] - H[index+1]), f(index+2) + abs(H[index] - H[index+2])); //rekursi

    return memo[index];

}

// f(0) -> f(2) -> f(4) = INF

//              -> f(3) = 0

//      -> f(1) ...         

int main()

{

    // memset(memo, -1, sizeof(memo)); 

    // // memset(nama_array, val, sizeof(nama_array)) -> nama_array[0,1,2,3,...] = val

    // // val = {-1, 0}

    cin>>n;

    for(int i=0;i<n;i++)memo[i]=-1;

    for(int i=0;i<n;i++)

    {

        cin>>H[i];

    }

    cout << f(0) << endl;

    return 0;

}