#877485 (C#) No.2337 Equidistant

提出ソース

結果

問題	No.2337 Equidistant
ユーザー	takytank
提出日時	2023-06-02 23:19:38
言語	C# (.NET 8.0.203)
結果	AC
実行時間	1,162 ms / 4,000 ms
コード長	43,984 bytes
コンパイル時間	10,235 ms
コンパイル使用メモリ	169,576 KB
実行使用メモリ	295,512 KB
最終ジャッジ日時	2024-06-09 01:25:35
合計ジャッジ時間	30,367 ms
ジャッジサーバーID （参考情報）	judge3 / judge4

このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示

入力	結果	実行時間実行使用メモリ
testcase_00	AC	75 ms 34,688 KB
testcase_01	AC	71 ms 34,944 KB
testcase_02	AC	68 ms 34,944 KB
testcase_03	AC	74 ms 34,816 KB
testcase_04	AC	73 ms 34,944 KB
testcase_05	AC	74 ms 34,800 KB
testcase_06	AC	78 ms 35,584 KB
testcase_07	AC	78 ms 35,584 KB
testcase_08	AC	77 ms 35,584 KB
testcase_09	AC	78 ms 35,712 KB
testcase_10	AC	81 ms 35,584 KB
testcase_11	AC	831 ms 116,864 KB
testcase_12	AC	859 ms 117,120 KB
testcase_13	AC	891 ms 116,864 KB
testcase_14	AC	842 ms 117,120 KB
testcase_15	AC	819 ms 116,860 KB
testcase_16	AC	843 ms 116,852 KB
testcase_17	AC	861 ms 116,608 KB
testcase_18	AC	857 ms 116,992 KB
testcase_19	AC	832 ms 116,992 KB
testcase_20	AC	817 ms 116,836 KB
testcase_21	AC	784 ms 143,488 KB
testcase_22	AC	800 ms 132,480 KB
testcase_23	AC	952 ms 127,588 KB
testcase_24	AC	1,120 ms 129,408 KB
testcase_25	AC	951 ms 127,744 KB
testcase_26	AC	1,162 ms 129,136 KB
testcase_27	AC	1,025 ms 131,476 KB
testcase_28	AC	1,116 ms 295,512 KB

権限があれば一括ダウンロードができます

コンパイルメッセージ

  復元対象のプロジェクトを決定しています...
  /home/judge/data/code/main.csproj を復元しました (93 ms)。
MSBuild のバージョン 17.9.6+a4ecab324 (.NET)
  main -> /home/judge/data/code/bin/Release/net8.0/main.dll
  main -> /home/judge/data/code/bin/Release/net8.0/publish/

ソースコード

raw source code

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;

namespace YukiCoder
{
	class Program
	{
		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		static void Main()
		{
			using var cin = new Scanner();
			var (n, q) = cin.Int2();
			var la = new LevelAncestor(n);
			var edges = new JagList2<int>(n);
			
			var ab = new (int a, int b)[n - 1];
			//var uf = new UnionFindTree(n);
			//var sp = new ShortestPath(n);
			//var rnd = new Random();
			for (int i = 0; i < n - 1; i++) {
				var (a, b) = cin.Int2(-1);
				/*
				int a = rnd.Next(0, n);
				int b = rnd.Next(0, n);
				while (uf.IsUnited(a, b)) {
					b = rnd.Next(0, n);
				}

				uf.Unite(a, b);
				*/

				ab[i] = (a, b);
			}

			for (int i = 0; i < n - 1; i++) {
				var (a, b) = ab[i];
				la.AddEdge2W(a, b);
				edges.Add(a, b);
				edges.Add(b, a);
				//sp.AddEdge2W(a, b);
			}

			la.Build();
			edges.Build();
			//sp.Build();

			var counts = new int[n];

			int Dfs(int v, int p)
			{
				int ret = 1;
				foreach (var next in edges[v]) {
					if (next == p) {
						continue;
					}

					ret += Dfs(next, v);
				}

				counts[v] = ret;
				return ret;
			}

			Dfs(0, -1);

			var st = new (int s, int t)[q];
			for (int i = 0; i < q; i++) {
				st[i] = cin.Int2(-1);
				/*
				int s = rnd.Next(0, n);
				int t = rnd.Next(0, n);
				while (s == t) {
					t = rnd.Next(0, n);
				}

				st[i] = (s, t);*/
			}

			for (int i = 0; i < q; i++) {
				var (s, t) = st[i];
				int lca = la.Lca(s, t);
				
				int ds = la.Depth(s);
				int dt = la.Depth(t);
				int dc = la.Depth(lca);
				
				int ans = 0;
				int dist = la.Distance(s, t);

				if (ds == dt) {
					ans += n - counts[lca];

					int ss = la.Next(lca, s, 1);
					int tt = la.Next(lca, t, 1);
					int temp = counts[lca] - counts[ss] - counts[tt];
					ans += temp;
				} else if (dist % 2 == 0) {
					int v = s;
					if (dt > ds) {
						v = t;
					}

					int dd = dist / 2;
					int p = la.Up(v, dd);
					int w = la.Next(p, v, 1);

					int temp = counts[p] - counts[w];
					ans += temp;
				}

				Console.WriteLine(ans);
				/*
				int ans2 = 0;
				var distsS = sp.Bfs(s);
				var distsT = sp.Bfs(t);
				for (int j = 0; j < n; j++) {
					if (distsS[j] == distsT[j]) {
						++ans2;
					}
				}

				
				if (ans != ans2) {
					Console.Write("");
				}*/
			}
		}
	}

	public class ShortestPath
	{
		private readonly int n_;
		private readonly List<(int to, long d)>[] tempEdges_;
		private readonly (int to, long d)[][] edges_;

		public ShortestPath(int n)
		{
			n_ = n;
			edges_ = new (int to, long d)[n][];
			tempEdges_ = new List<(int v, long d)>[n];
			for (int i = 0; i < n; i++) {
				tempEdges_[i] = new List<(int v, long d)>();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AddEdge(int p, int q, long d = 1) => tempEdges_[p].Add((q, d));
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AddEdge2W(int u, int v, long d = 1)
		{
			tempEdges_[u].Add((v, d));
			tempEdges_[v].Add((u, d));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Build()
		{
			for (int i = 0; i < n_; i++) {
				edges_[i] = tempEdges_[i].ToArray();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlySpan<(int to, long d)> GetEdge(int i) => edges_[i].AsSpan();

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlySpan<int> GetPath(int s, int t, int[] prevs)
		{
			var path = new List<int> { t };
			int cur = t;
			while (cur != s) {
				cur = prevs[cur];
				path.Add(cur);
			}

			path.Reverse();
			return path.ToArray().AsSpan();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public long[] Bfs(int start, long inf = long.MaxValue)
		{
			var distances = new long[n_];
			distances.AsSpan().Fill(inf);
			distances[start] = 0;
			var que = new Queue<int>();
			que.Enqueue(start);
			while (que.Count > 0) {
				var cur = que.Dequeue();
				foreach (var (to, d) in edges_[cur]) {
					long nextDistance = distances[cur] + d;
					if (nextDistance < distances[to]) {
						distances[to] = nextDistance;
						que.Enqueue(to);
					}
				}
			}

			return distances;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (long[] distances, int[] prevs) BfsWithPath(int start, long inf = long.MaxValue)
		{
			var distances = new long[n_];
			distances.AsSpan().Fill(inf);
			distances[start] = 0;
			var prevs = new int[n_].Fill(-1);
			var que = new Queue<int>();
			que.Enqueue(start);
			while (que.Count > 0) {
				var cur = que.Dequeue();
				foreach (var (to, d) in edges_[cur]) {
					long nextDistance = distances[cur] + d;
					if (nextDistance < distances[to]) {
						distances[to] = nextDistance;
						prevs[to] = cur;
						que.Enqueue(to);
					}
				}
			}

			return (distances, prevs);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public long[] Bfs01(int start, long inf = long.MaxValue)
		{
			var distances = new long[n_];
			distances.AsSpan().Fill(inf);
			distances[start] = 0;
			var que0 = new Queue<(int v, long distance)>();
			var que1 = new Queue<(int v, long distance)>();
			que0.Enqueue((start, 0));
			while (que0.Count > 0 || que1.Count > 0) {
				var (v, distance) = que0.Count > 0
					 ? que0.Dequeue()
					 : que1.Dequeue();
				if (distance > distances[v]) {
					continue;
				}

				foreach (var (to, d) in edges_[v]) {
					long nextDistance = distances[v] + d;
					if (nextDistance < distances[to]) {
						distances[to] = nextDistance;
						if (d == 0) {
							que0.Enqueue((to, nextDistance));
						} else {
							que1.Enqueue((to, nextDistance));
						}
					}
				}
			}

			return distances;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (long[] distances, int[] prevs) Bfs01WithPath(int start, long inf = long.MaxValue)
		{
			var distances = new long[n_];
			distances.AsSpan().Fill(inf);
			distances[start] = 0;
			var prevs = new int[n_].Fill(-1);
			var que0 = new Queue<(int v, long distance)>();
			var que1 = new Queue<(int v, long distance)>();
			que0.Enqueue((start, 0));
			while (que0.Count > 0 || que1.Count > 0) {
				var (v, distance) = que0.Count > 0
					 ? que0.Dequeue()
					 : que1.Dequeue();
				if (distance > distances[v]) {
					continue;
				}

				foreach (var (to, d) in edges_[v]) {
					long nextDistance = distances[v] + d;
					if (nextDistance < distances[to]) {
						distances[to] = nextDistance;
						prevs[to] = v;
						if (d == 0) {
							que0.Enqueue((to, nextDistance));
						} else {
							que1.Enqueue((to, nextDistance));
						}
					}
				}
			}

			return (distances, prevs);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (long[] distances, bool existsNegativeCycle) BellmanFord(
			int start, long inf = long.MaxValue)
		{
			var distances = new long[n_];
			distances.AsSpan().Fill(inf);
			distances[start] = 0;

			bool existsNegativeCycle = false;
			for (int i = 0; i < n_; i++) {
				bool changes = false;
				for (int v = 0; v < n_; v++) {
					if (distances[v] == inf) {
						continue;
					}

					foreach (var (to, d) in edges_[v]) {
						long newDistance = distances[v] + d;
						if (newDistance < distances[to]) {
							changes = true;
							distances[to] = newDistance;
						}
					}
				}

				if (i == n_ - 1) {
					existsNegativeCycle = changes;
				}

				if (changes == false) {
					break;
				}
			}

			return (distances, existsNegativeCycle);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (long[] distances, bool existsNegativeCycle, int[] prevs) BellmanFordWithPath(
			int start, long inf = long.MaxValue)
		{
			var distances = new long[n_];
			distances.AsSpan().Fill(inf);
			distances[start] = 0;
			var prevs = new int[n_].Fill(-1);

			bool existsNegativeCycle = false;
			for (int i = 0; i < n_; i++) {
				bool changes = false;
				for (int v = 0; v < n_; v++) {
					if (distances[v] == inf) {
						continue;
					}

					foreach (var (to, d) in edges_[v]) {
						long newDistance = distances[v] + d;
						if (newDistance < distances[to]) {
							changes = true;
							distances[to] = newDistance;
							prevs[to] = v;
						}
					}
				}

				if (i == n_ - 1) {
					existsNegativeCycle = changes;
				}

				if (changes == false) {
					break;
				}
			}

			return (distances, existsNegativeCycle, prevs);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public long[] Dijkstra(int start, long inf = long.MaxValue)
		{
			var distances = new long[n_];
			distances.AsSpan().Fill(inf);
			distances[start] = 0;
			var que = new DijkstraQ();
			que.Enqueue(0, start);
			while (que.Count > 0) {
				var (distance, v) = que.Dequeue();
				if (distance > distances[v]) {
					continue;
				}

				foreach (var (to, d) in edges_[v]) {
					long nextDistance = distances[v] + d;
					if (nextDistance < distances[to]) {
						distances[to] = nextDistance;
						que.Enqueue(nextDistance, to);
					}
				}
			}

			return distances;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (long[] distances, int[] prevs) DijkstraWithPath(int start, long inf = long.MaxValue)
		{
			var distances = new long[n_];
			distances.AsSpan().Fill(inf);
			distances[start] = 0;
			var prevs = new int[n_].Fill(-1);
			var que = new DijkstraQ();
			que.Enqueue(0, start);
			while (que.Count > 0) {
				var (distance, v) = que.Dequeue();
				if (distance > distances[v]) {
					continue;
				}

				foreach (var (to, d) in edges_[v]) {
					long nextDistance = distances[v] + d;
					if (nextDistance < distances[to]) {
						distances[to] = nextDistance;
						prevs[to] = v;
						que.Enqueue(nextDistance, to);
					}
				}
			}

			return (distances, prevs);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public long[,] WarshallFloyd(long inf = long.MaxValue / 2)
		{
			var distances = new long[n_, n_];
			for (int i = 0; i < n_; ++i) {
				for (int j = 0; j < n_; ++j) {
					if (i != j) {
						distances[i, j] = inf;
					}
				}
			}

			for (int i = 0; i < n_; i++) {
				foreach (var (j, d) in edges_[i]) {
					distances[i, j] = Math.Min(distances[i, j], d);
				}
			}

			for (int k = 0; k < n_; k++) {
				for (int i = 0; i < n_; i++) {
					for (int j = 0; j < n_; j++) {
						distances[i, j] = Math.Min(
							distances[i, j],
							distances[i, k] + distances[k, j]);
					}
				}
			}

			return distances;
		}
	}

	public class UnionFindTree
	{
		private readonly int[] data_;

		public int Count => data_.Length;
		public int GroupCount { get; private set; }

		public UnionFindTree(int count)
		{
			data_ = new int[count];
			for (int i = 0; i < count; i++) {
				data_[i] = -1;
			}

			GroupCount = count;
		}

		public int GetSizeOf(int k) => -data_[Find(k)];

		public bool IsUnited(int x, int y) => Find(x) == Find(y);
		public bool Unite(int x, int y)
		{
			x = Find(x);
			y = Find(y);
			if (x == y) {
				return false;
			}

			if (data_[x] > data_[y]) {
				(x, y) = (y, x);
			}

			--GroupCount;
			data_[x] += data_[y];
			data_[y] = x;
			return true;
		}

		public int Find(int k)
		{
			while (data_[k] >= 0) {
				if (data_[data_[k]] >= 0) {
					data_[k] = data_[data_[k]];
				}

				k = data_[k];
			}

			return k;
		}

		public IEnumerable<int> GetAllRoots()
		{
			for (int i = 0; i < data_.Length; i++) {
				if (data_[i] < 0) {
					yield return i;
				}
			}
		}
	}

	public class LevelAncestor
	{
		private readonly List<int>[] _edges;
		private readonly int[,] _parents;
		private readonly List<List<int>> _lad;

		private readonly int[] _depth;
		private readonly int[] _next;
		private readonly int[] _length;
		private readonly int[] _path;
		private readonly int[] _order;
		private readonly int[] _hs;

		public LevelAncestor(int n)
		{
			_edges = new List<int>[n];
			for (int i = 0; i < n; ++i) {
				_edges[i] = new List<int>();
			}

			_lad = new List<List<int>>();

			_depth = new int[n];
			_next = new int[n];
			_next.AsSpan().Fill(-1);
			_length = new int[n];
			_path = new int[n];
			_order = new int[n];
			_hs = new int[n + 1];

			int h = 1;
			while ((1 << h) <= n) {
				++h;
			}

			_parents = new int[h, n];
			MemoryMarshal.CreateSpan<int>(ref _parents[0, 0], _parents.Length).Fill(-1);
			for (int i = 2; i <= n; ++i) {
				_hs[i] = _hs[i >> 1] + 1;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AddEdge2W(int u, int v)
		{
			_edges[u].Add(v);
			_edges[v].Add(u);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Dfs(int v, int p, int d, bool isFirst)
		{
			if (_next[v] < 0) {
				_next[v] = v;
				_parents[0, v] = p;
				_length[v] = d;
				_depth[v] = d;
				foreach (int u in _edges[v]) {
					if (u == p) {
						continue;
					}

					Dfs(u, v, d + 1, false);
					if (_length[v] < _length[u]) {
						_next[v] = u;
						_length[v] = _length[u];
					}
				}
			}

			if (isFirst == false) {
				return;
			}

			_path[v] = _lad.Count;
			_lad.Add(new List<int>());
			for (int k = v; ; k = _next[k]) {
				_lad[^1].Add(k);
				_path[k] = _path[v];
				if (k == _next[k]) {
					break;
				}
			}

			for (; ; p = v, v = _next[v]) {
				foreach (var u in _edges[v]) {
					if (u != p && u != _next[v]) {
						Dfs(u, v, d + 1, true);
					}
				}

				if (v == _next[v]) {
					break;
				}
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Build(int root = 0)
		{
			int n = _edges.Length;
			Dfs(root, -1, 0, true);
			for (int k = 0; k + 1 < _parents.GetLength(0); ++k) {
				for (int v = 0; v < n; ++v) {
					if (_parents[k, v] < 0) {
						_parents[k + 1, v] = -1;
					} else {
						_parents[k + 1, v] = _parents[k, _parents[k, v]];
					}
				}
			}

			for (int i = 0; i < _lad.Count; ++i) {
				int v = _lad[i][0];
				int p = _parents[0, v];
				if (~p != 0) {
					int k = _path[p];
					int l = Math.Min(_order[p] + 1, _lad[i].Count);
					_lad[i].AddRange(Enumerable.Repeat(0, l));
					for (int j = 0, m = _lad[i].Count; j + l < m; ++j) {
						_lad[i][m - (j + 1)] = _lad[i][m - (j + l + 1)];
					}

					for (int j = 0; j < l; ++j) {
						_lad[i][j] = _lad[k][_order[p] - l + j + 1];
					}
				}

				for (int j = 0; j < _lad[i].Count; ++j) {
					if (_path[_lad[i][j]] == i) {
						_order[_lad[i][j]] = j;
					}
				}
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public int Depth(int v) => _depth[v];

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public int Lca(int u, int v)
		{
			int h = _parents.GetLength(0);

			if (_depth[u] > _depth[v]) {
				(u, v) = (v, u);
			}

			for (int k = 0; k < h; ++k) {
				if (((_depth[v] - _depth[u]) >> k & 1) != 0) {
					v = _parents[k, v];
				}
			}

			if (u == v) {
				return u;
			}

			for (int k = h - 1; k >= 0; --k) {
				if (_parents[k, u] == _parents[k, v]) {
					continue;
				}

				u = _parents[k, u];
				v = _parents[k, v];
			}

			return _parents[0, u];
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public int Distance(int u, int v) => Distance(u, v, Lca(u, v));
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private int Distance(int u, int v, int lca)
		{
			return _depth[u] + _depth[v] - _depth[lca] * 2;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public int Up(int v, int d)
		{
			if (d == 0) {
				return v;
			}

			v = _parents[_hs[d], v];
			d -= 1 << _hs[d];
			return _lad[_path[v]][_order[v] - d];
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public int Next(int u, int v)
		{
			// from u to v
			if (_depth[u] >= _depth[v]) {
				return _parents[0, u];
			}

			int l = Up(v, _depth[v] - _depth[u] - 1);
			return _parents[0, l] == u ? l : _parents[0, u];
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public int Next(int u, int v, int d)
		{
			int lca = Lca(u, v);
			if (Distance(u, v, lca) < d) {
				return -1;
			}

			int du = _depth[u] - _depth[lca];
			if (du >= d) {
				return Up(u, d);
			}

			d -= du;
			int dv = _depth[v] - _depth[lca];
			return Up(v, dv - d);
		}
	}

	public struct BitFlag
	{
		public static BitFlag Begin() => 0;
		public static BitFlag End(int bitCount) => 1 << bitCount;
		public static BitFlag FromBit(int bitNumber) => 1 << bitNumber;
		public static BitFlag Fill(int count) => (1 << count) - 1;

		public static IEnumerable<BitFlag> All(int n)
		{
			for (var f = Begin(); f < End(n); ++f) {
				yield return f;
			}
		}

		private readonly int flags_;
		public int Flag => flags_;
		public bool this[int bitNumber] => (flags_ & (1 << bitNumber)) != 0;
		public BitFlag(int flags) { flags_ = flags; }

		public bool Has(BitFlag target) => (flags_ & target.flags_) == target.flags_;
		public bool Has(int target) => (flags_ & target) == target;
		public bool HasBit(int bitNumber) => (flags_ & (1 << bitNumber)) != 0;
		public BitFlag OrBit(int bitNumber) => flags_ | (1 << bitNumber);
		public BitFlag AndBit(int bitNumber) => flags_ & (1 << bitNumber);
		public BitFlag XorBit(int bitNumber) => flags_ ^ (1 << bitNumber);
		public BitFlag ComplementOf(BitFlag sub) => flags_ ^ sub.flags_;
		public int PopCount() => BitOperations.PopCount((uint)flags_);

		public static BitFlag operator ++(BitFlag src) => new BitFlag(src.flags_ + 1);
		public static BitFlag operator --(BitFlag src) => new BitFlag(src.flags_ - 1);
		public static BitFlag operator |(BitFlag lhs, BitFlag rhs)
			=> new BitFlag(lhs.flags_ | rhs.flags_);
		public static BitFlag operator |(BitFlag lhs, int rhs)
			=> new BitFlag(lhs.flags_ | rhs);
		public static BitFlag operator |(int lhs, BitFlag rhs)
			=> new BitFlag(lhs | rhs.flags_);
		public static BitFlag operator &(BitFlag lhs, BitFlag rhs)
			=> new BitFlag(lhs.flags_ & rhs.flags_);
		public static BitFlag operator &(BitFlag lhs, int rhs)
			=> new BitFlag(lhs.flags_ & rhs);
		public static BitFlag operator &(int lhs, BitFlag rhs)
			=> new BitFlag(lhs & rhs.flags_);
		public static BitFlag operator ^(BitFlag lhs, BitFlag rhs)
			=> new BitFlag(lhs.flags_ ^ rhs.flags_);
		public static BitFlag operator ^(BitFlag lhs, int rhs)
			=> new BitFlag(lhs.flags_ ^ rhs);
		public static BitFlag operator ^(int lhs, BitFlag rhs)
			=> new BitFlag(lhs ^ rhs.flags_);
		public static BitFlag operator <<(BitFlag bit, int shift) => bit.flags_ << shift;
		public static BitFlag operator >>(BitFlag bit, int shift) => bit.flags_ >> shift;

		public static bool operator <(BitFlag lhs, BitFlag rhs) => lhs.flags_ < rhs.flags_;
		public static bool operator <(BitFlag lhs, int rhs) => lhs.flags_ < rhs;
		public static bool operator <(int lhs, BitFlag rhs) => lhs < rhs.flags_;
		public static bool operator >(BitFlag lhs, BitFlag rhs) => lhs.flags_ > rhs.flags_;
		public static bool operator >(BitFlag lhs, int rhs) => lhs.flags_ > rhs;
		public static bool operator >(int lhs, BitFlag rhs) => lhs > rhs.flags_;
		public static bool operator <=(BitFlag lhs, BitFlag rhs) => lhs.flags_ <= rhs.flags_;
		public static bool operator <=(BitFlag lhs, int rhs) => lhs.flags_ <= rhs;
		public static bool operator <=(int lhs, BitFlag rhs) => lhs <= rhs.flags_;
		public static bool operator >=(BitFlag lhs, BitFlag rhs) => lhs.flags_ >= rhs.flags_;
		public static bool operator >=(BitFlag lhs, int rhs) => lhs.flags_ >= rhs;
		public static bool operator >=(int lhs, BitFlag rhs) => lhs >= rhs.flags_;

		public static implicit operator BitFlag(int t) => new BitFlag(t);
		public static implicit operator int(BitFlag t) => t.flags_;

		public override string ToString() => $"{Convert.ToString(flags_, 2).PadLeft(32, '0')} ({flags_})";

		public SubBitsEnumerator SubBits => new SubBitsEnumerator(flags_);
		public struct SubBitsEnumerator : IEnumerable<BitFlag>
		{
			private readonly int flags_;
			public SubBitsEnumerator(int flags)
			{
				flags_ = flags;
			}

			IEnumerator<BitFlag> IEnumerable<BitFlag>.GetEnumerator() => new Enumerator(flags_);
			IEnumerator IEnumerable.GetEnumerator() => new Enumerator(flags_);
			public Enumerator GetEnumerator() => new Enumerator(flags_);
			public struct Enumerator : IEnumerator<BitFlag>
			{
				private readonly int src_;
				public BitFlag Current { get; private set; }
				object IEnumerator.Current => Current;

				public Enumerator(int flags)
				{
					src_ = flags;
					Current = flags + 1;
				}

				public void Dispose() { }
				[MethodImpl(MethodImplOptions.AggressiveInlining)]
				public bool MoveNext() => (Current = --Current & src_) > 0;
				[MethodImpl(MethodImplOptions.AggressiveInlining)]
				public void Reset() => Current = src_;
			}
		}
	}

	public class HashMap<TKey, TValue> : Dictionary<TKey, TValue>
	{
		public static HashMap<TKey, TValue> Merge(
			HashMap<TKey, TValue> src1,
			HashMap<TKey, TValue> src2,
			Func<TValue, TValue, TValue> mergeValues)
		{
			if (src1.Count < src2.Count) {
				(src1, src2) = (src2, src1);
			}

			foreach (var key in src2.Keys) {
				src1[key] = mergeValues(src1[key], src2[key]);
			}

			return src1;
		}

		private readonly Func<TKey, TValue> initialzier_;
		public HashMap(Func<TKey, TValue> initialzier)
			: base()
		{
			initialzier_ = initialzier;
		}

		public HashMap(Func<TKey, TValue> initialzier, int capacity)
			: base(capacity)
		{
			initialzier_ = initialzier;
		}

		new public TValue this[TKey key]
		{
			get
			{
				if (TryGetValue(key, out TValue value)) {
					return value;
				} else {
					var init = initialzier_(key);
					base[key] = init;
					return init;
				}
			}

			set { base[key] = value; }
		}

		public HashMap<TKey, TValue> Merge(
			HashMap<TKey, TValue> src,
			Func<TValue, TValue, TValue> mergeValues)
		{
			foreach (var key in src.Keys) {
				this[key] = mergeValues(this[key], src[key]);
			}

			return this;
		}
	}

	public class JagList2<T> where T : struct
	{
		private readonly int n_;
		private readonly List<T>[] tempValues_;
		private T[][] values_;

		public int Count => n_;
		public List<T>[] Raw => tempValues_;
		public T[][] Values => values_;
		public T[] this[int index] => values_[index];

		public JagList2(int n)
		{
			n_ = n;
			tempValues_ = new List<T>[n];
			for (int i = 0; i < n; ++i) {
				tempValues_[i] = new List<T>();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Add(int i, T value) => tempValues_[i].Add(value);
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Build()
		{
			values_ = new T[n_][];
			for (int i = 0; i < values_.Length; ++i) {
				values_[i] = tempValues_[i].ToArray();
			}
		}
	}

	public class DijkstraQ
	{
		private int count_ = 0;
		private long[] distanceHeap_;
		private int[] vertexHeap_;

		public int Count => count_;
		public DijkstraQ()
		{
			distanceHeap_ = new long[8];
			vertexHeap_ = new int[8];
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Enqueue(long distance, int v)
		{
			if (distanceHeap_.Length == count_) {
				var newDistanceHeap = new long[distanceHeap_.Length << 1];
				var newVertexHeap = new int[vertexHeap_.Length << 1];
				Unsafe.CopyBlock(
					ref Unsafe.As<long, byte>(ref newDistanceHeap[0]),
					ref Unsafe.As<long, byte>(ref distanceHeap_[0]),
					(uint)(8 * count_));
				Unsafe.CopyBlock(
					ref Unsafe.As<int, byte>(ref newVertexHeap[0]),
					ref Unsafe.As<int, byte>(ref vertexHeap_[0]),
					(uint)(4 * count_));
				distanceHeap_ = newDistanceHeap;
				vertexHeap_ = newVertexHeap;
			}

			ref var dRef = ref distanceHeap_[0];
			ref var vRef = ref vertexHeap_[0];
			Unsafe.Add(ref dRef, count_) = distance;
			Unsafe.Add(ref vRef, count_) = v;
			++count_;

			int c = count_ - 1;
			while (c > 0) {
				int p = (c - 1) >> 1;
				var tempD = Unsafe.Add(ref dRef, p);
				if (tempD <= distance) {
					break;
				} else {
					Unsafe.Add(ref dRef, c) = tempD;
					Unsafe.Add(ref vRef, c) = Unsafe.Add(ref vRef, p);
					c = p;
				}
			}

			Unsafe.Add(ref dRef, c) = distance;
			Unsafe.Add(ref vRef, c) = v;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (long distance, int v) Dequeue()
		{
			ref var dRef = ref distanceHeap_[0];
			ref var vRef = ref vertexHeap_[0];
			(long distance, int v) ret = (dRef, vRef);
			int n = count_ - 1;

			var distance = Unsafe.Add(ref dRef, n);
			var vertex = Unsafe.Add(ref vRef, n);
			int p = 0;
			int c = (p << 1) + 1;
			while (c < n) {
				if (c != n - 1 && Unsafe.Add(ref dRef, c + 1) < Unsafe.Add(ref dRef, c)) {
					++c;
				}

				var tempD = Unsafe.Add(ref dRef, c);
				if (distance > tempD) {
					Unsafe.Add(ref dRef, p) = tempD;
					Unsafe.Add(ref vRef, p) = Unsafe.Add(ref vRef, c);
					p = c;
					c = (p << 1) + 1;
				} else {
					break;
				}
			}

			Unsafe.Add(ref dRef, p) = distance;
			Unsafe.Add(ref vRef, p) = vertex;
			--count_;

			return ret;
		}
	}

	public struct ModInt
	{
		public const long P = 1000000007;
		//public const long P = 998244353;
		//public const long P = 2;
		public const long ROOT = 3;

		// (924844033, 5)
		// (998244353, 3)
		// (1012924417, 5)
		// (167772161, 3)
		// (469762049, 3)
		// (1224736769, 3)

		private long value_;

		public static ModInt New(long value, bool mods) => new ModInt(value, mods);
		public ModInt(long value) => value_ = value;
		public ModInt(long value, bool mods)
		{
			if (mods) {
				value %= P;
				if (value < 0) {
					value += P;
				}
			}

			value_ = value;
		}

		public static ModInt operator +(ModInt lhs, ModInt rhs)
		{
			lhs.value_ = (lhs.value_ + rhs.value_) % P;
			return lhs;
		}
		public static ModInt operator +(long lhs, ModInt rhs)
		{
			rhs.value_ = (lhs + rhs.value_) % P;
			return rhs;
		}
		public static ModInt operator +(ModInt lhs, long rhs)
		{
			lhs.value_ = (lhs.value_ + rhs) % P;
			return lhs;
		}

		public static ModInt operator -(ModInt lhs, ModInt rhs)
		{
			lhs.value_ = (P + lhs.value_ - rhs.value_) % P;
			return lhs;
		}
		public static ModInt operator -(long lhs, ModInt rhs)
		{
			rhs.value_ = (P + lhs - rhs.value_) % P;
			return rhs;
		}
		public static ModInt operator -(ModInt lhs, long rhs)
		{
			lhs.value_ = (P + lhs.value_ - rhs) % P;
			return lhs;
		}

		public static ModInt operator *(ModInt lhs, ModInt rhs)
		{
			lhs.value_ = lhs.value_ * rhs.value_ % P;
			return lhs;
		}
		public static ModInt operator *(long lhs, ModInt rhs)
		{
			rhs.value_ = lhs * rhs.value_ % P;
			return rhs;
		}
		public static ModInt operator *(ModInt lhs, long rhs)
		{
			lhs.value_ = lhs.value_ * rhs % P;
			return lhs;
		}

		public static ModInt operator /(ModInt lhs, ModInt rhs)
			=> lhs * Inverse(rhs);

		public static implicit operator ModInt(long n) => new ModInt(n, true);

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ModInt Inverse(ModInt value) => Pow(value, P - 2);
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ModInt Pow(ModInt value, long k) => Pow(value.value_, k);
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ModInt Pow(long value, long k)
		{
			long ret = 1;
			while (k > 0) {
				if ((k & 1) != 0) {
					ret = ret * value % P;
				}

				value = value * value % P;
				k >>= 1;
			}

			return new ModInt(ret);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public long ToLong() => value_;
		public override string ToString() => value_.ToString();
	}

	public static class Helper
	{
		public static long INF => 1L << 50;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static T Clamp<T>(this T value, T min, T max) where T : struct, IComparable<T>
		{
			if (value.CompareTo(min) <= 0) {
				return min;
			}

			if (value.CompareTo(max) >= 0) {
				return max;
			}

			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void UpdateMin<T>(this ref T target, T value) where T : struct, IComparable<T>
			=> target = target.CompareTo(value) > 0 ? value : target;
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void UpdateMin<T>(this ref T target, T value, Action<T> onUpdated)
			where T : struct, IComparable<T>
		{
			if (target.CompareTo(value) > 0) {
				target = value;
				onUpdated(value);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void UpdateMax<T>(this ref T target, T value) where T : struct, IComparable<T>
			=> target = target.CompareTo(value) < 0 ? value : target;
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void UpdateMax<T>(this ref T target, T value, Action<T> onUpdated)
			where T : struct, IComparable<T>
		{
			if (target.CompareTo(value) < 0) {
				target = value;
				onUpdated(value);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long BinarySearchOKNG(long ok, long ng, Func<long, bool> satisfies)
		{
			while (ng - ok > 1) {
				long mid = (ok + ng) / 2;
				if (satisfies(mid)) {
					ok = mid;
				} else {
					ng = mid;
				}
			}

			return ok;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long BinarySearchNGOK(long ng, long ok, Func<long, bool> satisfies)
		{
			while (ok - ng > 1) {
				long mid = (ok + ng) / 2;
				if (satisfies(mid)) {
					ok = mid;
				} else {
					ng = mid;
				}
			}

			return ok;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static T[] Array1<T>(int n, T initialValue) where T : struct
			=> new T[n].Fill(initialValue);
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static T[] Array1<T>(int n, Func<int, T> initializer)
			=> Enumerable.Range(0, n).Select(x => initializer(x)).ToArray();
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static T[] Fill<T>(this T[] array, T value)
			where T : struct
		{
			array.AsSpan().Fill(value);
			return array;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static T[,] Array2<T>(int n, int m, T initialValule) where T : struct
			=> new T[n, m].Fill(initialValule);
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static T[,] Array2<T>(int n, int m, Func<int, int, T> initializer)
		{
			var array = new T[n, m];
			for (int i = 0; i < n; ++i) {
				for (int j = 0; j < m; ++j) {
					array[i, j] = initializer(i, j);
				}
			}

			return array;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static T[,] Fill<T>(this T[,] array, T initialValue)
			where T : struct
		{
			MemoryMarshal.CreateSpan<T>(ref array[0, 0], array.Length).Fill(initialValue);
			return array;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<T> AsSpan<T>(this T[,] array, int i)
			=> MemoryMarshal.CreateSpan<T>(ref array[i, 0], array.GetLength(1));

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static T[,,] Array3<T>(int n1, int n2, int n3, T initialValue)
			where T : struct
			=> new T[n1, n2, n3].Fill(initialValue);
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static T[,,] Fill<T>(this T[,,] array, T initialValue)
			where T : struct
		{
			MemoryMarshal.CreateSpan<T>(ref array[0, 0, 0], array.Length).Fill(initialValue);
			return array;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<T> AsSpan<T>(this T[,,] array, int i, int j)
			=> MemoryMarshal.CreateSpan<T>(ref array[i, j, 0], array.GetLength(2));

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static T[,,,] Array4<T>(int n1, int n2, int n3, int n4, T initialValue)
			where T : struct
			=> new T[n1, n2, n3, n4].Fill(initialValue);
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static T[,,,] Fill<T>(this T[,,,] array, T initialValue)
			where T : struct
		{
			MemoryMarshal.CreateSpan<T>(ref array[0, 0, 0, 0], array.Length).Fill(initialValue);
			return array;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<T> AsSpan<T>(this T[,,,] array, int i, int j, int k)
			=> MemoryMarshal.CreateSpan<T>(ref array[i, j, k, 0], array.GetLength(3));

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static T[] Merge<T>(ReadOnlySpan<T> first, ReadOnlySpan<T> second) where T : IComparable<T>
		{
			var ret = new T[first.Length + second.Length];
			int p = 0;
			int q = 0;
			while (p < first.Length || q < second.Length) {
				if (p == first.Length) {
					ret[p + q] = second[q];
					q++;
					continue;
				}

				if (q == second.Length) {
					ret[p + q] = first[p];
					p++;
					continue;
				}

				if (first[p].CompareTo(second[q]) < 0) {
					ret[p + q] = first[p];
					p++;
				} else {
					ret[p + q] = second[q];
					q++;
				}
			}

			return ret;
		}

		private static readonly int[] delta4_ = { 1, 0, -1, 0, 1 };
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static IEnumerable<(int i, int j)> Adjacence4(int i, int j, int imax, int jmax)
		{
			for (int dn = 0; dn < 4; ++dn) {
				int d4i = i + delta4_[dn];
				int d4j = j + delta4_[dn + 1];
				if ((uint)d4i < (uint)imax && (uint)d4j < (uint)jmax) {
					yield return (d4i, d4j);
				}
			}
		}

		private static readonly int[] delta8_ = { 1, 0, -1, 0, 1, 1, -1, -1, 1 };
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static IEnumerable<(int i, int j)> Adjacence8(int i, int j, int imax, int jmax)
		{
			for (int dn = 0; dn < 8; ++dn) {
				int d8i = i + delta8_[dn];
				int d8j = j + delta8_[dn + 1];
				if ((uint)d8i < (uint)imax && (uint)d8j < (uint)jmax) {
					yield return (d8i, d8j);
				}
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static IEnumerable<int> SubBitsOf(int bit)
		{
			for (int sub = bit; sub > 0; sub = --sub & bit) {
				yield return sub;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Reverse(string src)
		{
			var chars = src.ToCharArray();
			for (int i = 0, j = chars.Length - 1; i < j; ++i, --j) {
				var tmp = chars[i];
				chars[i] = chars[j];
				chars[j] = tmp;
			}

			return new string(chars);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Exchange(string src, char a, char b)
		{
			var chars = src.ToCharArray();
			for (int i = 0; i < chars.Length; i++) {
				if (chars[i] == a) {
					chars[i] = b;
				} else if (chars[i] == b) {
					chars[i] = a;
				}
			}

			return new string(chars);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void Swap(this string str, int i, int j)
		{
			var span = str.AsWriteableSpan();
			(span[i], span[j]) = (span[j], span[i]);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static char Replace(this string str, int index, char c)
		{
			var span = str.AsWriteableSpan();
			char old = span[index];
			span[index] = c;
			return old;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<char> AsWriteableSpan(this string str)
		{
			var span = str.AsSpan();
			return MemoryMarshal.CreateSpan(ref MemoryMarshal.GetReference(span), span.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Join<T>(this IEnumerable<T> values, string separator = "")
			=> string.Join(separator, values);
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string JoinNL<T>(this IEnumerable<T> values)
			=> string.Join(Environment.NewLine, values);
	}

	public static class Extensions
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<T> AsSpan<T>(this List<T> list)
		{
			return Unsafe.As<FakeList<T>>(list).Array.AsSpan(0, list.Count);
		}

		private class FakeList<T>
		{
			public T[] Array = null;
		}
	}

	public class Scanner : IDisposable
	{
		private const int BUFFER_SIZE = 1024;
		private const int ASCII_SPACE = 32;
		private const int ASCII_CHAR_BEGIN = 33;
		private const int ASCII_CHAR_END = 126;
		private readonly string filePath_;
		private readonly Stream stream_;
		private readonly byte[] buf_ = new byte[BUFFER_SIZE];
		private int length_ = 0;
		private int index_ = 0;
		private bool isEof_ = false;

		public Scanner(string file = "")
		{
			if (string.IsNullOrWhiteSpace(file)) {
				stream_ = Console.OpenStandardInput();
			} else {
				filePath_ = file;
				stream_ = new FileStream(file, FileMode.Open);
			}

			Console.SetOut(new StreamWriter(Console.OpenStandardOutput()) {
				AutoFlush = false
			});
		}

		public void Dispose()
		{
			Console.Out.Flush();
			stream_.Dispose();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public string NextLine()
		{
			var sb = new StringBuilder();
			for (var b = Char(); b >= ASCII_SPACE && b <= ASCII_CHAR_END; b = (char)Read()) {
				sb.Append(b);
			}

			return sb.ToString();
		}


		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public char Char()
		{
			byte b;
			do {
				b = Read();
			} while (b < ASCII_CHAR_BEGIN || ASCII_CHAR_END < b);

			return (char)b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public string String()
		{
			var sb = new StringBuilder();
			for (var b = Char(); b >= ASCII_CHAR_BEGIN && b <= ASCII_CHAR_END; b = (char)Read()) {
				sb.Append(b);
			}

			return sb.ToString();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public string[] ArrayString(int length)
		{
			var array = new string[length];
			for (int i = 0; i < length; ++i) {
				array[i] = String();
			}

			return array;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public int Int() => (int)Long();
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public int Int(int offset) => Int() + offset;
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (int, int) Int2(int offset = 0)
			=> (Int(offset), Int(offset));
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (int, int, int) Int3(int offset = 0)
			=> (Int(offset), Int(offset), Int(offset));
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (int, int, int, int) Int4(int offset = 0)
			=> (Int(offset), Int(offset), Int(offset), Int(offset));
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (int, int, int, int, int) Int5(int offset = 0)
			=> (Int(offset), Int(offset), Int(offset), Int(offset), Int(offset));
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public int[] ArrayInt(int length, int offset = 0)
		{
			var array = new int[length];
			for (int i = 0; i < length; ++i) {
				array[i] = Int(offset);
			}

			return array;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public long Long()
		{
			long ret = 0;
			byte b;
			bool ng = false;
			do {
				b = Read();
			} while (b != '-' && (b < '0' || '9' < b));

			if (b == '-') {
				ng = true;
				b = Read();
			}

			for (; true; b = Read()) {
				if (b < '0' || '9' < b) {
					return ng ? -ret : ret;
				} else {
					ret = ret * 10 + b - '0';
				}
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public long Long(long offset) => Long() + offset;
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (long, long) Long2(long offset = 0)
			=> (Long(offset), Long(offset));
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (long, long, long) Long3(long offset = 0)
			=> (Long(offset), Long(offset), Long(offset));
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (long, long, long, long) Long4(long offset = 0)
			=> (Long(offset), Long(offset), Long(offset), Long(offset));
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (long, long, long, long, long) Long5(long offset = 0)
			=> (Long(offset), Long(offset), Long(offset), Long(offset), Long(offset));
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public long[] ArrayLong(int length, long offset = 0)
		{
			var array = new long[length];
			for (int i = 0; i < length; ++i) {
				array[i] = Long(offset);
			}

			return array;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public BigInteger Big() => new BigInteger(Long());
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public BigInteger Big(long offset) => Big() + offset;
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (BigInteger, BigInteger) Big2(long offset = 0)
			=> (Big(offset), Big(offset));
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (BigInteger, BigInteger, BigInteger) Big3(long offset = 0)
			=> (Big(offset), Big(offset), Big(offset));
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (BigInteger, BigInteger, BigInteger, BigInteger) Big4(long offset = 0)
			=> (Big(offset), Big(offset), Big(offset), Big(offset));
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (BigInteger, BigInteger, BigInteger, BigInteger, BigInteger) Big5(long offset = 0)
			=> (Big(offset), Big(offset), Big(offset), Big(offset), Big(offset));
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public BigInteger[] ArrayBig(int length, long offset = 0)
		{
			var array = new BigInteger[length];
			for (int i = 0; i < length; ++i) {
				array[i] = Big(offset);
			}

			return array;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public double Double() => double.Parse(String(), CultureInfo.InvariantCulture);
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public double Double(double offset) => Double() + offset;
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (double, double) Double2(double offset = 0)
			=> (Double(offset), Double(offset));
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (double, double, double) Double3(double offset = 0)
			=> (Double(offset), Double(offset), Double(offset));
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (double, double, double, double) Double4(double offset = 0)
			=> (Double(offset), Double(offset), Double(offset), Double(offset));
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (double, double, double, double, double) Double5(double offset = 0)
			=> (Double(offset), Double(offset), Double(offset), Double(offset), Double(offset));
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public double[] ArrayDouble(int length, double offset = 0)
		{
			var array = new double[length];
			for (int i = 0; i < length; ++i) {
				array[i] = Double(offset);
			}

			return array;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public decimal Decimal() => decimal.Parse(String(), CultureInfo.InvariantCulture);
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public decimal Decimal(decimal offset) => Decimal() + offset;
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (decimal, decimal) Decimal2(decimal offset = 0)
			=> (Decimal(offset), Decimal(offset));
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (decimal, decimal, decimal) Decimal3(decimal offset = 0)
			=> (Decimal(offset), Decimal(offset), Decimal(offset));
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (decimal, decimal, decimal, decimal) Decimal4(decimal offset = 0)
			=> (Decimal(offset), Decimal(offset), Decimal(offset), Decimal(offset));
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (decimal, decimal, decimal, decimal, decimal) Decimal5(decimal offset = 0)
			=> (Decimal(offset), Decimal(offset), Decimal(offset), Decimal(offset), Decimal(offset));
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public decimal[] ArrayDecimal(int length, decimal offset = 0)
		{
			var array = new decimal[length];
			for (int i = 0; i < length; ++i) {
				array[i] = Decimal(offset);
			}

			return array;
		}

		private byte Read()
		{
			if (isEof_) {
				throw new EndOfStreamException();
			}

			if (index_ >= length_) {
				index_ = 0;
				if ((length_ = stream_.Read(buf_, 0, BUFFER_SIZE)) <= 0) {
					isEof_ = true;
					return 0;
				}
			}

			return buf_[index_++];
		}

		public void Save(string text)
		{
			if (string.IsNullOrWhiteSpace(filePath_)) {
				return;
			}

			File.WriteAllText(filePath_ + "_output.txt", text);
		}
	}
}

yukicoder

結果

テストケース

コンパイルメッセージ

ソースコード