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

#include <vector>

#include <string>

#include <unordered_map>

#include <unordered_set>

#include <set>

#include <map>

#include <cmath>

#include <algorithm>

#include <stack>

#include <climits>

#include <queue>

using namespace std;

//

//int n, m;

//bool vaild(int i, int j)

//{

//    return i >= 0 && i <= n - 1 && j >= 0 && j <= m - 1;

//}

//

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

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

//

//

//long long maxSubArraySum(vector<long long >& a, long long start, long long  end)

//{

//    long long max_so_far = a[start];

//    long long curr_max = a[start];

//    for (int i = 0; i < end; i++)

//    {

//        curr_max += a[i];

//        if (curr_max < a[i])

//        {

//            curr_max = a[i];

//        }

//        max_so_far = max(max_so_far, curr_max);

//    }

//    return max_so_far;

//}

//

//

//long long gcd(long long a, long long b)

//{

//    if (b == 0)

//        return a;

//    return gcd(b, a % b);

//

//}

//

//

//long long lcm(long long a, long long b)

//{

//    return a * b / gcd(a, b);

//}

//

//

//

//int fastpow(int b, int p) {

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

//    int sq = pow(b, p / 2);

//    sq = sq * sq;

//

//    if (p % 2 == 1)

//        sq = sq * b;

//

//    return sq;

//}





//

//int grid[500][500];

//int n = 50;

//int targetx = 5;

//int targety = 5;

//

//int maxSum(int i, int j)

//{

//    if (i < 0 || i >= n || j < 0 || j >= n )

//    {

//        return 0;

//    }

//    if (i == targetx && j == targety)

//    {

//        return grid[i][j];

//    }

//    int sum1;

//    int sum2;

//    if (dp[i][j+1] != -1)

//    {

//        return dp[i][j + 1];

//    }

//    if (dp[i+1][j] != -1)

//    {

//        return dp[i+1][j ];

//    }

//    sum1 = maxSum(i, j + 1);

//    sum2 = maxSum(i, j + 1);

//    return dp[i][j] = grid[i][j] + max(sum1, sum2);

//}







//int dp[500][500];

//int RecuSum(int index, int curSum)

//{

//    if (dp[index][curSum] = -1)

//    {

//        return dp[index][curSum];

//    }

//    if (index == sum.size() )

//    {

//        return curSum % 7  == 0;

//    }

//    if (dp[index][curSum] = RecuSum(index + 1, curSum + sum[index]) || RecuSum(index + 1, curSum - sum[index]))

//    {

//        return dp[index][curSum];

//    }

//    return dp[index][curSum];

//}



// 0 0 -> 1 1

// 1 1 -> 2 6





//const int MAX = 21;

//const int N = 3;

//int minimumCost = INT_MAX;

//int r[MAX];

//int g[MAX];

//int b[MAX];

//int dp[MAX][MAX];



//

//int minCost (int lastColor , int i)

//{

//    

//    if (i == N)

//    {

//        return 0;

//    }

//    int& minimumCost = dp{i][lastColor];

//    if (minimumCost != -1)

//    {

//        return minimumCost;

//    }

//

//    minimumCost = INT_MAX;

//

//    if(minimumCost)

//    if (lastColor != 0)

//    {

//        minimumCost = min(r[i]+minCost(0, i + 1) , minimumCost);

//    }

//    if (lastColor != 1  )

//    {

//        minimumCost = min(g[i]+minCost(1, i + 1), minimumCost);

//

//    }

//    if (lastColor != 2)

//    {

//        minimumCost = min(b[i]+minCost(2, i + 1), minimumCost);

//

//    }

//    return minimumCost;

//

//}























//int dp[5][101];

//int minimumReset(int index, int parenttype)

//{

//    if (index == n)

//    {

//        return 0;

//    }

//

//    int &r = dp[parenttype][index];

//    if (r != -1)

//    {

//        return r;

//    }

//    r = 0;

//    

//

//    if (parenttype != 3 || elements[index] == 0)

//    {

//        r = max(minimumReset(index + 1, 3), r);

//

//    }

//

//

//    if ((elements[index] == 1 || elements[index] == 3) && parenttype != 1)

//        r = max(minimumReset(index + 1, 1)+1, r);

//

//    if ((elements[index] == 2 || elements[index] == 3 )&& parenttype != 2)

//        r = max(minimumReset(index + 1, 2)+1, r);

//

//    return r;

//

//}

//





int n;

int elements[100001];



long long dp[100001];



long long minCost(int index)

{

    if (index == n - 1)

    {

        return 0;

    }



    if (dp[index] != -1)

    {

        return dp[index];

    }

    long long r = LLONG_MAX;



    if (index + 1 < n)

    {

        r = min(minCost(index + 1) + abs(elements[index] - elements[index+1]), r);



    }

    if (index + 2 < n)

    {

        r = min( minCost(index + 2) + abs(elements[index] - elements[index + 2]), r);

    }

    dp[index]= r;



    return r;





}



int main()

{

    cin >> n;

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

    {

        int a;

        cin >> a;

        elements[i] = a;

    }

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

    {

          dp[i] = -1;

    }



    cout << minCost(0);

}






// Optimized solution to the same problem (faster):
#include <iostream>

#include <vector>

#include <string>

#include <queue>

#include <stack>

#include <map>

#include <set>

#include <unordered_map>

#include <unordered_set>

#include <cmath>

#include <algorithm>

#include <bitset>  

using namespace std;



//======================================================

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

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

#define forr1(i,n)  for (int i = n - 1 ;i <= 0; --i)

#define forr2(i,n)  for (int i = n  ;i < 0; --i)

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

#define allr(v)	   ((v).rbegin()), ((v).rend())

#define clr(v,d)   memset(v, d, sizeof(v))

#define ull        unsigned long long

#define MP(a,b)	   make_pair(a,b)

#define S          second

#define F          first

#define PI         3.14159265359

#define ll         long long

#define sz(v)	   v.size()

#define pb         push_back

#define pp         pop_back

#define bgn        begin

#define N          100000+5

#define	MOD        1e9+7

#define inf        1e18

//======================================================

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

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

//======================================================

ll gcd(ll a, ll b) { return !b ? a : gcd(b, a % b); }

ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }

ll power(ull a, ull b, ull ret = 1LL) {

	while (b--) ret = (ret * a);

	return ret;

}

//======================================================











int main()

{



	int n;

	cin >> n;

	vector<int> v(n + 1);

	for (size_t i = 1; i <= n; i++)

	{

		cin >> v[i];

	}

	vector<int> dp(n + 1);

	dp[1] = 0;

	dp[2] = abs(v[2] - v[1]);

	for (size_t i = 3; i <=n; i++)

	{

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

	}

	cout << dp[n];







}






// Fastest known solution for this problem: