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 C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using static System.Math;
using System.Text;
using System.Threading;
namespace Program
{
    public static class AGC040B
    {
        static public int numberOfRandomCases = 0;
        static public void MakeTestCase(List<string> _input, List<string> _output, ref Func<string[], bool> _outputChecker)
        {
        }
        static public void Solve()
        {
            var N = NN;
            var lrlist = Repeat(0, N).Select(_ => new { L = NN, R = NN }).OrderByRand().ToList();
            var ans = 0L;
            {
                var maxValue = lrlist.Max(e => e.R - e.L + 1);
                var sortedRFirst = lrlist.OrderBy(e => e.R).First();
                lrlist.Remove(sortedRFirst);
                var sortedLLast = lrlist.OrderBy(e => e.L).Last();
                lrlist.Remove(sortedLLast);
                var sorted = lrlist.OrderBy(e => e.L).ToList();
                lrlist.Add(sortedLLast);
                lrlist.Add(sortedRFirst);
                var l1 = sortedRFirst.L;
                var r1 = sortedRFirst.R;
                var l2 = sortedLLast.L;
                var r2 = sortedLLast.R;
                if (l2 < l1)
                {
                    var t = l1; l1 = l2; l2 = t;
                    var t2 = r2; r2 = r1; r1 = t2;

                }
                foreach (var item in sorted)
                {
                    var nextl1 = l1;
                    var nextr1 = r1;
                    var nextl2 = l2;
                    var nextr2 = r2;
                    nextl1 = Max(nextl1, item.L);
                    nextl2 = Max(nextl2, item.L);
                    nextr1 = Min(nextr1, item.R);
                    nextr2 = Min(nextr2, item.R);
                    var tanosisa1 = r1 - l1 + 1;
                    var tanosisa2 = r2 - l2 + 1;
                    var nextTanosisa1 = nextr1 - nextl1 + 1;
                    var nextTanosisa2 = nextr2 - nextl2 + 1;
                    var dif1 = tanosisa1 - nextTanosisa1;
                    var dif2 = tanosisa2 - nextTanosisa2;
                    if (dif1 <= dif2)
                    {
                        l1 = nextl1;
                        r1 = nextr1;
                    }
                    else
                    {
                        l2 = nextl2;
                        r2 = nextr2;
                    }
                }
                ans = Max(maxValue, Max(r1 - l1 + 1, 0) + Max(r2 - l2 + 1, 0));
            }
            {
                var maxValue = lrlist.Max(e => e.R - e.L + 1);
                var sortedRFirst = lrlist.OrderBy(e => e.R).First();
                lrlist.Remove(sortedRFirst);
                var sortedLLast = lrlist.OrderBy(e => e.L).First();
                lrlist.Remove(sortedLLast);
                var sorted = lrlist.OrderBy(e => e.L).ToList();
                lrlist.Add(sortedLLast);
                lrlist.Add(sortedRFirst);
                var l1 = sortedRFirst.L;
                var r1 = sortedRFirst.R;
                var l2 = sortedLLast.L;
                var r2 = sortedLLast.R;
                if (l2 < l1)
                {
                    var t = l1; l1 = l2; l2 = t;
                    var t2 = r2; r2 = r1; r1 = t2;

                }
                foreach (var item in sorted)
                {
                    var nextl1 = l1;
                    var nextr1 = r1;
                    var nextl2 = l2;
                    var nextr2 = r2;
                    nextl1 = Max(nextl1, item.L);
                    nextl2 = Max(nextl2, item.L);
                    nextr1 = Min(nextr1, item.R);
                    nextr2 = Min(nextr2, item.R);
                    var tanosisa1 = r1 - l1 + 1;
                    var tanosisa2 = r2 - l2 + 1;
                    var nextTanosisa1 = nextr1 - nextl1 + 1;
                    var nextTanosisa2 = nextr2 - nextl2 + 1;
                    var dif1 = tanosisa1 - nextTanosisa1;
                    var dif2 = tanosisa2 - nextTanosisa2;
                    if (dif1 <= dif2)
                    {
                        l1 = nextl1;
                        r1 = nextr1;
                    }
                    else
                    {
                        l2 = nextl2;
                        r2 = nextr2;
                    }
                }
                ans = Max(ans, Max(maxValue, Max(r1 - l1 + 1, 0) + Max(r2 - l2 + 1, 0)));
            }
            {
                var maxValue = lrlist.Max(e => e.R - e.L + 1);
                var sortedRFirst = lrlist.OrderBy(e => e.R).Last();
                lrlist.Remove(sortedRFirst);
                var sortedLLast = lrlist.OrderBy(e => e.L).First();
                lrlist.Remove(sortedLLast);
                var sorted = lrlist.OrderBy(e => e.L).ToList();
                lrlist.Add(sortedLLast);
                lrlist.Add(sortedRFirst);
                var l1 = sortedRFirst.L;
                var r1 = sortedRFirst.R;
                var l2 = sortedLLast.L;
                var r2 = sortedLLast.R;
                if (l2 < l1)
                {
                    var t = l1; l1 = l2; l2 = t;
                    var t2 = r2; r2 = r1; r1 = t2;

                }
                foreach (var item in sorted)
                {
                    var nextl1 = l1;
                    var nextr1 = r1;
                    var nextl2 = l2;
                    var nextr2 = r2;
                    nextl1 = Max(nextl1, item.L);
                    nextl2 = Max(nextl2, item.L);
                    nextr1 = Min(nextr1, item.R);
                    nextr2 = Min(nextr2, item.R);
                    var tanosisa1 = r1 - l1 + 1;
                    var tanosisa2 = r2 - l2 + 1;
                    var nextTanosisa1 = nextr1 - nextl1 + 1;
                    var nextTanosisa2 = nextr2 - nextl2 + 1;
                    var dif1 = tanosisa1 - nextTanosisa1;
                    var dif2 = tanosisa2 - nextTanosisa2;
                    if (dif1 <= dif2)
                    {
                        l1 = nextl1;
                        r1 = nextr1;
                    }
                    else
                    {
                        l2 = nextl2;
                        r2 = nextr2;
                    }
                }
                ans = Max(ans, Max(maxValue, Max(r1 - l1 + 1, 0) + Max(r2 - l2 + 1, 0)));
            }
            {
                var maxValue = lrlist.Max(e => e.R - e.L + 1);
                var sortedRFirst = lrlist.OrderBy(e => e.R).Last();
                lrlist.Remove(sortedRFirst);
                var sortedLLast = lrlist.OrderBy(e => e.L).Last();
                lrlist.Remove(sortedLLast);
                var sorted = lrlist.OrderBy(e => e.L).ToList();
                lrlist.Add(sortedLLast);
                lrlist.Add(sortedRFirst);
                var l1 = sortedRFirst.L;
                var r1 = sortedRFirst.R;
                var l2 = sortedLLast.L;
                var r2 = sortedLLast.R;
                if (l2 < l1)
                {
                    var t = l1; l1 = l2; l2 = t;
                    var t2 = r2; r2 = r1; r1 = t2;

                }
                foreach (var item in sorted)
                {
                    var nextl1 = l1;
                    var nextr1 = r1;
                    var nextl2 = l2;
                    var nextr2 = r2;
                    nextl1 = Max(nextl1, item.L);
                    nextl2 = Max(nextl2, item.L);
                    nextr1 = Min(nextr1, item.R);
                    nextr2 = Min(nextr2, item.R);
                    var tanosisa1 = r1 - l1 + 1;
                    var tanosisa2 = r2 - l2 + 1;
                    var nextTanosisa1 = nextr1 - nextl1 + 1;
                    var nextTanosisa2 = nextr2 - nextl2 + 1;
                    var dif1 = tanosisa1 - nextTanosisa1;
                    var dif2 = tanosisa2 - nextTanosisa2;
                    if (dif1 <= dif2)
                    {
                        l1 = nextl1;
                        r1 = nextr1;
                    }
                    else
                    {
                        l2 = nextl2;
                        r2 = nextr2;
                    }
                }
                ans = Max(ans, Max(maxValue, Max(r1 - l1 + 1, 0) + Max(r2 - l2 + 1, 0)));
            }
            {
                var maxValue = lrlist.Max(e => e.R - e.L + 1);
                var lrlisthenka = lrlist.Select(e => new { e.L, e.R, len = e.R - e.L + 1 }).ToList();
                var sortedRFirst = lrlisthenka.OrderBy(e => e.len).First();
                lrlisthenka.Remove(sortedRFirst);
                var sortedLLast = lrlisthenka.OrderBy(e => e.len).Last();
                lrlisthenka.Remove(sortedLLast);
                var sorted = lrlisthenka.OrderBy(e => e.L).ToList();
                var l1 = sortedRFirst.L;
                var r1 = sortedRFirst.R;
                var l2 = sortedLLast.L;
                var r2 = sortedLLast.R;
                if (l2 < l1)
                {
                    var t = l1; l1 = l2; l2 = t;
                    var t2 = r2; r2 = r1; r1 = t2;

                }
                foreach (var item in sorted)
                {
                    var nextl1 = l1;
                    var nextr1 = r1;
                    var nextl2 = l2;
                    var nextr2 = r2;
                    nextl1 = Max(nextl1, item.L);
                    nextl2 = Max(nextl2, item.L);
                    nextr1 = Min(nextr1, item.R);
                    nextr2 = Min(nextr2, item.R);
                    var tanosisa1 = r1 - l1 + 1;
                    var tanosisa2 = r2 - l2 + 1;
                    var nextTanosisa1 = nextr1 - nextl1 + 1;
                    var nextTanosisa2 = nextr2 - nextl2 + 1;
                    var dif1 = tanosisa1 - nextTanosisa1;
                    var dif2 = tanosisa2 - nextTanosisa2;
                    if (dif1 <= dif2)
                    {
                        l1 = nextl1;
                        r1 = nextr1;
                    }
                    else
                    {
                        l2 = nextl2;
                        r2 = nextr2;
                    }
                }
                ans = Max(ans, Max(maxValue, Max(r1 - l1 + 1, 0) + Max(r2 - l2 + 1, 0)));
            }
            {
                var maxValue = lrlist.Max(e => e.R - e.L + 1);
                var lrlisthenka = lrlist.Select(e => new { e.L, e.R, len = e.R - e.L + 1 }).ToList();
                var ookii = lrlisthenka.OrderBy(e => e.len).Last();
                lrlisthenka.Remove(ookii);
                var sortedLLast = lrlisthenka.OrderBy(e => e.len).Last();
                var kezuritori = 0L;
                foreach (var item in lrlisthenka)
                {
                    var a = ookii.len;
                    var nr = Min(ookii.R, item.R);
                    var nl = Max(ookii.L, item.L);
                    var dif = nr - nl + 1;
                    var kezuri = a - dif;
                    if (kezuritori < kezuri)
                    {
                        kezuritori = kezuri;
                        sortedLLast = item;
                    }
                }
                lrlisthenka.Remove(sortedLLast);
                var sorted = lrlisthenka.OrderBy(e => e.L).ToList();
                var l1 = ookii.L;
                var r1 = ookii.R;
                var l2 = sortedLLast.L;
                var r2 = sortedLLast.R;
                if (l2 < l1)
                {
                    var t = l1; l1 = l2; l2 = t;
                    var t2 = r2; r2 = r1; r1 = t2;

                }
                foreach (var item in sorted)
                {
                    var nextl1 = l1;
                    var nextr1 = r1;
                    var nextl2 = l2;
                    var nextr2 = r2;
                    nextl1 = Max(nextl1, item.L);
                    nextl2 = Max(nextl2, item.L);
                    nextr1 = Min(nextr1, item.R);
                    nextr2 = Min(nextr2, item.R);
                    var tanosisa1 = r1 - l1 + 1;
                    var tanosisa2 = r2 - l2 + 1;
                    var nextTanosisa1 = nextr1 - nextl1 + 1;
                    var nextTanosisa2 = nextr2 - nextl2 + 1;
                    var dif1 = tanosisa1 - nextTanosisa1;
                    var dif2 = tanosisa2 - nextTanosisa2;
                    if (dif1 <= dif2)
                    {
                        l1 = nextl1;
                        r1 = nextr1;
                    }
                    else
                    {
                        l2 = nextl2;
                        r2 = nextr2;
                    }
                }
                ans = Max(ans, Max(maxValue, Max(r1 - l1 + 1, 0) + Max(r2 - l2 + 1, 0)));
            }

            {
                var maxValue = lrlist.Max(e => e.R - e.L + 1);
                var lrlisthenka = lrlist.Select(e => new { e.L, e.R, len = e.R - e.L + 1 }).ToList();
                var ookii = lrlisthenka.OrderBy(e => e.len).Last();
                lrlisthenka.Remove(ookii);
                var sortedLLast = lrlisthenka.OrderBy(e => e.len).Last();
                var kezuritori = 0L;
                foreach (var item in lrlisthenka)
                {
                    var a = ookii.len;
                    var nr = Min(ookii.R, item.R);
                    var nl = Max(ookii.L, item.L);
                    var dif = nr - nl + 1;
                    var kezuri = a - dif;
                    if (kezuritori < kezuri)
                    {
                        kezuritori = kezuri;
                        sortedLLast = item;
                    }
                }
                lrlisthenka.Remove(sortedLLast);
                var sorted = lrlisthenka.OrderBy(e => e.len).ToList();
                var l1 = ookii.L;
                var r1 = ookii.R;
                var l2 = sortedLLast.L;
                var r2 = sortedLLast.R;
                if (l2 < l1)
                {
                    var t = l1; l1 = l2; l2 = t;
                    var t2 = r2; r2 = r1; r1 = t2;

                }
                foreach (var item in sorted)
                {
                    var nextl1 = l1;
                    var nextr1 = r1;
                    var nextl2 = l2;
                    var nextr2 = r2;
                    nextl1 = Max(nextl1, item.L);
                    nextl2 = Max(nextl2, item.L);
                    nextr1 = Min(nextr1, item.R);
                    nextr2 = Min(nextr2, item.R);
                    var tanosisa1 = r1 - l1 + 1;
                    var tanosisa2 = r2 - l2 + 1;
                    var nextTanosisa1 = nextr1 - nextl1 + 1;
                    var nextTanosisa2 = nextr2 - nextl2 + 1;
                    var dif1 = tanosisa1 - nextTanosisa1;
                    var dif2 = tanosisa2 - nextTanosisa2;
                    if (dif1 <= dif2)
                    {
                        l1 = nextl1;
                        r1 = nextr1;
                    }
                    else
                    {
                        l2 = nextl2;
                        r2 = nextr2;
                    }
                }
                ans = Max(ans, Max(maxValue, Max(r1 - l1 + 1, 0) + Max(r2 - l2 + 1, 0)));
            }
            Console.WriteLine(ans);
        }
        static public void Main(string[] args) { if (args.Length == 0) { var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false }; Console.SetOut(sw); } var t = new Thread(Solve, 134217728); t.Start(); t.Join(); Console.Out.Flush(); }
        static class Console_
        {
            static Queue<string> param = new Queue<string>();
            public static string NextString() { if (param.Count == 0) foreach (var item in Console.ReadLine().Split(' ')) param.Enqueue(item); return param.Dequeue(); }
        }
        static long NN => long.Parse(Console_.NextString());
        static double ND => double.Parse(Console_.NextString());
        static string NS => Console_.NextString();
        static long[] NNList(long N) => Repeat(0, N).Select(_ => NN).ToArray();
        static double[] NDList(long N) => Repeat(0, N).Select(_ => ND).ToArray();
        static string[] NSList(long N) => Repeat(0, N).Select(_ => NS).ToArray();
        static IEnumerable<T> OrderByRand<T>(this IEnumerable<T> x) => x.OrderBy(_ => xorshift);
        static long Count<T>(this IEnumerable<T> x, Func<T, bool> pred) => Enumerable.Count(x, pred);
        static IEnumerable<T> Repeat<T>(T v, long n) => Enumerable.Repeat<T>(v, (int)n);
        static IEnumerable<int> Range(long s, long c) => Enumerable.Range((int)s, (int)c);
        static IEnumerable<long> Primes(long x) { if (x < 2) yield break; yield return 2; var halfx = x / 2; var table = new bool[halfx + 1]; var max = (long)(Math.Sqrt(x) / 2); for (long i = 1; i <= max; ++i) { if (table[i]) continue; var add = 2 * i + 1; yield return add; for (long j = 2 * i * (i + 1); j <= halfx; j += add) table[j] = true; } for (long i = max + 1; i <= halfx; ++i) if (!table[i] && 2 * i + 1 <= x) yield return 2 * i + 1; }
        static IEnumerable<long> Factors(long x) { if (x < 2) yield break; while (x % 2 == 0) { x /= 2; yield return 2; } var max = (long)Math.Sqrt(x); for (long i = 3; i <= max; i += 2) while (x % i == 0) { x /= i; yield return i; } if (x != 1) yield return x; }
        static IEnumerable<long> Divisor(long x) { if (x < 1) yield break; var max = (long)Math.Sqrt(x); for (long i = 1; i <= max; ++i) { if (x % i != 0) continue; yield return i; if (i != x / i) yield return x / i; } }
        static uint xorshift { get { _xsi.MoveNext(); return _xsi.Current; } }
        static IEnumerator<uint> _xsi = _xsc();
        static IEnumerator<uint> _xsc() { uint x = 123456789, y = 362436069, z = 521288629, w = (uint)(DateTime.Now.Ticks & 0xffffffff); while (true) { var t = x ^ (x << 11); x = y; y = z; z = w; w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)); yield return w; } }
        static long GCD(long a, long b) { while (b > 0) { var tmp = b; b = a % b; a = tmp; } return a; }
        static long LCM(long a, long b) => a * b / GCD(a, b);
        static Mod Pow(Mod x, long y) { Mod a = 1; while (y != 0) { if ((y & 1) == 1) a.Mul(x); x.Mul(x); y >>= 1; } return a; }
        static long Pow(long x, long y) { long a = 1; while (y != 0) { if ((y & 1) == 1) a *= x; x *= x; y >>= 1; } return a; }
        static List<long> _fact = new List<long>() { 1 };
        static void _B(long n) { if (n >= _fact.Count) for (int i = _fact.Count; i <= n; ++i) _fact.Add(_fact[i - 1] * i); }
        static long Comb(long n, long k) { _B(n); if (n == 0 && k == 0) return 1; if (n < k || n < 0) return 0; return _fact[(int)n] / _fact[(int)(n - k)] / _fact[(int)k]; }
        static long Perm(long n, long k) { _B(n); if (n == 0 && k == 0) return 1; if (n < k || n < 0) return 0; return _fact[(int)n] / _fact[(int)(n - k)]; }
        static Func<TR> Lambda<TR>(Func<Func<TR>, TR> f) { Func<TR> t = () => default(TR); return t = () => f(t); }
        static Func<T1, TR> Lambda<T1, TR>(Func<T1, Func<T1, TR>, TR> f) { Func<T1, TR> t = x1 => default(TR); return t = x1 => f(x1, t); }
        static Func<T1, T2, TR> Lambda<T1, T2, TR>(Func<T1, T2, Func<T1, T2, TR>, TR> f) { Func<T1, T2, TR> t = (x1, x2) => default(TR); return t = (x1, x2) => f(x1, x2, t); }
        static Func<T1, T2, T3, TR> Lambda<T1, T2, T3, TR>(Func<T1, T2, T3, Func<T1, T2, T3, TR>, TR> f) { Func<T1, T2, T3, TR> t = (x1, x2, x3) => default(TR); return t = (x1, x2, x3) => f(x1, x2, x3, t); }
        static Func<T1, T2, T3, T4, TR> Lambda<T1, T2, T3, T4, TR>(Func<T1, T2, T3, T4, Func<T1, T2, T3, T4, TR>, TR> f) { Func<T1, T2, T3, T4, TR> t = (x1, x2, x3, x4) => default(TR); return t = (x1, x2, x3, x4) => f(x1, x2, x3, x4, t); }
        static List<T> LCS<T>(T[] s, T[] t) where T : IEquatable<T> { int sl = s.Length, tl = t.Length; var dp = new int[sl + 1, tl + 1]; for (var i = 0; i < sl; i++) for (var j = 0; j < tl; j++) dp[i + 1, j + 1] = s[i].Equals(t[j]) ? dp[i, j] + 1 : Max(dp[i + 1, j], dp[i, j + 1]); { var r = new List<T>(); int i = sl, j = tl; while (i > 0 && j > 0) if (s[--i].Equals(t[--j])) r.Add(s[i]); else if (dp[i, j + 1] > dp[i + 1, j]) ++j; else ++i; r.Reverse(); return r; } }
        static long LIS<T>(T[] array, bool strict) { var l = new List<T>(); foreach (var e in array) { var i = l.BinarySearch(e); if (i < 0) i = ~i; else if (!strict) ++i; if (i == l.Count) l.Add(e); else l[i] = e; } return l.Count; }
        class PQ<T>
        {
            List<T> h; Comparison<T> c; public T Peek => h[0]; public int Count => h.Count;
            public PQ(int cap, Comparison<T> c, bool asc = true) { h = new List<T>(cap); this.c = asc ? c : (x, y) => c(y, x); }
            public PQ(Comparison<T> c, bool asc = true) { h = new List<T>(); this.c = asc ? c : (x, y) => c(y, x); }
            public PQ(int cap, bool asc = true) : this(cap, Comparer<T>.Default.Compare, asc) { }
            public PQ(bool asc = true) : this(Comparer<T>.Default.Compare, asc) { }
            public void Push(T v) { var i = h.Count; h.Add(v); while (i > 0) { var ni = (i - 1) / 2; if (c(v, h[ni]) >= 0) break; h[i] = h[ni]; i = ni; } h[i] = v; }
            public T Pop() { var r = h[0]; var v = h[h.Count - 1]; h.RemoveAt(h.Count - 1); if (h.Count == 0) return r; var i = 0; while (i * 2 + 1 < h.Count) { var i1 = i * 2 + 1; var i2 = i * 2 + 2; if (i2 < h.Count && c(h[i1], h[i2]) > 0) i1 = i2; if (c(v, h[i1]) <= 0) break; h[i] = h[i1]; i = i1; } h[i] = v; return r; }
        }
        class PQ<TK, TV>
        {
            PQ<Tuple<TK, TV>> q; public Tuple<TK, TV> Peek => q.Peek; public int Count => q.Count;
            public PQ(int cap, Comparison<TK> c, bool asc = true) { q = new PQ<Tuple<TK, TV>>(cap, (x, y) => c(x.Item1, y.Item1), asc); }
            public PQ(Comparison<TK> c, bool asc = true) { q = new PQ<Tuple<TK, TV>>((x, y) => c(x.Item1, y.Item1), asc); }
            public PQ(int cap, bool asc = true) : this(cap, Comparer<TK>.Default.Compare, asc) { }
            public PQ(bool asc = true) : this(Comparer<TK>.Default.Compare, asc) { }
            public void Push(TK k, TV v) => q.Push(Tuple.Create(k, v));
            public Tuple<TK, TV> Pop() => q.Pop();
        }
        public class UF
        {
            long[] d;
            public UF(long s) { d = Repeat(-1L, s).ToArray(); }
            public bool Unite(long x, long y) { x = Root(x); y = Root(y); if (x != y) { if (d[y] < d[x]) { var t = y; y = x; x = t; } d[x] += d[y]; d[y] = x; } return x != y; }
            public bool IsSame(long x, long y) => Root(x) == Root(y);
            public long Root(long x) => d[x] < 0 ? x : d[x] = Root(d[x]);
            public long Count(long x) => -d[Root(x)];
        }
        struct Mod : IEquatable<Mod>, IEquatable<long>
        {
            static public long _mod = 1000000007; long v;
            public Mod(long x) { if (x < _mod && x >= 0) v = x; else if ((v = x % _mod) < 0) v += _mod; }
            static public implicit operator Mod(long x) => new Mod(x);
            static public implicit operator long(Mod x) => x.v;
            public void Add(Mod x) { if ((v += x.v) >= _mod) v -= _mod; }
            public void Sub(Mod x) { if ((v -= x.v) < 0) v += _mod; }
            public void Mul(Mod x) => v = (v * x.v) % _mod;
            public void Div(Mod x) => v = (v * Inverse(x.v)) % _mod;
            static public Mod operator +(Mod x, Mod y) { var t = x.v + y.v; return t >= _mod ? new Mod { v = t - _mod } : new Mod { v = t }; }
            static public Mod operator -(Mod x, Mod y) { var t = x.v - y.v; return t < 0 ? new Mod { v = t + _mod } : new Mod { v = t }; }
            static public Mod operator *(Mod x, Mod y) => x.v * y.v;
            static public Mod operator /(Mod x, Mod y) => x.v * Inverse(y.v);
            static public bool operator ==(Mod x, Mod y) => x.v == y.v;
            static public bool operator !=(Mod x, Mod y) => x.v != y.v;
            static public long Inverse(long x) { long b = _mod, r = 1, u = 0, t = 0; while (b > 0) { var q = x / b; t = u; u = r - q * u; r = t; t = b; b = x - q * b; x = t; } return r < 0 ? r + _mod : r; }
            public bool Equals(Mod x) => v == x.v;
            public bool Equals(long x) => v == x;
            public override bool Equals(object x) => x == null ? false : Equals((Mod)x);
            public override int GetHashCode() => v.GetHashCode();
            public override string ToString() => v.ToString();
            static List<Mod> _fact = new List<Mod>() { 1 };
            static void B(long n) { if (n >= _fact.Count) for (int i = _fact.Count; i <= n; ++i) _fact.Add(_fact[i - 1] * i); }
            static public Mod Comb(long n, long k) { B(n); if (n == 0 && k == 0) return 1; if (n < k || n < 0) return 0; return _fact[(int)n] / _fact[(int)(n - k)] / _fact[(int)k]; }
            static public Mod Perm(long n, long k) { B(n); if (n == 0 && k == 0) return 1; if (n < k || n < 0) return 0; return _fact[(int)n] / _fact[(int)(n - k)]; }
        }
        class Tree
        {
            long N; int l; List<long>[] p; int[] d; long[][] pr; long r; Tuple<long, long, int>[] e; Tuple<long, long>[] b; bool lca; bool euler; bool bfs;
            public Tree(List<long>[] p_, long r_) { N = p_.Length; p = p_; r = r_; lca = false; euler = false; }
            public Tuple<long, long>[] BFSRoot() { if (!bfs) { var nb = new List<Tuple<long, long>>(); var q = new Queue<long>(); var d = new bool[N]; nb.Add(Tuple.Create(r, -1L)); d[r] = true; q.Enqueue(r); while (q.Count > 0) { var w = q.Dequeue(); foreach (var i in p[w]) { if (d[i]) continue; d[i] = true; q.Enqueue(i); nb.Add(Tuple.Create(i, w)); } } b = nb.ToArray(); bfs = true; } return b; }
            public Tuple<long, long>[] BFSLeaf() => BFSRoot().Reverse().ToArray();
            public Tuple<long, long, int>[] Euler() { if (!euler) { var ne = new List<Tuple<long, long, int>>(); var s = new Stack<Tuple<long, long>>(); var d = new bool[N]; d[r] = true; s.Push(Tuple.Create(r, -1L)); while (s.Count > 0) { var w = s.Peek(); var ad = true; foreach (var i in p[w.Item1]) { if (d[i]) continue; d[i] = true; ad = false; s.Push(Tuple.Create(i, w.Item1)); } if (!ad || p[w.Item1].Count == 1) ne.Add(Tuple.Create(w.Item1, w.Item2, 1)); if (ad) { s.Pop(); ne.Add(Tuple.Create(w.Item1, w.Item2, -1)); } } e = ne.ToArray(); euler = true; } return e; }
            public long LCA(long u, long v) { if (!lca) { l = 0; while (N > (1 << l)) l++; d = new int[N]; pr = Repeat(0, l).Select(_ => new long[N]).ToArray(); d[r] = 0; pr[0][r] = -1; var q = new Stack<long>(); q.Push(r); while (q.Count > 0) { var w = q.Pop(); foreach (var i in p[w]) { if (i == pr[0][w]) continue; q.Push(i); d[i] = d[w] + 1; pr[0][i] = w; } } for (var k = 0; k + 1 < l; k++) for (var w = 0; w < N; w++) if (pr[k][w] < 0) pr[k + 1][w] = -1; else pr[k + 1][w] = pr[k][pr[k][w]]; lca = true; } if (d[u] > d[v]) { var t = u; u = v; v = t; } for (var k = 0; k < l; k++) if ((((d[v] - d[u]) >> k) & 1) != 0) v = pr[k][v]; if (u == v) return u; for (var k = l - 1; k >= 0; k--) if (pr[k][u] != pr[k][v]) { u = pr[k][u]; v = pr[k][v]; } return pr[0][u]; }
        }
        class BT<T> where T : IComparable
        {
            class Node { public Node l; public Node r; public T v; public bool b; public int c; }
            Comparison<T> c; Node r; bool ch; T lm;
            public BT(Comparison<T> _c) { c = _c; }
            public BT() : this((x, y) => x.CompareTo(y)) { }
            bool R(Node n) => n != null && !n.b;
            bool B(Node n) => n != null && n.b;
            long C(Node n) => n?.c ?? 0;
            Node RtL(Node n) { Node m = n.r, t = m.l; m.l = n; n.r = t; n.c -= m.c - (t?.c ?? 0); m.c += n.c - (t?.c ?? 0); return m; }
            Node RtR(Node n) { Node m = n.l, t = m.r; m.r = n; n.l = t; n.c -= m.c - (t?.c ?? 0); m.c += n.c - (t?.c ?? 0); return m; }
            Node RtLR(Node n) { n.l = RtL(n.l); return RtR(n); }
            Node RtRL(Node n) { n.r = RtR(n.r); return RtL(n); }
            public void Add(T x) { r = A(r, x); r.b = true; }
            Node A(Node n, T x) { if (n == null) { ch = true; return new Node() { v = x, c = 1 }; } if (c(x, n.v) < 0) n.l = A(n.l, x); else n.r = A(n.r, x); n.c++; return Bl(n); }
            Node Bl(Node n) { if (!ch) return n; if (!B(n)) return n; if (R(n.l) && R(n.l.l)) { n = RtR(n); n.l.b = true; } else if (R(n.l) && R(n.l.r)) { n = RtLR(n); n.l.b = true; } else if (R(n.r) && R(n.r.l)) { n = RtRL(n); n.r.b = true; } else if (R(n.r) && R(n.r.r)) { n = RtL(n); n.r.b = true; } else ch = false; return n; }
            public void Remove(T x) { r = Rm(r, x); if (r != null) r.b = true; }
            Node Rm(Node n, T x) { if (n == null) { ch = false; return n; } n.c--; var r = c(x, n.v); if (r < 0) { n.l = Rm(n.l, x); return BlL(n); } if (r > 0) { n.r = Rm(n.r, x); return BlR(n); } if (n.l == null) { ch = n.b; return n.r; } n.l = RmM(n.l); n.v = lm; return BlL(n); }
            Node RmM(Node n) { n.c--; if (n.r != null) { n.r = RmM(n.r); return BlR(n); } lm = n.v; ch = n.b; return n.l; }
            Node BlL(Node n) { if (!ch) return n; if (B(n.r) && R(n.r.l)) { var b = n.b; n = RtRL(n); n.b = b; n.l.b = true; ch = false; } else if (B(n.r) && R(n.r.r)) { var b = n.b; n = RtL(n); n.b = b; n.r.b = true; n.l.b = true; ch = false; } else if (B(n.r)) { ch = n.b; n.b = true; n.r.b = false; } else { n = RtL(n); n.b = true; n.l.b = false; n.l = BlL(n.l); ch = false; } return n; }
            Node BlR(Node n) { if (!ch) return n; if (B(n.l) && R(n.l.r)) { var b = n.b; n = RtLR(n); n.b = b; n.r.b = true; ch = false; } else if (B(n.l) && R(n.l.l)) { var b = n.b; n = RtR(n); n.b = b; n.l.b = true; n.r.b = true; ch = false; } else if (B(n.l)) { ch = n.b; n.b = true; n.l.b = false; } else { n = RtR(n); n.b = true; n.r.b = false; n.r = BlR(n.r); ch = false; } return n; }
            public T this[long i] { get { return At(r, i); } }
            T At(Node n, long i) { if (n == null) return default(T); if (n.l == null) if (i == 0) return n.v; else return At(n.r, i - 1); if (n.l.c == i) return n.v; if (n.l.c > i) return At(n.l, i); return At(n.r, i - n.l.c - 1); }
            public bool Have(T x) { var t = FindUpper(x); return t < C(r) && c(At(r, t), x) == 0; }
            public long FindUpper(T x, bool allowSame = true) => allowSame ? FL(r, x) + 1 : FU(r, x);
            long FU(Node n, T x) { if (n == null) return 0; var r = c(x, n.v); if (r < 0) return FU(n.l, x); return C(n.l) + 1 + FU(n.r, x); }
            public long FindLower(T x, bool allowSame = true) { var t = FL(r, x); if (allowSame) return t + 1 < C(r) && c(At(r, t + 1), x) == 0 ? t + 1 : t < 0 ? C(r) : t; return t < 0 ? C(r) : t; }
            long FL(Node n, T x) { if (n == null) return -1; var r = c(x, n.v); if (r > 0) return C(n.l) + 1 + FL(n.r, x); return FL(n.l, x); }
            public T Min() { Node n = r, p = null; while (n != null) { p = n; n = n.l; } return p == null ? default(T) : p.v; }
            public T Max() { Node n = r, p = null; while (n != null) { p = n; n = n.r; } return p == null ? default(T) : p.v; }
            public bool Any() => r != null;
            public long Count() => C(r);
            public IEnumerable<T> List() => L(r);
            IEnumerable<T> L(Node n) { if (n == null) yield break; foreach (var i in L(n.l)) yield return i; yield return n.v; foreach (var i in L(n.r)) yield return i; }
        }
        class Dict<K, V> : Dictionary<K, V>
        {
            Func<K, V> d;
            public Dict(Func<K, V> _d) { d = _d; }
            public Dict() : this(_ => default(V)) { }
            new public V this[K i] { get { V v; return TryGetValue(i, out v) ? v : base[i] = d(i); } set { base[i] = value; } }
            public override int GetHashCode() { var ret = 0; for (var e = GetEnumerator(); e.MoveNext();) { ret ^= e.Current.Key.GetHashCode(); ret ^= e.Current.Value.GetHashCode(); } return ret; }
            public override bool Equals(object obj) { var o = (Dict<K, V>)obj; foreach (var kv in o) { if (!ContainsKey(kv.Key) || !this[kv.Key].Equals(kv.Value)) return false; } return o.Count == Count; }
        }
        class Deque<T>
        {
            T[] b; int o, c;
            public int Count;
            public T this[int i] { get { return b[gi(i)]; } set { b[gi(i)] = value; } }
            public Deque(int cap = 16) { b = new T[c = cap]; }
            int gi(int i) { if (i >= c) throw new Exception(); var r = o + i; return r >= c ? r - c : r; }
            public void PushFront(T x) { if (Count == c) e(); if (--o < 0) o += b.Length; b[o] = x; ++Count; }
            public T PopFront() { if (Count-- == 0) throw new Exception(); var r = b[o++]; if (o >= c) o -= c; return r; }
            public T Front => b[o];
            public void PushBack(T x) { if (Count == c) e(); var i = o + Count++; b[i >= c ? i - c : i] = x; }
            public T PopBack() { if (Count == 0) throw new Exception(); return b[gi(--Count)]; }
            public T Back => b[gi(Count - 1)];
            void e() { T[] nb = new T[c << 1]; if (o > c - Count) { var l = b.Length - o; Array.Copy(b, o, nb, 0, l); Array.Copy(b, 0, nb, l, Count - l); } else Array.Copy(b, o, nb, 0, Count); b = nb; o = 0; c <<= 1; }
            public void Insert(int i, T x) { if (i > Count) throw new Exception(); this.PushFront(x); for (int j = 0; j < i; j++) this[j] = this[j + 1]; this[i] = x; }
            public T RemoveAt(int i) { if (i < 0 || i >= Count) throw new Exception(); var r = this[i]; for (int j = i; j > 0; j--) this[j] = this[j - 1]; this.PopFront(); return r; }
        }
        class SegTree<T>
        {
            int n; T ti; Func<T, T, T> f; T[] dat;
            public SegTree(long _n, T _ti, Func<T, T, T> _f) { n = 1; while (n < _n) n <<= 1; ti = _ti; f = _f; dat = Repeat(ti, n << 1).ToArray(); for (var i = n - 1; i > 0; i--) dat[i] = f(dat[(i << 1) | 0], dat[(i << 1) | 1]); }
            public SegTree(List<T> l, T _ti, Func<T, T, T> _f) : this(l.Count, _ti, _f) { for (var i = 0; i < l.Count; i++) dat[n + i] = l[i]; for (var i = n - 1; i > 0; i--) dat[i] = f(dat[(i << 1) | 0], dat[(i << 1) | 1]); }
            public void Update(long i, T v) { dat[i += n] = v; while ((i >>= 1) > 0) dat[i] = f(dat[(i << 1) | 0], dat[(i << 1) | 1]); }
            public T Query(long l, long r) { var vl = ti; var vr = ti; for (long li = n + l, ri = n + r; li < ri; li >>= 1, ri >>= 1) { if ((li & 1) == 1) vl = f(vl, dat[li++]); if ((ri & 1) == 1) vr = f(dat[--ri], vr); } return f(vl, vr); }
            public T this[long idx] { get { return dat[idx + n]; } set { Update(idx, value); } }
        }
        class LazySegTree<T, E>
        {
            int n, height; T ti; E ei; Func<T, T, T> f; Func<T, E, T> g; Func<E, E, E> h; T[] dat; E[] laz;
            public LazySegTree(long _n, T _ti, E _ei, Func<T, T, T> _f, Func<T, E, T> _g, Func<E, E, E> _h) { n = 1; height = 0; while (n < _n) { n <<= 1; ++height; } ti = _ti; ei = _ei; f = _f; g = _g; h = _h; dat = Repeat(ti, n << 1).ToArray(); laz = Repeat(ei, n << 1).ToArray(); for (var i = n - 1; i > 0; i--) dat[i] = f(dat[(i << 1) | 0], dat[(i << 1) | 1]); }
            public LazySegTree(List<T> l, T _ti, E _ei, Func<T, T, T> _f, Func<T, E, T> _g, Func<E, E, E> _h) : this(l.Count, _ti, _ei, _f, _g, _h) { for (var i = 0; i < l.Count; i++) dat[n + i] = l[i]; for (var i = n - 1; i > 0; i--) dat[i] = f(dat[(i << 1) | 0], dat[(i << 1) | 1]); }
            T Reflect(long i) => laz[i].Equals(ei) ? dat[i] : g(dat[i], laz[i]);
            void Eval(long i) { if (laz[i].Equals(ei)) return; laz[(i << 1) | 0] = h(laz[(i << 1) | 0], laz[i]); laz[(i << 1) | 1] = h(laz[(i << 1) | 1], laz[i]); dat[i] = Reflect(i); laz[i] = ei; }
            void Thrust(long i) { for (var j = height; j > 0; j--) Eval(i >> j); }
            void Recalc(long i) { while ((i >>= 1) > 0) dat[i] = f(Reflect((i << 1) | 0), Reflect((i << 1) | 1)); }
            public void Update(long l, long r, E v) { Thrust(l += n); Thrust(r += n - 1); for (long li = l, ri = r + 1; li < ri; li >>= 1, ri >>= 1) { if ((li & 1) == 1) { laz[li] = h(laz[li], v); ++li; } if ((ri & 1) == 1) { --ri; laz[ri] = h(laz[ri], v); } } Recalc(l); Recalc(r); }
            public T Query(long l, long r) { Thrust(l += n); Thrust(r += n - 1); var vl = ti; var vr = ti; for (long li = l, ri = r + 1; li < ri; li >>= 1, ri >>= 1) { if ((li & 1) == 1) vl = f(vl, Reflect(li++)); if ((ri & 1) == 1) vr = f(Reflect(--ri), vr); } return f(vl, vr); }
            public T this[long idx] { get { Thrust(idx += n); return dat[idx] = Reflect(idx); } set { Thrust(idx += n); dat[idx] = value; laz[idx] = ei; Recalc(idx); } }
        }
        class SlidingWindowAggregation<T>
        {
            T[][] l; T[][] a; int[] n; Func<T, T, T> f;
            public SlidingWindowAggregation(IEnumerable<T> ary, Func<T, T, T> _f) { l = new T[2][]; a = new T[2][]; n = new int[2]; f = _f; l[0] = new T[16]; a[0] = new T[16]; n[0] = 0; if (ary.Any()) { var t = ary.ToArray(); n[1] = t.Length; l[1] = new T[n[1]]; a[1] = new T[n[1]]; for (var i = 0; i < l[1].Length; i++) { l[1][i] = t[i]; if (i == 0) a[1][i] = t[i]; else a[1][i] = this.f(a[1][i - 1], t[i]); } } else { l[1] = new T[16]; a[1] = new T[16]; n[1] = 0; } }
            public SlidingWindowAggregation(Func<T, T, T> f) : this(new T[0], f) { }
            public int Count => n[0] + n[1];
            void Push(int la, T v) { if (l[la].Length == n[la]) { var nar = new T[n[la] * 2]; var nag = new T[n[la] * 2]; Array.Copy(l[la], nar, n[la]); Array.Copy(a[la], nag, n[la]); l[la] = nar; a[la] = nag; } if (n[la] == 0) a[la][0] = v; else a[la][n[la]] = la == 0 ? f(v, a[la][n[la] - 1]) : f(a[la][n[la] - 1], v); l[la][n[la]++] = v; }
            public void PushBack(T val) => Push(1, val);
            public void PushFront(T val) => Push(0, val);
            public T Pop(int la) { var lb = 1 - la; if (n[la] == 0) { if (n[lb] == 0) throw new Exception(); var m = (n[lb] - 1) / 2; if (l[la].Length <= m) { l[la] = new T[m + 1]; a[la] = new T[m + 1]; } n[la] = 0; for (var i = m; i >= 0; i--) { if (n[la] == 0) a[la][n[la]] = l[lb][i]; else a[la][n[la]] = la == 0 ? f(l[lb][i], a[la][n[la] - 1]) : f(a[la][n[la] - 1], l[lb][i]); l[la][n[la]++] = l[lb][i]; } for (var i = m + 1; i < n[lb]; i++) { var j = i - m - 1; if (j == 0) a[lb][j] = l[lb][i]; else a[lb][j] = la == 0 ? f(l[lb][i], a[lb][j - 1]) : f(a[lb][j - 1], l[lb][i]); l[lb][j] = l[lb][i]; } n[lb] -= n[la]; } return l[la][--n[la]]; }
            public T PopBack() => Pop(1);
            public T PopFront() => Pop(0);
            public T Aggregate() { if (n[0] == 0 && n[1] == 0) throw new Exception(); else if (n[1] == 0) return a[0][n[0] - 1]; else if (n[0] == 0) return a[1][n[1] - 1]; else return f(a[0][n[0] - 1], a[1][n[1] - 1]); }
        }
    }
}