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

using namespace std;

typedef long long ll;

#define rep(i, n) for(int i = 0; (i) < (n); i++)

ll INF18 = 1e18;



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;

}



ll h[100010];

ll dp[100010]; 



int main(){



    int n; cin >> n;

    rep(i, n) cin >> h[i];



    rep(i, 100010) dp[i] = INF18;

    dp[0] = 0;



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

        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];

return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.6154162473424607x):
#pragma GCC optimize("O3")



#define _GLIBCXX_DEBUG

#include <iostream>

#include <vector>

#include <string>

#include <string_view>

#include <algorithm>

#include <cmath>

#include <iomanip>

#include <cassert>

#include <list>

#include <map>

#include <set>

#include <queue>

#include <deque>

#include <stack>

using namespace std;



/*----------macros----------*/



//output================

#define endl '\n'

#define fcout(a) cout << fixed << setprecision((int)(a))



//typedef===============

typedef long long       ll;

typedef long double     ld;

typedef pair<int, int>  Pii;

typedef pair<ll, ll>    Pll;



//const number==========

constexpr ll INF9   = (ll)1e9 + 1;

constexpr ll INF18  = (ll)1e18 + 1;

constexpr ll MOD    = 1'000'000'007;

constexpr ll MOD2   = 998'244'353;

constexpr ld PI     = 3.141592653589793L;



//member================

#define pb push_back

#define eb emplace_back

#define pf push_front

#define mp make_pair

#define fi first

#define se second



//others================

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

#define rall(x)         (x).rbegin(), (x).rend()

#define rep(i, n)       for(int i = 0; (i) < (n); ++(i))

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

#define rrep(i, n)      for(int i = n - 1; (i) >= 0 ; --(i))

#define CtoI(c)         int((c)) - int('0')

#define ItoC(c)         char((c) + '0')



//functions=============

template<typename T1, typename T2>

inline bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }



template<typename T1, typename T2>

inline bool chmin(T1 &a, T2 b) { return a > b && (a = b, true); }



//vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};

//vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };



/*--------additional--------*/







/*----------main------------*/



int main() {

/*----------fastio----------*/

    std::cin.tie(nullptr);

    std::cout.tie(nullptr);

    std::ios::sync_with_stdio(false);

/*----------solve-----------*/



    int n; cin >> n;

    vector<int> h(n);

    rep(i, n) cin >> h[i];

    int dp[1000000];



    dp[1] = abs(h[1] - h[0]);

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

        dp[i] = min(dp[i - 2] + abs(h[i] - h[i - 2]),

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

    }



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



return 0;

}