import sys

input = sys.stdin.readline

from heapq import heappop, heappush



"""

f(x) = （一番上の長方形の左端がxに来るときのコストの最小値） を関数ごと更新していきたい

更新後をg(x)とする

g(x) = |x-L| + min_{-width_1 \leq t\leq width_2} f(x+t), 前回の幅、今回の幅

常に、区間上で最小値を持ち傾きが1ずつ変わる凸な関数であることが維持される。（区間は1点かも）

傾きが変わる点の集合S_f = S_f_lower + S_f_upperを持っていく。

S_f_lower, S_upperは一斉に定数を足す：変化量のみ持つ

"""



N = int(eval(input()))

LR = [[int(x) for x in input().split()] for _ in range(N)]



# initialize

L,R = LR[0]

S_lower = [-L]

S_upper = [L]

min_f = 0

add_lower = 0

add_upper = 0

prev_w = R - L



push_L = lambda x: heappush(S_lower, -x)

push_R = lambda x: heappush(S_upper, x)

pop_L = lambda: -heappop(S_lower)

pop_R = lambda: heappop(S_upper)



for L,R in LR[1:]:

    w = R - L

    # 平行移動とのminをとるステップ

    add_lower -= w

    add_upper += prev_w

    # abs(x-L) を加えるステップ

    # abs は瞬間に2傾きが変わるので

    x = pop_L() + add_lower

    y = pop_R() + add_upper

    a,b,c,d = sorted([x,y,L,L])

    push_L(a - add_lower)

    push_L(b - add_lower)

    push_R(c - add_upper)

    push_R(d - add_upper)

    min_f += c-b

    prev_w = w



print(min_f)



import sys

read = sys.stdin.buffer.read

readline = sys.stdin.buffer.readline

readlines = sys.stdin.buffer.readlines



from heapq import heappush, heappushpop



"""

・f(x) = （最上段の左端座標） -> 最小コスト

・g = newf とすると、g(x) = |x-l| + min_{x-w_{n-1}<=y<=x+w_n}f(y)

・常に [A0,B0] 上で定数、[A_i,A_{i-1}]で傾き-i、[B_{i-1},B_i]で傾きiの下に凸な折れ線

heapqで(A,B)の形で関数を持つ

・1段目の長方形で、A = [l], B = [l] からスタート（f(x) = |x - l|）

"""



N = int(readline())

m = list(map(int,read().split()))

L,R = list(zip(*list(zip(m,m))))



A = [-L[0]]; B = [L[0]]

addA = 0

addB = 0

min_f = 0

for n in range(1,N):

    p = R[n-1] - L[n-1]; q = R[n] - L[n]

    # まず、f(x) = min_{x-p <= y <= x+q} f(y) へと更新

    addA += (-q); addB += p

    a = -A[0] + addA

    b = B[0] + addB

    x = L[n]

    # x で座標を2回切り替えるようにする

    if x <= a:

        # 左に2つ入れたあと、右に1つうつす

        min_f += a - x

        heappush(A,-x + addA)

        y = -heappushpop(A,-x + addA) + addA

        heappush(B, y - addB)

    elif x >= b:

        # 右に2つ入れたあと、左に1つうつす

        min_f += x - b

        heappush(B, x - addB)

        y = heappushpop(B, x - addB) + addB

        heappush(A, -y + addA)

    else:

        # 左右に1つずつ入れる

        heappush(A, -x + addA)

        heappush(B, x - addB)



print(min_f)
import sys

input = sys.stdin.readline
from heapq import heappop, heappush

"""
f(x) = （一番上の長方形の左端がxに来るときのコストの最小値） を関数ごと更新していきたい
更新後をg(x)とする
g(x) = |x-L| + min_{-width_1 \leq t\leq width_2} f(x+t), 前回の幅、今回の幅
常に、区間上で最小値を持ち傾きが1ずつ変わる凸な関数であることが維持される。（区間は1点かも）
傾きが変わる点の集合S_f = S_f_lower + S_f_upperを持っていく。
S_f_lower, S_upperは一斉に定数を足す：変化量のみ持つ
"""
N = int(eval(input()))
LR = [[int(x) for x in input().split()] for _ in range(N)]
# initialize
L, R = LR[0]
S_lower = [-L]
S_upper = [L]
min_f = 0
add_lower = 0
add_upper = 0
prev_w = R - L
push_L = lambda x: heappush(S_lower, -x)
push_R = lambda x: heappush(S_upper, x)
pop_L = lambda: -heappop(S_lower)
pop_R = lambda: heappop(S_upper)
for L, R in LR[1:]:
    w = R - L
    # 平行移動とのminをとるステップ
    add_lower -= w
    add_upper += prev_w
    # abs(x-L) を加えるステップ
    # abs は瞬間に2傾きが変わるので
    x = pop_L() + add_lower
    y = pop_R() + add_upper
    a, b, c, d = sorted([x, y, L, L])
    push_L(a - add_lower)
    push_L(b - add_lower)
    push_R(c - add_upper)
    push_R(d - add_upper)
    min_f += c - b
    prev_w = w
print(min_f)

import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from heapq import heappush, heappushpop

"""
・f(x) = （最上段の左端座標） -> 最小コスト
・g = newf とすると、g(x) = |x-l| + min_{x-w_{n-1}<=y<=x+w_n}f(y)
・常に [A0,B0] 上で定数、[A_i,A_{i-1}]で傾き-i、[B_{i-1},B_i]で傾きiの下に凸な折れ線
heapqで(A,B)の形で関数を持つ
・1段目の長方形で、A = [l], B = [l] からスタート（f(x) = |x - l|）
"""
N = int(readline())
m = list(map(int, read().split()))
L, R = list(zip(*list(zip(m, m))))
A = [-L[0]]
B = [L[0]]
addA = 0
addB = 0
min_f = 0
for n in range(1, N):
    p = R[n - 1] - L[n - 1]
    q = R[n] - L[n]
    # まず、f(x) = min_{x-p <= y <= x+q} f(y) へと更新
    addA += -q
    addB += p
    a = -A[0] + addA
    b = B[0] + addB
    x = L[n]
    # x で座標を2回切り替えるようにする
    if x <= a:
        # 左に2つ入れたあと、右に1つうつす
        min_f += a - x
        heappush(A, -x + addA)
        y = -heappushpop(A, -x + addA) + addA
        heappush(B, y - addB)
    elif x >= b:
        # 右に2つ入れたあと、左に1つうつす
        min_f += x - b
        heappush(B, x - addB)
        y = heappushpop(B, x - addB) + addB
        heappush(A, -y + addA)
    else:
        # 左右に1つずつ入れる
        heappush(A, -x + addA)
        heappush(B, x - addB)
print(min_f)

-input = sys.stdin.readline -from heapq import heappop, heappush +read = sys.stdin.buffer.read +readline = sys.stdin.buffer.readline +readlines = sys.stdin.buffer.readlines +from heapq import heappush, heappushpop -f(x) = （一番上の長方形の左端がxに来るときのコストの最小値） を関数ごと更新していきたい -更新後をg(x)とする -g(x) = |x-L| + min_{-width_1 \leq t\leq width_2} f(x+t), 前回の幅、今回の幅 -常に、区間上で最小値を持ち傾きが1ずつ変わる凸な関数であることが維持される。（区間は1点かも） -傾きが変わる点の集合S_f = S_f_lower + S_f_upperを持っていく。 -S_f_lower, S_upperは一斉に定数を足す：変化量のみ持つ +・f(x) = （最上段の左端座標） -> 最小コスト +・g = newf とすると、g(x) = |x-l| + min_{x-w_{n-1}<=y<=x+w_n}f(y) +・常に [A0,B0] 上で定数、[A_i,A_{i-1}]で傾き-i、[B_{i-1},B_i]で傾きiの下に凸な折れ線 +heapqで(A,B)の形で関数を持つ +・1段目の長方形で、A = [l], B = [l] からスタート（f(x) = |x - l|） -N = int(eval(input())) -LR = [[int(x) for x in input().split()] for _ in range(N)] -# initialize -L, R = LR[0] -S_lower = [-L] -S_upper = [L] +N = int(readline()) +m = list(map(int, read().split())) +L, R = list(zip(*list(zip(m, m)))) +A = [-L[0]] +B = [L[0]] +addA = 0 +addB = 0 -add_lower = 0 -add_upper = 0 -prev_w = R - L -push_L = lambda x: heappush(S_lower, -x) -push_R = lambda x: heappush(S_upper, x) -pop_L = lambda: -heappop(S_lower) -pop_R = lambda: heappop(S_upper) -for L, R in LR[1:]: -    w = R - L -    # 平行移動とのminをとるステップ -    add_lower -= w -    add_upper += prev_w -    # abs(x-L) を加えるステップ -    # abs は瞬間に2傾きが変わるので -    x = pop_L() + add_lower -    y = pop_R() + add_upper -    a, b, c, d = sorted([x, y, L, L]) -    push_L(a - add_lower) -    push_L(b - add_lower) -    push_R(c - add_upper) -    push_R(d - add_upper) -    min_f += c - b -    prev_w = w +for n in range(1, N): +    p = R[n - 1] - L[n - 1] +    q = R[n] - L[n] +    # まず、f(x) = min_{x-p <= y <= x+q} f(y) へと更新 +    addA += -q +    addB += p +    a = -A[0] + addA +    b = B[0] + addB +    x = L[n] +    # x で座標を2回切り替えるようにする +    if x <= a: +        # 左に2つ入れたあと、右に1つうつす +        min_f += a - x +        heappush(A, -x + addA) +        y = -heappushpop(A, -x + addA) + addA +        heappush(B, y - addB) +    elif x >= b: +        # 右に2つ入れたあと、左に1つうつす +        min_f += x - b +        heappush(B, x - addB) +        y = heappushpop(B, x - addB) + addB +        heappush(A, -y + addA) +    else: +        # 左右に1つずつ入れる +        heappush(A, -x + addA) +        heappush(B, x - addB)