output_description: Print the minimum possible total cost incurred.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      h_1 h_2 \ldots h_N
attempt: # coding: utf-8
  import re
  import math
  import itertools
  from copy import deepcopy
  import fractions
  import random
  from functools import lru_cache
  from heapq import heappop, heappush
  import time
  import sys
  
  readline = sys.stdin.readline
  sys.setrecursionlimit(2000)
  # import numpy as np
  alphabet = "abcdefghijklmnopqrstuvwxyz"
  mod = int(10**9 + 7)
  inf = int(10**20)
  
  
  def yn(b):
      if b:
          print("yes")
      else:
          print("no")
  
  
  def Yn(b):
      if b:
          print("Yes")
      else:
          print("No")
  
  
  def YN(b):
      if b:
          print("YES")
      else:
          print("NO")
  
  
  class union_find:
      def __init__(self, n):
          self.n = n
          self.P = [a for a in range(N)]
          self.rank = [0] * n
  
      def find(self, x):
          if x != self.P[x]:
              self.P[x] = self.find(self.P[x])
          return self.P[x]
  
      def same(self, x, y):
          return self.find(x) == self.find(y)
  
      def link(self, x, y):
          if self.rank[x] < self.rank[y]:
              self.P[x] = y
          elif self.rank[y] < self.rank[x]:
              self.P[y] = x
          else:
              self.P[x] = y
              self.rank[y] += 1
  
      def unite(self, x, y):
          self.link(self.find(x), self.find(y))
  
      def size(self):
          S = set()
          for a in range(self.n):
              S.add(self.find(a))
          return len(S)
  
  
  def bin_(num, size):
      A = [0] * size
      for a in range(size):
          if (num >> (size - a - 1)) & 1 == 1:
              A[a] = 1
          else:
              A[a] = 0
      return A
  
  
  def fac_list(n, mod_=0):
      A = [1] * (n + 1)
      for a in range(2, len(A)):
          A[a] = A[a - 1] * a
          if mod > 0:
              A[a] %= mod_
      return A
  
  
  def comb(n, r, mod, fac):
      if n - r < 0:
          return 0
      return (fac[n] * pow(fac[n - r], mod - 2, mod) * pow(fac[r], mod - 2, mod)) % mod
  
  
  def next_comb(num, size):
      x = num & (-num)
      y = num + x
      z = num & (~y)
      z //= x
      z = z >> 1
      num = y | z
      if num >= (1 << size):
          return False
      else:
          return num
  
  
  def get_primes(n, type="int"):
      A = [True] * (n + 1)
      A[0] = False
      A[1] = False
      for a in range(2, n + 1):
          if A[a]:
              for b in range(a * 2, n + 1, a):
                  A[b] = False
      if type == "bool":
          return A
      B = []
      for a in range(n + 1):
          if A[a]:
              B.append(a)
      return B
  
  
  def is_prime(num):
      if num <= 2:
          return False
      i = 2
      while i * i <= num:
          if num % i == 0:
              return False
          i += 1
      return True
  
  
  def join(A, c=" "):
      n = len(A)
      A = list(map(str, A))
      s = ""
      for a in range(n):
          s += A[a]
          if a < n - 1:
              s += c
      return s
  
  
  # main
  
  n = int(input())
  H = list(map(int, input().split()))
  dp = [inf] * n
  for a in range(n):
      if a == 0:
          dp[a] = 0
      elif a == 1:
          dp[a] = abs(H[a] - H[a - 1])
      else:
          dp[a] = min(dp[a - 2] + abs(H[a] - H[a - 2]), dp[a - 2] + abs(H[a] - H[a - 1]))
      print(dp[a])
  print(dp[n - 1])
  
problem_description: Statement
  
  There are N stones, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N),
  the height of Stone i is h_i.
  
  There is a frog who is initially on Stone 1. He will repeat the following
  action some number of times to reach Stone N:
  
    * If the frog is currently on Stone i, jump to Stone i + 1 or Stone i + 2. Here, a cost of |h_i - h_j| is incurred, where j is the stone to land on.
  
  Find the minimum possible total cost incurred before the frog reaches Stone N.
samples: [{"input": "4\n    10 30 40 20", "output": "30\n    \n\nIf we follow the path 1 \u2192 2 \u2192 4, the total cost incurred would be |10 - 30| +\n|30 - 20| = 30.\n\n* * *"}, {"input": "2\n    10 10", "output": "0\n    \n\nIf we follow the path 1 \u2192 2, the total cost incurred would be |10 - 10| = 0.\n\n* * *"}, {"input": "6\n    30 10 60 10 60 50", "output": "40\n    \n\nIf we follow the path 1 \u2192 3 \u2192 5 \u2192 6, the total cost incurred would be |30 -\n60| + |60 - 60| + |60 - 50| = 40."}]