Problem:
Score : 700 points

Problem Statement

Takahashi and Aoki will play a game with a number line and some segments.
Takahashi is standing on the number line and he is initially at coordinate 0.
Aoki has N segments. The i-th segment is [L_i,R_i], that is, a segment consisting of points with coordinates between L_i and R_i (inclusive).

The game has N steps. The i-th step proceeds as follows:

First, Aoki chooses a segment that is still not chosen yet from the N segments and tells it to Takahashi.

Then, Takahashi walks along the number line to some point within the segment chosen by Aoki this time.

After N steps are performed, Takahashi will return to coordinate 0 and the game ends.

Let K be the total distance traveled by Takahashi throughout the game. Aoki will choose segments so that K will be as large as possible, and Takahashi walks along the line so that K will be as small as possible. What will be the value of K in the end?

Constraints

1 ≤ N ≤ 10^5

-10^5 ≤ L_i < R_i ≤ 10^5

L_i and R_i are integers.

Input

Input is given from Standard Input in the following format:

N
L_1 R_1
:
L_N R_N

Output

Print the total distance traveled by Takahashi throughout the game when Takahashi and Aoki acts as above.
It is guaranteed that K is always an integer when L_i,R_i are integers.

Sample Input 1

3
-5 1
3 7
-4 -2

Sample Output 1

10

One possible sequence of actions of Takahashi and Aoki is as follows:

Aoki chooses the first segment. Takahashi moves from coordinate 0 to -4, covering a distance of 4.

Aoki chooses the third segment. Takahashi stays at coordinate -4.

Aoki chooses the second segment. Takahashi moves from coordinate -4 to 3, covering a distance of 7.

Takahashi moves from coordinate 3 to 0, covering a distance of 3.

The distance covered by Takahashi here is 14 (because Takahashi didn't move optimally).
It turns out that if both players move optimally, the distance covered by Takahashi will be 10.

Sample Input 2

3
1 2
3 4
5 6

Sample Output 2

12

Sample Input 3

5
-2 0
-2 0
7 8
9 10
-2 -1

Sample Output 3

34

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Accepted)

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.TreeSet;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        C solver = new C();
        solver.solve(1, in, out);
        out.close();
    }

    static class C {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int n = in.readInt();
            C.Segment[] segments = new C.Segment[n];
            for (int i = 0; i < n; i++) {
                segments[i] = new C.Segment(in.readInt(), in.readInt(), i);
            }
            long maxAns = Long.MIN_VALUE;
            {
                TreeSet<C.Segment> right = new TreeSet<>((a, b) -> {
                    int r = -Integer.compare(a.L, b.L);
                    if (r != 0) return r;
                    return Integer.compare(a.i, b.i);
                });
                TreeSet<C.Segment> left = new TreeSet<>((a, b) -> {
                    int r = Integer.compare(a.R, b.R);
                    if (r != 0) return r;
                    return Integer.compare(a.i, b.i);
                });
                for (C.Segment s : segments) {
                    left.add(s);
                    right.add(s);
                }
                long ans = 0;
                int curPos = 0;
                TreeSet<C.Segment> currentSet = left; // differs here
                while (true) {
                    C.Segment s = currentSet.pollFirst();
                    if (s == null) break;
                    ans += s.distanceTo(curPos);
                    left.remove(s);
                    right.remove(s);
                    curPos = s.closestPointTo(curPos);
                    if (currentSet == left) currentSet = right;
                    else currentSet = left;
                }
                ans += Math.abs(curPos);
                maxAns = Math.max(maxAns, ans);
            }
            {
                TreeSet<C.Segment> right = new TreeSet<>((a, b) -> {
                    int r = -Integer.compare(a.L, b.L);
                    if (r != 0) return r;
                    return Integer.compare(a.i, b.i);
                });
                TreeSet<C.Segment> left = new TreeSet<>((a, b) -> {
                    int r = Integer.compare(a.R, b.R);
                    if (r != 0) return r;
                    return Integer.compare(a.i, b.i);
                });
                for (C.Segment s : segments) {
                    left.add(s);
                    right.add(s);
                }
                long ans = 0;
                int curPos = 0;
                TreeSet<C.Segment> currentSet = right; // differs here
                while (true) {
                    C.Segment s = currentSet.pollFirst();
                    if (s == null) break;
                    ans += s.distanceTo(curPos);
                    left.remove(s);
                    right.remove(s);
                    curPos = s.closestPointTo(curPos);
                    if (currentSet == left) currentSet = right;
                    else currentSet = left;
                }
                ans += Math.abs(curPos);
                maxAns = Math.max(maxAns, ans);
            }
            out.printLine(maxAns);
        }

        static class Segment {
            int L;
            int R;
            int i;

            public Segment(int l, int r, int i) {
                L = l;
                R = r;
                this.i = i;
            }

            public int distanceTo(int x) {
                if (L <= x && x <= R) {
                    return 0;
                }
                return Math.min(Math.abs(x - L), Math.abs(x - R));
            }

            public int closestPointTo(int x) {
                if (L <= x && x <= R) {
                    return x;
                }
                if (Math.abs(x - L) < Math.abs(x - R)) {
                    return L;
                } else {
                    return R;
                }
            }

        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int readInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void close() {
            writer.close();
        }

        public void printLine(long i) {
            writer.println(i);
        }

    }
}