n = int(eval(input()))

h = list(map(int, input().split()))



dp = [0]*n

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



for i in range(2, n):

    # +1

    temp1 = abs(h[i]-h[i-1])+dp[i-1]

    # +2

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



    dp[i] = min(temp1, temp2)



print((dp[n-1]))
INF = float("inf")



import sys

sys.setrecursionlimit(10**9)

input = sys.stdin.readline

input_int = lambda:int(eval(input()))

input_ints = lambda:list(map(int,input().split()))

input_ints_list = lambda:list(input_ints())

input_str = lambda:eval(input())

input_strs = lambda:input().split()

input_lines = lambda n,input_func:[input_func() for _ in range(n)]



import importlib

import_module = lambda module_name:importlib.import_module(module_name)



init_array_1dim = lambda value,n:[value]*n # 1次元配列を生成

init_array_2dim = lambda value,n,m:[init_array_1dim(value,n) for _ in range(m)] # 2次元配列を生成



gcd_base = lambda value1,value2:import_module('fractions').gcd(value1,value2) # 最大公約数（2値)

gcd = lambda lst:import_module('functools').reduce(gcd_base,lst) # 最大公約数（リスト）

lcm_base = lambda value1,value2:(value1*value2)//gcd_base(value1,value2) # 最小公倍数(2値)

lcm = lambda lst:import_module('functools').reduce(lcm_base,lst,1) # 最小公倍数(リスト)



permutations = lambda lst,n:import_module('itertools').permutations(lst,n) # 順列

combinations = lambda lst,n:import_module('itertools').combinations(lst,n) # 組み合わせ

product = lambda lst1,lst2:import_module('itertools').product(lst1,lst2) # 二つのリストの直積



round = lambda value:round(value) # 四捨五入

ceil = lambda value:import_module('math').ceil(value) # 切り上げ

floor = lambda value:import_module('math').floor(value) # 切り捨て



# キュー

init_q = lambda lst: import_module('collections').deque(lst)

q_pop = lambda q: q.popleft() # 先頭から取り出し

q_push = lambda q,value:q.appendleft(value) # 先頭に追加（値）

q_pushlist = lambda q,lst:q.extendleft(lst) # 先頭に追加（リスト）

q_append = lambda q,value:q.append(value) # 末尾に追加（値）

q_appendlist = lambda q,lst:q.extend(lst) # 末尾に追加（リスト）



# プライオリティキュー

init_heap = lambda a:import_module('heapq').heapify(a)

heap_push = lambda a,v:import_module('heapq').heappush(a,v)

heap_pop = lambda a:import_module('heapq').heappop(a) # 最小値を取り出す



def solution():

    # ここに実装

    N = input_int()

    h = input_ints_list()



    dp = init_array_1dim(0,N)

    for i in range(N):

        if i == 0:continue

        elif i == 1:dp[1] = abs(h[1]-h[0])

        else:

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

    print((dp[N-1]))

    

if __name__ == '__main__':

    solution()
n = int(eval(input()))
h = list(map(int, input().split()))
dp = [0] * n
dp[1] = abs(h[1] - h[0])
for i in range(2, n):
    # +1
    temp1 = abs(h[i] - h[i - 1]) + dp[i - 1]
    # +2
    temp2 = abs(h[i] - h[i - 2]) + dp[i - 2]
    dp[i] = min(temp1, temp2)
print((dp[n - 1]))

INF = float("inf")
import sys

sys.setrecursionlimit(10**9)
input = sys.stdin.readline
input_int = lambda: int(eval(input()))
input_ints = lambda: list(map(int, input().split()))
input_ints_list = lambda: list(input_ints())
input_str = lambda: eval(input())
input_strs = lambda: input().split()
input_lines = lambda n, input_func: [input_func() for _ in range(n)]
import importlib

import_module = lambda module_name: importlib.import_module(module_name)
init_array_1dim = lambda value, n: [value] * n  # 1次元配列を生成
init_array_2dim = lambda value, n, m: [
    init_array_1dim(value, n) for _ in range(m)
]  # 2次元配列を生成
gcd_base = lambda value1, value2: import_module("fractions").gcd(
    value1, value2
)  # 最大公約数（2値)
gcd = lambda lst: import_module("functools").reduce(gcd_base, lst)  # 最大公約数（リスト）
lcm_base = lambda value1, value2: (value1 * value2) // gcd_base(
    value1, value2
)  # 最小公倍数(2値)
lcm = lambda lst: import_module("functools").reduce(lcm_base, lst, 1)  # 最小公倍数(リスト)
permutations = lambda lst, n: import_module("itertools").permutations(lst, n)  # 順列
combinations = lambda lst, n: import_module("itertools").combinations(lst, n)  # 組み合わせ
product = lambda lst1, lst2: import_module("itertools").product(lst1, lst2)  # 二つのリストの直積
round = lambda value: round(value)  # 四捨五入
ceil = lambda value: import_module("math").ceil(value)  # 切り上げ
floor = lambda value: import_module("math").floor(value)  # 切り捨て
# キュー
init_q = lambda lst: import_module("collections").deque(lst)
q_pop = lambda q: q.popleft()  # 先頭から取り出し
q_push = lambda q, value: q.appendleft(value)  # 先頭に追加（値）
q_pushlist = lambda q, lst: q.extendleft(lst)  # 先頭に追加（リスト）
q_append = lambda q, value: q.append(value)  # 末尾に追加（値）
q_appendlist = lambda q, lst: q.extend(lst)  # 末尾に追加（リスト）
# プライオリティキュー
init_heap = lambda a: import_module("heapq").heapify(a)
heap_push = lambda a, v: import_module("heapq").heappush(a, v)
heap_pop = lambda a: import_module("heapq").heappop(a)  # 最小値を取り出す


def solution():
    # ここに実装
    N = input_int()
    h = input_ints_list()
    dp = init_array_1dim(0, N)
    for i in range(N):
        if i == 0:
            continue
        elif i == 1:
            dp[1] = abs(h[1] - h[0])
        else:
            dp[i] = min(
                dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2])
            )
    print((dp[N - 1]))


if __name__ == "__main__":
    solution()

-n = int(eval(input())) -h = list(map(int, input().split())) -dp = [0] * n -dp[1] = abs(h[1] - h[0]) -for i in range(2, n): -    # +1 -    temp1 = abs(h[i] - h[i - 1]) + dp[i - 1] -    # +2 -    temp2 = abs(h[i] - h[i - 2]) + dp[i - 2] -    dp[i] = min(temp1, temp2) -print((dp[n - 1])) +INF = float("inf") +import sys + +sys.setrecursionlimit(10**9) +input = sys.stdin.readline +input_int = lambda: int(eval(input())) +input_ints = lambda: list(map(int, input().split())) +input_ints_list = lambda: list(input_ints()) +input_str = lambda: eval(input()) +input_strs = lambda: input().split() +input_lines = lambda n, input_func: [input_func() for _ in range(n)] +import importlib + +import_module = lambda module_name: importlib.import_module(module_name) +init_array_1dim = lambda value, n: [value] * n  # 1次元配列を生成 +init_array_2dim = lambda value, n, m: [ +    init_array_1dim(value, n) for _ in range(m) +]  # 2次元配列を生成 +gcd_base = lambda value1, value2: import_module("fractions").gcd( +    value1, value2 +)  # 最大公約数（2値) +gcd = lambda lst: import_module("functools").reduce(gcd_base, lst)  # 最大公約数（リスト） +lcm_base = lambda value1, value2: (value1 * value2) // gcd_base( +    value1, value2 +)  # 最小公倍数(2値) +lcm = lambda lst: import_module("functools").reduce(lcm_base, lst, 1)  # 最小公倍数(リスト) +permutations = lambda lst, n: import_module("itertools").permutations(lst, n)  # 順列 +combinations = lambda lst, n: import_module("itertools").combinations(lst, n)  # 組み合わせ +product = lambda lst1, lst2: import_module("itertools").product(lst1, lst2)  # 二つのリストの直積 +round = lambda value: round(value)  # 四捨五入 +ceil = lambda value: import_module("math").ceil(value)  # 切り上げ +floor = lambda value: import_module("math").floor(value)  # 切り捨て +# キュー +init_q = lambda lst: import_module("collections").deque(lst) +q_pop = lambda q: q.popleft()  # 先頭から取り出し +q_push = lambda q, value: q.appendleft(value)  # 先頭に追加（値） +q_pushlist = lambda q, lst: q.extendleft(lst)  # 先頭に追加（リスト） +q_append = lambda q, value: q.append(value)  # 末尾に追加（値） +q_appendlist = lambda q, lst: q.extend(lst)  # 末尾に追加（リスト） +# プライオリティキュー +init_heap = lambda a: import_module("heapq").heapify(a) +heap_push = lambda a, v: import_module("heapq").heappush(a, v) +heap_pop = lambda a: import_module("heapq").heappop(a)  # 最小値を取り出す + + +def solution(): +    # ここに実装 +    N = input_int() +    h = input_ints_list() +    dp = init_array_1dim(0, N) +    for i in range(N): +        if i == 0: +            continue +        elif i == 1: +            dp[1] = abs(h[1] - h[0]) +        else: +            dp[i] = min( +                dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]) +            ) +    print((dp[N - 1])) + + +if __name__ == "__main__": +    solution()