// Original C++ solution (slower):
#include <bits/stdc++.h>

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

#define _rep(i,m,n) for(long long int i = m; i < n; i++)

#define print(n) std::cout << n << std::endl

#define _print(n) std::cout << n

using namespace std;

typedef long long ll;

const int N = 1000000;

const ll mod = 1000000007;

using Graph = vector<vector<int>>;

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

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



ll n; 

ll h[100010];

ll dp[100010];

int main(){

    cin >> n;

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

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

    dp[0] = 0;



    _rep(i,1,n){

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

        if(i > 1)dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));

    }

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

}

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

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

#define _rep(i, m, n) for(long long int i = m; i < n; i++)

using namespace std;

typedef long long ll;

typedef pair<int, int> P;

const ll mod = 1000000007;

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

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

     

ll gcd(ll A, ll B){

    if(B == 0)return A;

    return gcd(B, A % B);

}

ll lcm(ll A, ll B){

    return A * B / gcd(A, B);

}

template <typename T>

T pow(T a, ll n, T e = 1) {

    T ret = e;

    while (n) {

        if (n & 1) ret *= a;

        a *= a;

        n >>= 1;

    }

    return ret;

}

 

template <int mod>

struct ModInt {

    int x;

    ModInt() : x(0) {}

    ModInt(long long x_) {

        if ((x = x_ % mod + mod) >= mod) x -= mod;

    }

    ModInt& operator+=(ModInt rhs) {

        if ((x += rhs.x) >= mod) x -= mod;

        return *this;

    }

    ModInt& operator-=(ModInt rhs) {

        if ((x -= rhs.x) < 0) x += mod;

        return *this;

    }

    ModInt& operator*=(ModInt rhs) {

        x = (unsigned long long)x * rhs.x % mod;

        return *this;

    }

    ModInt& operator/=(ModInt rhs) {

        x = (unsigned long long)x * rhs.inv().x % mod;

        return *this;

    }

 

    ModInt operator-() const { return -x < 0 ? mod - x : -x; }

    ModInt operator+(ModInt rhs) const { return ModInt(*this) += rhs; }

    ModInt operator-(ModInt rhs) const { return ModInt(*this) -= rhs; }

    ModInt operator*(ModInt rhs) const { return ModInt(*this) *= rhs; }

    ModInt operator/(ModInt rhs) const { return ModInt(*this) /= rhs; }

    bool operator==(ModInt rhs) const { return x == rhs.x; }

    bool operator!=(ModInt rhs) const { return x != rhs.x; }

    ModInt inv() const { return pow(*this, mod - 2); }

 

    friend ostream& operator<<(ostream& s, ModInt<mod> a) {

        s << a.x;

        return s;

    }

    friend istream& operator>>(istream& s, ModInt<mod>& a) {

        s >> a.x;

        return s;

    }

};

 

using mint = ModInt<1000000007>;

using Graph = vector<vector<int>>;

Graph G;

/*------------------------------------------------------------------*/

int main(){

    ios::sync_with_stdio(false);

    cin.tie(nullptr);

    

    int n; cin >> n;

    vector<ll> h(n);

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



    ll INF = 1e15;

    vector<ll> dp(n);

    rep(i, n) dp[i] = INF;

    dp[0] = 0;

    rep(i, n)rep(j, 3){

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

    }

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

}

// Fastest known solution for this problem: