

"""



貪欲か？

今いる地点から左のRと右のLの数を比較

多い方の最遠点に行く→そのような点が無くなったら終了



証明は…

まず右のR,左のLは無意味→区間を無駄にするだけ

少ない方に行く→多い方の区間が無駄になる

近い点に行く→　ここがむずい

遠い区間が無駄になるのを防ぐため？



実装は？

多い方の処理→BITで左にあるRの数と右にあるLの数をlogNで

優先度付きキューで最小のRと最大のLを検出

10^5+1 を足して1 ～ 2*10^5 + 1の区間として扱う

初期・終了地点は　10^5+1



"""

import heapq



def bitadd(a,w,bit): #aにwを加える(1-origin)

 

    x = a

    while x <= (len(bit)-1):

        bit[x] += w

        x += x & (-1 * x)

 

def bitsum(a,bit): #ind 1～aまでの和を求める

 

    ret = 0

    x = a

    while x > 0:

        ret += bit[x]

        x -= x & (-1 * x)

    return ret



N = int(eval(input()))



used = [False] * N

lq = []

rq = []

LR = []



LBIT = [0] * (2 * (10**5) + 10)

RBIT = [0] * (2 * (10**5) + 10)



for i in range(N):



    L,R = list(map(int,input().split()))



    L += 10**5+1

    R += 10**5+1



    LR.append([L,R])

    

    heapq.heappush(lq,[-1 * L,i])

    heapq.heappush(rq,[R,i])



    bitadd(L,1,LBIT)

    bitadd(R,1,RBIT)





ans = 0

now = 10**5+1



for i in range(N):



    R_in_left  = bitsum(now-1,RBIT)

    L_in_right = N - i - bitsum(now,LBIT)

    



    if R_in_left >= L_in_right: #左にあるRに移動



        while len(rq) > 0 and used[ rq[0][1] ]:

            heapq.heappop(rq)



        if len(rq) == 0:

            break



        nexp,nexind = heapq.heappop(rq)

        pair = LR[nexind][0]



        bitadd(nexp,-1,RBIT)

        bitadd(pair,-1,LBIT)

        used[nexind] = True



        if nexp >= now:

            break



        ans += now - nexp

        now = nexp



    else:



        while len(lq) > 0 and used[ lq[0][1] ]:

            heapq.heappop(lq)



        if len(lq) == 0:

            break



        nexp,nexind = heapq.heappop(lq)

        nexp *= -1

        pair = LR[nexind][1]



        bitadd(nexp,-1,LBIT)

        bitadd(pair,-1,RBIT)

        used[nexind] = True



        if nexp <= now:

            break



        ans += nexp - now

        now = nexp



ans += abs(10**5+1 - now)



print (ans)



        





N = int(eval(input()))



L = []

R = []



for i in range(N):

    l,r = list(map(int,input().split()))

    L.append(2 * l)

    R.append(-2 * r)



L.sort()

R.sort()

L.reverse()

R.reverse()



ans = 0



now = 0

for i in range(N):

    now += L[i]

    ans = max(ans,now)

    now += R[i]

    ans = max(ans,now)



now = 0

for i in range(N):

    now += R[i]

    ans = max(ans,now)

    now += L[i]

    ans = max(ans,now)



print (ans)

"""
貪欲か？
今いる地点から左のRと右のLの数を比較
多い方の最遠点に行く→そのような点が無くなったら終了
証明は…
まず右のR,左のLは無意味→区間を無駄にするだけ
少ない方に行く→多い方の区間が無駄になる
近い点に行く→　ここがむずい
遠い区間が無駄になるのを防ぐため？
実装は？
多い方の処理→BITで左にあるRの数と右にあるLの数をlogNで
優先度付きキューで最小のRと最大のLを検出
10^5+1 を足して1 ～ 2*10^5 + 1の区間として扱う
初期・終了地点は　10^5+1
"""
import heapq


def bitadd(a, w, bit):  # aにwを加える(1-origin)
    x = a
    while x <= (len(bit) - 1):
        bit[x] += w
        x += x & (-1 * x)


def bitsum(a, bit):  # ind 1～aまでの和を求める
    ret = 0
    x = a
    while x > 0:
        ret += bit[x]
        x -= x & (-1 * x)
    return ret


N = int(eval(input()))
used = [False] * N
lq = []
rq = []
LR = []
LBIT = [0] * (2 * (10**5) + 10)
RBIT = [0] * (2 * (10**5) + 10)
for i in range(N):
    L, R = list(map(int, input().split()))
    L += 10**5 + 1
    R += 10**5 + 1
    LR.append([L, R])
    heapq.heappush(lq, [-1 * L, i])
    heapq.heappush(rq, [R, i])
    bitadd(L, 1, LBIT)
    bitadd(R, 1, RBIT)
ans = 0
now = 10**5 + 1
for i in range(N):
    R_in_left = bitsum(now - 1, RBIT)
    L_in_right = N - i - bitsum(now, LBIT)
    if R_in_left >= L_in_right:  # 左にあるRに移動
        while len(rq) > 0 and used[rq[0][1]]:
            heapq.heappop(rq)
        if len(rq) == 0:
            break
        nexp, nexind = heapq.heappop(rq)
        pair = LR[nexind][0]
        bitadd(nexp, -1, RBIT)
        bitadd(pair, -1, LBIT)
        used[nexind] = True
        if nexp >= now:
            break
        ans += now - nexp
        now = nexp
    else:
        while len(lq) > 0 and used[lq[0][1]]:
            heapq.heappop(lq)
        if len(lq) == 0:
            break
        nexp, nexind = heapq.heappop(lq)
        nexp *= -1
        pair = LR[nexind][1]
        bitadd(nexp, -1, LBIT)
        bitadd(pair, -1, RBIT)
        used[nexind] = True
        if nexp <= now:
            break
        ans += nexp - now
        now = nexp
ans += abs(10**5 + 1 - now)
print(ans)

N = int(eval(input()))
L = []
R = []
for i in range(N):
    l, r = list(map(int, input().split()))
    L.append(2 * l)
    R.append(-2 * r)
L.sort()
R.sort()
L.reverse()
R.reverse()
ans = 0
now = 0
for i in range(N):
    now += L[i]
    ans = max(ans, now)
    now += R[i]
    ans = max(ans, now)
now = 0
for i in range(N):
    now += R[i]
    ans = max(ans, now)
    now += L[i]
    ans = max(ans, now)
print(ans)

-""" -貪欲か？ -今いる地点から左のRと右のLの数を比較 -多い方の最遠点に行く→そのような点が無くなったら終了 -証明は… -まず右のR,左のLは無意味→区間を無駄にするだけ -少ない方に行く→多い方の区間が無駄になる -近い点に行く→　ここがむずい -遠い区間が無駄になるのを防ぐため？ -実装は？ -多い方の処理→BITで左にあるRの数と右にあるLの数をlogNで -優先度付きキューで最小のRと最大のLを検出 -10^5+1 を足して1 ～ 2*10^5 + 1の区間として扱う -初期・終了地点は　10^5+1 -""" -import heapq - - -def bitadd(a, w, bit):  # aにwを加える(1-origin) -    x = a -    while x <= (len(bit) - 1): -        bit[x] += w -        x += x & (-1 * x) - - -def bitsum(a, bit):  # ind 1～aまでの和を求める -    ret = 0 -    x = a -    while x > 0: -        ret += bit[x] -        x -= x & (-1 * x) -    return ret - - -used = [False] * N -lq = [] -rq = [] -LR = [] -LBIT = [0] * (2 * (10**5) + 10) -RBIT = [0] * (2 * (10**5) + 10) +L = [] +R = [] -    L, R = list(map(int, input().split())) -    L += 10**5 + 1 -    R += 10**5 + 1 -    LR.append([L, R]) -    heapq.heappush(lq, [-1 * L, i]) -    heapq.heappush(rq, [R, i]) -    bitadd(L, 1, LBIT) -    bitadd(R, 1, RBIT) +    l, r = list(map(int, input().split())) +    L.append(2 * l) +    R.append(-2 * r) +L.sort() +R.sort() +L.reverse() +R.reverse() -now = 10**5 + 1 +now = 0 -    R_in_left = bitsum(now - 1, RBIT) -    L_in_right = N - i - bitsum(now, LBIT) -    if R_in_left >= L_in_right:  # 左にあるRに移動 -        while len(rq) > 0 and used[rq[0][1]]: -            heapq.heappop(rq) -        if len(rq) == 0: -            break -        nexp, nexind = heapq.heappop(rq) -        pair = LR[nexind][0] -        bitadd(nexp, -1, RBIT) -        bitadd(pair, -1, LBIT) -        used[nexind] = True -        if nexp >= now: -            break -        ans += now - nexp -        now = nexp -    else: -        while len(lq) > 0 and used[lq[0][1]]: -            heapq.heappop(lq) -        if len(lq) == 0: -            break -        nexp, nexind = heapq.heappop(lq) -        nexp *= -1 -        pair = LR[nexind][1] -        bitadd(nexp, -1, LBIT) -        bitadd(pair, -1, RBIT) -        used[nexind] = True -        if nexp <= now: -            break -        ans += nexp - now -        now = nexp -ans += abs(10**5 + 1 - now) +    now += L[i] +    ans = max(ans, now) +    now += R[i] +    ans = max(ans, now) +now = 0 +for i in range(N): +    now += R[i] +    ans = max(ans, now) +    now += L[i] +    ans = max(ans, now)