// Original C++ solution (slower):
#include <iostream>

#include <vector>

#include <cstdlib>

using namespace std;

template<class T> inline bool chmin(T& a, T b) {

    if (a > b) {

        a = b;

        return true;

    }

    return false;

}

template<class T> inline bool chmax(T& a, T b) {

    if (a < b) {

        a = b;

        return true;

    }

    return false;

}

const long long INF = 1LL << 60;

long long dp[200000];

int main(void){

	

    int N;cin>>N;

	  

	for(int i=0;i<200000;i++)dp[i]=INF;

	long long h[N];

    for(int i=0;i<N;i++)cin>>h[i];

    dp[0]=0;

    for(int i=1;i<N;i++){

        chmin(dp[i],dp[i-1]+abs(h[i]-h[i-1]));

        if(i>1){

        	chmin(dp[i],dp[i-2]+abs(h[i]-h[i-2]));

        }

    }

    cout<<dp[N-1]<<endl;

    return 0;

}

// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

#define ll long long

#define ull unsigned long long

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

#define REP(a,b) for(int a=0;a<(b);++a)

#define REP1(i,n) for(int i=1;i<=(n);++i)

#define debug(x) cerr<<#x<<": "<<x<<'\n'

#define all(x) (x).begin(),(x).end()

#define SZ(x) ((int)(x).size())

#define pb push_back

#define mp make_pair

#define INF (1<<29)

using namespace std;

typedef pair<int, int> P;

typedef pair<ll, ll> LP;

typedef pair<int, P> PP;

typedef pair<ll, LP> LPP;



int dy[]={0, 0, 1, -1, 0};

int dx[]={1, -1, 0, 0, 0};



template<class T=int>

T in(){T x;cin>>x;return (x);}

template<class T>

void print(T& x){cout<<x<<'\n';}



const int MOD =(int)1e9+7;

const int MAX =510000;

ll fac[MAX],finv[MAX],inv[MAX];

void COMint(){

    fac[0]=fac[1]=1;

    finv[0]=finv[1]=1;

    inv[1]=1;

    for(int i=2;i<MAX;i++){

        fac[i]=fac[i-1]*i%MOD;

        inv[i]=MOD-inv[MOD%i]*(MOD/i)%MOD;

        finv[i]=finv[i-1]*inv[i]%MOD;

    }

}

ll COM(int n,int k){

    if(n<k) return 0;

    if(n<0||k<0)return 0;

    return fac[n]*(finv[k]*finv[n-k]%MOD)%MOD;

}

ll gcd(ll a,ll b){

    if(b==0)return a;

    if(a>b){

        swap(a,b);

    }

    return gcd(a,b%a);

}

ll lcm(ll a,ll b){

    ll g;g=gcd(a,b);

    return a*b/g;

}

bool compare_by_b(pair<int, int> a, pair<int, int> b) {

    if(a.second != b.second){

        return a.second < b.second;

    }else{

        return a.first < b.first;

    }

}



bool compare_by_a(pair<int, int> a, pair<int, int> b) {

    if(a.first != b.first){

        return a.first < b.first;

    }else{

        return a.second < b.second;

    }

}

template<class T> inline bool chmin(T& a, T b) {

    if (a > b) {

        a = b;

        return true;

    }

    return false;

}

template<class T> inline bool chmax(T& a, T b) {

    if (a < b) {

        a = b;

        return true;

    }

    return false;

}

int main() {

    ios::sync_with_stdio(false);

    cin.tie(0);

    int N=in();

    int h[N];

    REP(i,N){

        cin>>h[i];

    }

    int dp[N];

    REP(i,N){

        dp[i]=INF;

    }

    dp[0]=0;

    REP1(i,N-1){

        chmin(dp[i],dp[i-1]+abs(h[i]-h[i-1]));

        if(i>=2){

            chmin(dp[i],dp[i-2]+abs(h[i]-h[i-2]));

        }

   }

    cout<<dp[N-1]<<endl;

    return 0;

}

// Fastest known solution for this problem: