// Original C++ solution (slower):
/*

 * atcoder/dp/a.cpp

 */



// C++ 14

#include <iostream>

#include <string>

#include <vector>

#include <list>

#include <algorithm>

#include <queue>

#include <stack>

#include <set>

#include <map>

#include <unordered_map>

#include <math.h>

#include <cstring>



#define ll long long

#define Int ll

#define loop(__x, __start, __end) for(Int __x = __start; __x < __end; __x++)

#define loopdown(__x, __start, __end) for(Int __x = __start; __x > __end; __x--)

#define rep(__n) for(Int __x = 0; __x < __n; __x++)

#define span(__a,__x,__y) __a.begin()+__x,__a.begin()+__y

#define span_all(__a) __a.begin(),__a.end()

#define len(__x) (__x.size())

#define last(__x) (__x[__x.size()-1])



using namespace std;



template <class T> bool chmin(T &a, T b) { if (a > b) {a = b; return true; } return false; }

template <class T> bool chmax(T &a, T b) { if (a < b) {a = b; return true; } return false; }



struct Point {

  Int x, y;

  Point(Int x, Int y): x(x), y(y) {}

  Point(): x(0), y(0) {}



  Point operator + (Point v) { return Point(x + v.x, y + v.y); }

  Point operator - (Point v) { return Point(x - v.x, y - v.y); }

  bool operator == (const Point &v) const {

    return x == v.x && y == v.y;

  }

  bool operator< (const Point &p1) const {

    return x < p1.x && y < p1.y;

  }

};

ostream & operator << (ostream & out, Point const & v) {

  out << "Point(" << v.x << ", " << v.y << ')';

  return out;

}



istream & operator >> (istream & in, Point & v) {

  Int x, y;

  in >> x; in >> y; v.x = x; v.y = y;

  return in;

}



// Geometry



#define EPS 0.0000000001



class Vector2 {

public:

  double x, y;

  

  Vector2(double x = 0, double y = 0): x(x), y(y) {}

  

  Vector2 operator + (Vector2 v) { return Vector2(x + v.x, y + v.y); }

  Vector2 operator - (Vector2 v) { return Vector2(x - v.x, y - v.y); }

  Vector2 operator * (double k) { return Vector2(x * k, y * k); }

  Vector2 operator / (double k) { return Vector2(x / k, y / k); }

  

  double length() { return sqrt(norm()); }

  double norm() { return x * x + y * y; }

  double dot (Vector2 v) { return x * v.x + y * v.y; }

  double cross (Vector2 v) { return x * v.y - y * v.x; }

  

  bool operator < (const Vector2 &v) const {

    return x != v.x ? x < v.x : y < v.y;

  }

  

  bool operator == (const Vector2 &v) const {

    return fabs(x - v.x) < EPS && fabs(y - v.y) < EPS;

  }

};



ostream & operator << (ostream & out, Vector2 const & v) { 

  out<< "Vector2(" << v.x << ", " << v.y << ')';

  return out;

}



istream & operator >> (istream & in, Vector2 & v) { 

  double x, y;

  in >> x;

  in >> y;

  v.x = x;

  v.y = y;

  return in;

}





vector<Int> slice(vector<Int> &vec, int s, int t) {

  return vector<Int>(vec.begin()+s, vec.begin()+t);

}



vector<Int> trim(vector<Int> &vec, int n) {

  auto init = slice(vec, 0, n);

  auto tail = slice(vec, n+2, vec.size());

  init.insert(init.end(), tail.begin(), tail.end());

  return init;

}





const Int MAX_N = 100010;

const Int INFTY = 100000000000000000;

Int N;

vector<Int> A;



void input() {

  cin >> N;

  Int a;

  loop(n,0,N) {

    cin >> a;

    A.push_back(a);

  }



  // +1, +2で範囲外アクセスしないようにダミーの値

  A.push_back(0);

  A.push_back(0);

}



vector<Int> dp(MAX_N, INFTY);



void give() {

  dp.at(0) = 0;

  loop(n,0,N) {

    chmin(

      dp.at(n+1),

      dp.at(n) + abs(A.at(n+1)-A.at(n))

    );

    chmin(

      dp.at(n+2),

      dp.at(n) + abs(A.at(n+2)-A.at(n))

    );

  }

}



void receive() {

  dp.at(0) = 0;

  dp.at(1) = abs(A.at(1) - A.at(0));

  loop(n,2,N+1) {

    chmin(

      dp.at(n),

      dp.at(n-1) + abs(A.at(n)-A.at(n-1))

    );

    chmin(

      dp.at(n),

      dp.at(n-2) + abs(A.at(n)-A.at(n-2))

    );

  }

}



void solve() {

  receive();

  cout << dp.at(N-1) << endl;

}



int main() {

  input();

  solve();

  return 0;

}


// Optimized solution to the same problem (faster):
/*

 * atcoder/dp_2nd/a.cpp

 */



// C++ 14

#include <iostream>

#include <string>

#include <vector>

#include <list>

#include <algorithm>

#include <queue>

#include <stack>

#include <set>

#include <map>

#include <unordered_map>

#include <math.h>

#include <cstring>



#define ll long long

#define Int ll

#define loop(__x, __start, __end) for(Int __x = __start; __x < __end; __x++)

#define loopdown(__x, __start, __end) for(Int __x = __start; __x > __end; __x--)

#define rep(__n) for(Int __x = 0; __x < __n; __x++)

#define span(__a,__x,__y) __a.begin()+__x,__a.begin()+__y

#define span_all(__a) __a.begin(),__a.end()

#define len(__x) (__x.size())

#define last(__x) (__x[__x.size()-1])



using namespace std;



template <class T> bool chmin(T &a, T b) { if (a > b) {a = b; return true; } return false; }

template <class T> bool chmax(T &a, T b) { if (a < b) {a = b; return true; } return false; }



const Int INFTY = 100000000000000000;

const Int MAX_N = 100100;

Int N;

vector<Int> A;

Int dp[MAX_N];



void input() {

  cin >> N;

  Int a;

  loop(n,0,N) {

    cin >> a;

    A.push_back(a);

  }

}



void solve() {

  loop(i,0,N+1) dp[i] = INFTY;

  dp[0] = 0;

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

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

    if (i+2 < N) chmin(dp[i+2], dp[i] + abs(A[i+2] - A[i]));

  }

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

}



int main() {

  // cout.precision(15);

  input();

  solve();

  return 0;

}


// Fastest known solution for this problem: