Problem:
Score : 600 points

Problem Statement

10^9 contestants, numbered 1 to 10^9, will compete in a competition.
There will be two contests in this competition.

The organizer prepared N problems, numbered 1 to N, to use in these contests.
When Problem i is presented in a contest, it will be solved by all contestants from Contestant L_i to Contestant R_i (inclusive), and will not be solved by any other contestants.

The organizer will use these N problems in the two contests.
Each problem must be used in exactly one of the contests, and each contest must have at least one problem.

The joyfulness of each contest is the number of contestants who will solve all the problems in the contest.
Find the maximum possible total joyfulness of the two contests.

Constraints

2 \leq N \leq 10^5

1 \leq L_i \leq R_i \leq 10^9

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
L_1 R_1
L_2 R_2
\vdots
L_N R_N

Output

Print the maximum possible total joyfulness of the two contests.

Sample Input 1

4
4 7
1 4
5 8
2 5

Sample Output 1

6

The optimal choice is:

Use Problem 1 and 3 in the first contest. Contestant 5, 6, and 7 will solve both of them, so the joyfulness of this contest is 3.

Use Problem 2 and 4 in the second contest. Contestant 2, 3, and 4 will solve both of them, so the joyfulness of this contest is 3.

The total joyfulness of these two contests is 6. We cannot make the total joyfulness greater than 6.

Sample Input 2

4
1 20
2 19
3 18
4 17

Sample Output 2

34

Sample Input 3

10
457835016 996058008
456475528 529149798
455108441 512701454
455817105 523506955
457368248 814532746
455073228 459494089
456651538 774276744
457667152 974637457
457293701 800549465
456580262 636471526

Sample Output 3

540049931

Solution in Common Lisp (SBCL 1.1.14) (judge verdict: Time Limit Exceeded)

;; -*- coding: utf-8 -*-
(eval-when (:compile-toplevel :load-toplevel :execute)
  (sb-int:defconstant-eqx OPT
    #+swank '(optimize (speed 3) (safety 2))
    #-swank '(optimize (speed 3) (safety 0) (debug 0))
    #'equal)
  #+swank (ql:quickload '(:cl-debug-print :fiveam) :silent t)
  #-swank (set-dispatch-macro-character
           #\# #\> (lambda (s c p) (declare (ignore c p)) (read s nil nil t))))
#+swank (cl-syntax:use-syntax cl-debug-print:debug-print-syntax)
#-swank (disable-debugger) ; for CS Academy

;; BEGIN_INSERTED_CONTENTS
(defmacro define-int-types (&rest bits)
  `(progn
     ,@(mapcar (lambda (b) `(deftype ,(intern (format nil "UINT~A" b)) () '(unsigned-byte ,b))) bits)
     ,@(mapcar (lambda (b) `(deftype ,(intern (format nil "INT~A" b)) () '(signed-byte ,b))) bits)))
(define-int-types 2 4 7 8 15 16 31 32 62 63 64)

(defun delete-adjacent-duplicates (seq &key (test #'eql))
  "Destructively deletes adjacent duplicates of SEQ: e.g. #(1 1 1 2 2 1 3) ->
#(1 2 1 3)"
  (declare #.OPT
           ((simple-array uint31 (*)) seq)
           (function test))
  (if (zerop (length seq))
         seq
         (let ((prev (aref seq 0))
               (end 1))
           (loop for pos from 1 below (length seq)
                 unless (funcall test prev (aref seq pos))
                 do (setf prev (aref seq pos)
                          (aref seq end) (aref seq pos)
                          end (+ 1 end)))
           ;; KLUDGE: Resorting to ADJUST-ARRAY is maybe substandard. 
           (adjust-array seq end))))

(declaim (ftype (function * (values fixnum &optional)) read-fixnum))
(defun read-fixnum (&optional (in *standard-input*))
  (declare #.OPT)
  (macrolet ((%read-byte ()
               `(the (unsigned-byte 8)
                     #+swank (char-code (read-char in nil #\Nul))
                     #-swank (sb-impl::ansi-stream-read-byte in nil #.(char-code #\Nul) nil))))
    (let* ((minus nil)
           (result (loop (let ((byte (%read-byte)))
                           (cond ((<= 48 byte 57)
                                  (return (- byte 48)))
                                 ((zerop byte) ; #\Nul
                                  (error "Read EOF or #\Nul."))
                                 ((= byte #.(char-code #\-))
                                  (setf minus t)))))))
      (declare ((integer 0 #.most-positive-fixnum) result))
      (loop
        (let* ((byte (%read-byte)))
          (if (<= 48 byte 57)
              (setq result (+ (- byte 48)
                              (* 10 (the (integer 0 #.(floor most-positive-fixnum 10)) result))))
              (return (if minus (- result) result))))))))

;;;
;;; Treap with explicit key
;;; Virtually it works like std::map, std::multiset, or java.util.TreeMap.
;;;


;; Tips to use this structure as a multiset: Just define OP as (defun op (x y)
;; (+ x y)) and insert each element by (treap-ensure-key <treap> <key> 1
;; :if-exists #'1+) instead of TREAP-INSERT.

(declaim (inline op))
(defun op (x y)
  "Is the operator comprising a monoid"
  (declare (uint32 x y))
  (max x y))

(defconstant +op-identity+ 0
  "identity element w.r.t. OP")

(declaim (inline updater-op))
(defun updater-op (a b)
  "Is the operator to compute and update LAZY value."
  (declare (int32 a b))
  (+ a b))

(defconstant +updater-identity+ 0
  "identity element w.r.t. UPDATER-OP")

(declaim (inline modifier-op))
(defun modifier-op (a b)
  "Is the operator to update ACCUMULATOR based on LAZY value."
  (declare (int32 a b))
  (+ a b))

;; Treap with explicit key
(defstruct (treap (:constructor %make-treap (key priority value &key left right (accumulator value) lazy))
                  (:copier nil)
                  (:conc-name %treap-))
  (key 0 :type fixnum)
  (value +op-identity+ :type fixnum)
  (accumulator +op-identity+ :type fixnum)
  (lazy +updater-identity+ :type fixnum)
  (priority 0 :type (integer 0 #.most-positive-fixnum))
  (left nil :type (or null treap))
  (right nil :type (or null treap)))

(declaim (inline treap-accumulator))
(defun treap-accumulator (treap)
  (declare ((or null treap) treap))
  (if (null treap)
      +op-identity+
      (%treap-accumulator treap)))

(declaim (inline update-accumulator))
(defun update-accumulator (treap)
  (declare (treap treap))
  (setf (%treap-accumulator treap)
        (if (%treap-left treap)
            (if (%treap-right treap)
                (let ((mid-res (op (%treap-accumulator (%treap-left treap))
                                   (%treap-value treap))))
                  (declare (dynamic-extent mid-res))
                  (op mid-res (%treap-accumulator (%treap-right treap))))
                (op (%treap-accumulator (%treap-left treap))
                    (%treap-value treap)))
            (if (%treap-right treap)
                (op (%treap-value treap)
                    (%treap-accumulator (%treap-right treap)))
                (%treap-value treap)))))

(declaim (inline force-up))
(defun force-up (treap)
  "Propagates up the information from children."
  (declare (treap treap))
  (update-accumulator treap))

(declaim (inline force-down))
(defun force-down (treap)
  "Propagates down the information to children."
  (declare (treap treap))
  (unless (eql +updater-identity+ (%treap-lazy treap))
    (when (%treap-left treap)
      (setf (%treap-lazy (%treap-left treap))
            (updater-op (%treap-lazy (%treap-left treap))
                        (%treap-lazy treap)))
      (setf (%treap-accumulator (%treap-left treap))
            (modifier-op (%treap-accumulator (%treap-left treap))
                         (%treap-lazy treap))))
    (when (%treap-right treap)
      (setf (%treap-lazy (%treap-right treap))
            (updater-op (%treap-lazy (%treap-right treap))
                        (%treap-lazy treap)))
      (setf (%treap-accumulator (%treap-right treap))
            (modifier-op (%treap-accumulator (%treap-right treap))
                         (%treap-lazy treap))))
    (setf (%treap-value treap)
          (modifier-op (%treap-value treap)
                       (%treap-lazy treap)))
    (setf (%treap-lazy treap) +updater-identity+)))

(defun treap-bisect-left (treap key)
  "Returns the smallest key equal to or larger than KEY and the assigned
value. Returns NIL if KEY is larger than any keys in TREAP."
  (declare #.OPT
           ((or null treap) treap))
  (labels ((recur (treap)
             (unless treap (return-from recur nil))
             (force-down treap)
             (if (< (%treap-key treap) key)
                 (recur (%treap-right treap))
                 (or (recur (%treap-left treap))
                     treap))))
    (let ((result (recur treap)))
      (if result
          (values (%treap-key result) (%treap-value result))
          (values nil nil)))))

(declaim (ftype (function * (values (or null treap) (or null treap) &optional)) treap-split))
(defun treap-split (treap key)
  "Destructively splits the TREAP with reference to KEY and returns two treaps,
the smaller sub-treap (< KEY) and the larger one (>= KEY)."
  (declare #.OPT
           ((or null treap) treap)
           (uint32 key))
  (if (null treap)
      (values nil nil)
      (progn
        (force-down treap)
        (if (< (%treap-key treap) key)
            (multiple-value-bind (left right)
                (treap-split (%treap-right treap) key)
              (setf (%treap-right treap) left)
              (force-up treap)
              (values treap right))
            (multiple-value-bind (left right)
                (treap-split (%treap-left treap) key)
              (setf (%treap-left treap) right)
              (force-up treap)
              (values left treap))))))

(defun treap-merge (left right)
  "Destructively concatenates two treaps. Assumes that all keys of LEFT are
smaller (or larger, depending on the order) than those of RIGHT."
  (declare #.OPT
           ((or null treap) left right))
  (cond ((null left) (when right (force-down right) (force-up right)) right)
        ((null right) (when left (force-down left) (force-up left)) left)
        (t (force-down left)
           (force-down right)
         (if (> (%treap-priority left) (%treap-priority right))
             (progn
               (setf (%treap-right left)
                     (treap-merge (%treap-right left) right))
               (force-up left)
               left)
             (progn
               (setf (%treap-left right)
                     (treap-merge left (%treap-left right)))
               (force-up right)
               right)))))

;; Reference: https://cp-algorithms.com/data_structures/treap.html
;; TODO: take a sorted list as the argument
(defun make-treap (sorted-vector)
  "Makes a treap using each key of the given SORTED-VECTOR in O(n). Note that
this function doesn't check if the SORTED-VECTOR is actually sorted w.r.t. your
intended order. The values are filled with the identity element."
  (declare #.OPT
           ((simple-array uint31 (*)) sorted-vector))
  (labels ((heapify (top)
             (when top
               (let ((prioritized-node top))
                 (when (and (%treap-left top)
                            (> (%treap-priority (%treap-left top))
                               (%treap-priority prioritized-node)))
                   (setq prioritized-node (%treap-left top)))
                 (when (and (%treap-right top)
                            (> (%treap-priority (%treap-right top))
                               (%treap-priority prioritized-node)))
                   (setq prioritized-node (%treap-right top)))
                 (unless (eql prioritized-node top)
                   (rotatef (%treap-priority prioritized-node)
                            (%treap-priority top))
                   (heapify prioritized-node)))))
           (build (l r)
             (declare ((integer 0 #.most-positive-fixnum) l r))
             (if (= l r)
                 nil
                 (let* ((mid (ash (+ l r) -1))
                        (node (%make-treap (aref sorted-vector mid)
                                           (random most-positive-fixnum)
                                           +op-identity+)))
                   (setf (%treap-left node) (build l mid))
                   (setf (%treap-right node) (build (+ mid 1) r))
                   (heapify node)
                   node))))
    (build 0 (length sorted-vector))))

(defconstant +pos-inf+ most-positive-fixnum)
(defconstant +neg-inf+ most-negative-fixnum)

(defun treap-query (treap &key left right)
  "Queries the sum of the half-open interval specified by the keys: [LEFT,
RIGHT). If LEFT [RIGHT] is not given, it is assumed to be -inf [+inf]."
  (declare #.OPT)
  (setq left (or left +neg-inf+)
        right (or right +pos-inf+))
  (labels ((recur (treap l r)
             (declare (fixnum l r))
             (unless treap
               (return-from recur +op-identity+))
             (force-down treap)
             (prog1
                 (if (and (= l +neg-inf+) (= r +pos-inf+))
                     (%treap-accumulator treap)
                     (let ((key (%treap-key treap)))
                       (if (<= l key)
                           (if (< key r)
                               (funcall #'op
                                        (funcall #'op
                                                 (recur (%treap-left treap) l +pos-inf+)
                                                 (%treap-value treap))
                                        (recur (%treap-right treap) +neg-inf+ r))
                               (recur (%treap-left treap) l r))
                           (recur (%treap-right treap) l r))))
               (force-up treap))))
    (recur treap left right)))

(defun treap-update (treap x left right)
  "Updates TREAP[KEY] := (OP TREAP[KEY] X) for all KEY in [l, r)"
  (declare #.OPT
           (fixnum left right))
  (assert (not (< right left)))
  (labels ((recur (treap l r)
             (declare (fixnum l r))
             (when treap
               (if (and (= l +neg-inf+) (= r +pos-inf+))
                   (progn
                     (setf (%treap-lazy treap)
                           (updater-op (%treap-lazy treap) x))
                     (force-down treap))
                   (let ((key (%treap-key treap)))
                     (force-down treap)
                     (if (<= l key)
                         (if (< key r)
                             (progn
                               (recur (%treap-left treap) l +pos-inf+)
                               (setf (%treap-value treap)
                                     (modifier-op (%treap-value treap) x))
                               (recur (%treap-right treap) +neg-inf+ r))
                             (recur (%treap-left treap) l r))
                         (recur (%treap-right treap) l r))))
               (force-up treap))))
    (recur treap left right)))

(defmacro dbg (&rest forms)
  #+swank
  (if (= (length forms) 1)
      `(format *error-output* "~A => ~A~%" ',(car forms) ,(car forms))
      `(format *error-output* "~A => ~A~%" ',forms `(,,@forms)))
  #-swank (declare (ignore forms)))



(declaim (inline println))
(defun println (obj &optional (stream *standard-output*))
  (let ((*read-default-float-format* 'double-float))
    (prog1 (princ obj stream) (terpri stream))))

(defconstant +mod+ 1000000007)

;;;
;;; Body
;;;

(defun solve (n ls rs lrs seq)
  (declare #.OPT
           (uint31 n)
           ((simple-array uint31 (*)) ls rs seq)
           ((simple-array (cons uint31 uint31) (*)) lrs))
  (let ((inf (reduce #'max seq))
        (treap1 (make-treap seq))
        (treap2 (make-treap seq))
        (res 0))
    (dotimes (i n)
      (let ((l (aref ls i))
            (r (aref rs i)))
        (dbg l r)
        (treap-update treap2 1 l r)))
    (dotimes (i n)
      (let* ((lr (aref lrs i))
             (required1 i)
             (required2 (- n i))
             (l (car lr))
             (r (cdr lr))
             (max1 (treap-query treap1))
             (max2 (treap-query treap2)))
        (when (and (= required1 max1) (= required2 max2))
          (let* ((max1l (sb-int:named-let bisect ((ng 0) (ok inf))
                          (declare (uint32 ng ok))
                          (if (<= (- ok ng) 1)
                              (- ok 1)
                              (let ((mid (ash (+ ng ok) -1)))
                                (if (= (treap-query treap1 :right mid) max1)
                                    (bisect ng mid)
                                    (bisect mid ok))))))
                 (max1r (sb-int:named-let bisect ((ng max1l) (ok inf))
                          (declare (uint32 ng ok))
                          (if (<= (- ok ng) 1)
                              (treap-bisect-left treap1 ok)
                              (let ((mid (ash (+ ng ok) -1)))
                                (if (< (treap-query treap1 :left mid) max1)
                                    (bisect ng mid)
                                    (bisect mid ok))))))
                 (max2l (sb-int:named-let bisect ((ng 0) (ok inf))
                          (declare (uint32 ng ok))
                          (if (<= (- ok ng) 1)
                              (- ok 1)
                              (let ((mid (ash (+ ng ok) -1)))
                                (if (= (treap-query treap2 :right mid) max2)
                                    (bisect ng mid)
                                    (bisect mid ok))))))
                 (max2r (sb-int:named-let bisect ((ng max2l) (ok inf))
                          (declare (uint32 ng ok))
                          (if (<= (- ok ng) 1)
                              (treap-bisect-left treap2 ok)
                              (let ((mid (ash (+ ng ok) -1)))
                                (if (< (treap-query treap2 :left mid) max2)
                                    (bisect ng mid)
                                    (bisect mid ok))))))
                 (new-score (+ (- max1r max1l) (- max2r max2l))))
            (unless (zerop i)
              (setq res (max res new-score)))))
        (treap-update treap1 1 l r)
        (treap-update treap2 -1 l r)))
    res))

(defun main ()
  (declare #.OPT
           (inline sort))
  (let* ((n (read))
         (ls (make-array n :element-type 'uint31))
         (rs (make-array n :element-type 'uint31))
         (lrs (make-array n :element-type '(cons uint31 uint31)))
         (seq (make-array (+ n n) :element-type 'uint31)))
    (dotimes (i n)
      (let ((l (- (read-fixnum) 1))
            (r (read-fixnum)))
        (setf (aref ls i) l
              (aref rs i) r
              (aref lrs i) (cons l r)
              (aref seq i) l
              (aref seq (+ i n)) r)))
    (setq seq (sort seq #'<)
          lrs (sort lrs (lambda (x y) (< (the uint32 x) (the uint32 y))) :key #'cdr))
    (setq seq (delete-adjacent-duplicates seq))
    (let ((cand (solve n ls rs lrs seq)))
      (let ((idx 0)
            (l 0)
            (r 1000000000))
        (dotimes (i n)
          (when (>= (- (aref rs i) (aref ls i))
                    (- (aref rs idx) (aref ls idx)))
            (setq idx i)))
        (dotimes (i n)
          (unless (= idx i)
            (setq l (max l (aref ls i))
                  r (min r (aref rs i)))))
        (let ((cand2 (+ (- (aref rs idx) (aref ls idx))
                        (max 0 (- r l)))))
          (println (max cand cand2)))))))

#-swank (main)

;;;
;;; Test and benchmark
;;;

#+swank
(defun io-equal (in-string out-string &key (function #'main) (test #'equal))
  "Passes IN-STRING to *STANDARD-INPUT*, executes FUNCTION, and returns true if
the string output to *STANDARD-OUTPUT* is equal to OUT-STRING."
  (labels ((ensure-last-lf (s)
             (if (eql (uiop:last-char s) #\Linefeed)
                 s
                 (uiop:strcat s uiop:+lf+))))
    (funcall test
             (ensure-last-lf out-string)
             (with-output-to-string (out)
               (let ((*standard-output* out))
                 (with-input-from-string (*standard-input* (ensure-last-lf in-string))
                   (funcall function)))))))

#+swank
(defun get-clipbrd ()
  (with-output-to-string (out)
    (run-program "C:/msys64/usr/bin/cat.exe" '("/dev/clipboard") :output out)))

#+swank (defparameter *this-pathname* (uiop:current-lisp-file-pathname))
#+swank (defparameter *dat-pathname* (uiop:merge-pathnames* "test.dat" *this-pathname*))

#+swank
(defun run (&optional thing (out *standard-output*))
  "THING := null | string | symbol | pathname

null: run #'MAIN using the text on clipboard as input.
string: run #'MAIN using the string as input.
symbol: alias of FIVEAM:RUN!.
pathname: run #'MAIN using the text file as input."
  (let ((*standard-output* out))
    (etypecase thing
      (null
       (with-input-from-string (*standard-input* (delete #\Return (get-clipbrd)))
         (main)))
      (string
       (with-input-from-string (*standard-input* (delete #\Return thing))
         (main)))
      (symbol (5am:run! thing))
      (pathname
       (with-open-file (*standard-input* thing)
         (main))))))

#+swank
(defun gen-dat ()
  (uiop:with-output-file (out *dat-pathname* :if-exists :supersede)
    (format out "")))

#+swank
(defun bench (&optional (out (make-broadcast-stream)))
  (time (run *dat-pathname* out)))

;; To run: (5am:run! :sample)
#+swank
(it.bese.fiveam:test :sample
  (it.bese.fiveam:is
   (common-lisp-user::io-equal "4
4 7
1 4
5 8
2 5
"
    "6
"))
  (it.bese.fiveam:is
   (common-lisp-user::io-equal "4
1 20
2 19
3 18
4 17
"
    "34
"))
  (it.bese.fiveam:is
   (common-lisp-user::io-equal "10
457835016 996058008
456475528 529149798
455108441 512701454
455817105 523506955
457368248 814532746
455073228 459494089
456651538 774276744
457667152 974637457
457293701 800549465
456580262 636471526
"
    "540049931
")))