結果

問題 No.2805 Go to School
ユーザー 👑 p-adicp-adic
提出日時 2024-07-12 22:15:58
言語 C++17(gcc12)
(gcc 12.3.0 + boost 1.87.0)
結果
AC  
実行時間 489 ms / 2,000 ms
コード長 60,480 bytes
コンパイル時間 4,155 ms
コンパイル使用メモリ 259,520 KB
実行使用メモリ 47,164 KB
最終ジャッジ日時 2024-07-16 01:40:40
合計ジャッジ時間 12,127 ms
ジャッジサーバーID
(参考情報)
judge5 / judge2
このコードへのチャレンジ
(要ログイン)

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
6,812 KB
testcase_01 AC 2 ms
6,940 KB
testcase_02 AC 2 ms
6,940 KB
testcase_03 AC 2 ms
6,940 KB
testcase_04 AC 138 ms
29,416 KB
testcase_05 AC 192 ms
22,656 KB
testcase_06 AC 129 ms
14,080 KB
testcase_07 AC 86 ms
13,824 KB
testcase_08 AC 136 ms
24,448 KB
testcase_09 AC 123 ms
13,440 KB
testcase_10 AC 77 ms
13,696 KB
testcase_11 AC 467 ms
36,160 KB
testcase_12 AC 269 ms
23,424 KB
testcase_13 AC 411 ms
30,964 KB
testcase_14 AC 39 ms
8,448 KB
testcase_15 AC 2 ms
6,940 KB
testcase_16 AC 2 ms
6,940 KB
testcase_17 AC 2 ms
6,944 KB
testcase_18 AC 199 ms
18,560 KB
testcase_19 AC 135 ms
13,696 KB
testcase_20 AC 324 ms
25,984 KB
testcase_21 AC 489 ms
36,184 KB
testcase_22 AC 192 ms
18,156 KB
testcase_23 AC 333 ms
24,576 KB
testcase_24 AC 320 ms
24,320 KB
testcase_25 AC 97 ms
15,248 KB
testcase_26 AC 461 ms
47,164 KB
testcase_27 AC 153 ms
27,596 KB
testcase_28 AC 11 ms
9,728 KB
testcase_29 AC 17 ms
11,352 KB
testcase_30 AC 64 ms
19,828 KB
testcase_31 AC 210 ms
17,152 KB
testcase_32 AC 316 ms
39,744 KB
testcase_33 AC 314 ms
30,680 KB
testcase_34 AC 3 ms
6,944 KB
testcase_35 AC 2 ms
6,944 KB
testcase_36 AC 151 ms
14,848 KB
testcase_37 AC 157 ms
16,384 KB
testcase_38 AC 262 ms
26,336 KB
権限があれば一括ダウンロードができます

ソースコード

diff #
プレゼンテーションモードにする

#ifndef INCLUDE_MODE
#define INCLUDE_MODE
// #define REACTIVE
// #define USE_GETLINE
#endif
#ifdef INCLUDE_MAIN
IN VO Solve()
{
// //
// CIN( ll , N );
// CIN_A( ll , 0 , N , A );
// // CIN( string , S );
// //
// CIN_HW;
// // SET_HW( N , M );
// FOR( i , 0 , H ){
// SetWallStringOnGrid( i , grid ); // grid[i][j]'.''#'
// }
// // GridGraph graph{ WEdgeOnGrid };
// // AcyclicGridGraph graph{ WEdgeOnGrid };
// // {i,j}: EnumHW( v )
// // {i,j}: EnumHW_inv( { i , j } );
// // direction="URDL";
// // (i,j)->(k,h): DirectionNumberOnGrid( i , j , k , h );
// // v->w: DirectionNumberOnGrid( v , w );
// // U<->DR<->L: ReverseDirectionNumberOnGrid( n );
// //
// CIN( int , N , M );
// // CIN( int , N ); int M = N - 1;
// vector<vector<int>> e( N );
// REPEAT( M ){
// CIN( int , u , v ); --u; --v;
// e[u].push_back( v );
// e[v].push_back( u );
// }
// Graph graph{ N , Get( e ) };
// BreadthFirstSearch bfs{ graph , -1 , 0 }; vector<int> d = bfs.GetDistance();
// // DepthFirstSearchOnTree dfst{ graph , 0 };
// // AbstractUnionFindForest uff{ graph , AdditiveGroup<int>() };
// // auto [ts,ts_inv,prev,dir_edge] = TopologicalSortedTree( graph , 0 );
// // Graph graph_dir{ N , Get( dir_edge ) }; // 0
// // Graph graph_dir_rev{ N , [&]( const int& i ){ return vector( prev[i] >= 0 ? 1 : 0 , prev[i] ); } };
//
CIN( int , N , M , L , S , E );
// CIN( int , N ); int M = N - 1;
// CEXPR( ll , infty , 1e18 );
vector<vector<path>> e( N + N );
// vector w( N , vector( N , infty ) ); FOR( i , 0 , N ){ w[i][i] = 0; }
REPEAT( M ){
CIN( ll , u , v , w ); --u; --v;
e[u].push_back( { v , w } );
e[v].push_back( { u , w } );
e[u+N].push_back( { v+N , w } );
e[v+N].push_back( { u+N , w } );
// w[u][v] = w[v][u] = w;
}
CIN_A( int , 0 , L , T ); --T;
Graph graph1{ N , Get( e ) };
Dijkstra dijk1{ graph1 }; vector<ll> d1 = dijk1.GetDistance( 0 );
// AbstractUnionFindForest uff{ graph , AdditiveGroup<ll>() };
// FloydWarshall fw{ infty , w }; vector<vector<ll>> d = fw.GetDistance();
FOR( l , 0 , L ){
if( d1[T[l]] < S + E ){
e[0].push_back( { T[l]+N , max( d1[T[l]] , ll( S ) ) + 1 } );
}
}
Graph graph2{ N + N , Get( e ) };
Dijkstra dijk2{ graph2 }; vector<ll> d2 = dijk2.GetDistance( 0 );
if( d2[N + N - 1] == dijk2.Infty() ){
RETURN( -1 );
} else {
RETURN( d2[N + N - 1] );
}
// //
// CIN( int , Q );
// // BIT t{ N };
// // IntervalMultiplyLazySqrtDecomposition t{ MultiplicativeMonoid<ll>( 1 ) , Module<ll,ll>() , N };
// FOR( q , 0 , Q ){
// CIN( int , type );
// if( type == 1 ){
// CIN( ll , l , r , x ); --l; --r;
// } else if( type == 2 ){
// CIN( ll , l , r ); --l; --r;
// COUT( t.IntervalSum( l , r ) );
// }
// }
// // CIN_A( T3<int> , 0 , Q , query );
// // sort( query );
// // Mo mo{ query };
}
REPEAT_MAIN(1);
#else // INCLUDE_MAIN
#ifdef INCLUDE_SUB
// COMPARE使
ll Naive( ll N , ll M , ll K )
{
ll answer = N + M + K;
return answer;
}
// COMPARE使
ll Answer( ll N , ll M , ll K )
{
// START_WATCH;
ll answer = N + M + K;
// // TL100.0[ms]
// CEXPR( double , TL , 2000.0 );
// while( CHECK_WATCH( TL ) ){
// }
return answer;
}
//
IN VO Experiment()
{
// CEXPR( int , bound , 10 );
// FOREQ( N , 0 , bound ){
// FOREQ( M , 0 , bound ){
// FOREQ( K , 0 , bound ){
// COUT( N , M , K , ":" , Naive( N , M , K ) );
// }
// }
// // cout << Naive( N ) << ",\n"[N==bound];
// }
}
//
IN VO SmallTest()
{
// CEXPR( int , bound , 10 );
// FOREQ( N , 0 , bound ){
// FOREQ( M , 0 , bound ){
// FOREQ( K , 0 , bound ){
// COMPARE( N , M , K );
// }
// }
// }
}
//
IN VO RandomTest( CRI test_case_num )
{
// REPEAT( test_case_num ){
// CEXPR( int , bound_N , 1e5 ); CIN_ASSERT( N , 1 , bound_N );
// CEXPR( ll , bound_M , 1e18 ); CIN_ASSERT( M , 1 , bound_M );
// CEXPR( ll , bound_K , 1e9 ); CIN_ASSERT( K , 1 , bound_K );
// COMPARE( N , M , K );
// }
}
#define INCLUDE_MAIN
#include __FILE__
#else // INCLUDE_SUB
#ifdef INCLUDE_LIBRARY
/*
AdicExhausiveSearch/BFS (11KB)
c:/Users/user/Documents/Programming/Mathematics/Geometry/Graph/Algorithm/BreadthFirstSearch/AdicExhausiveSearch/compress.txt
CommutativeDualSqrtDecomposition (6KB)
c:/Users/user/Documents/Programming/Mathematics/SetTheory/DirectProduct/AffineSpace/SqrtDecomposition/Dual/Commutative/compress.txt
CoordinateCompress (3KB)
c:/Users/user/Documents/Programming/Mathematics/SetTheory/DirectProduct/CoordinateCompress/compress.txt
DFSOnTree (11KB)
c:/Users/user/Documents/Programming/Mathematics/Geometry/Graph/Algorithm/DepthFirstSearch/Tree/compress.txt
DifferenceSequence (9KB)
c:/Users/user/Documents/Programming/Mathematics/SetTheory/DirectProduct/AffineSpace/DifferenceSequence/compress.txt
Divisor/Prime (4KB)
c:/Users/user/Documents/Programming/Mathematics/Arithmetic/Prime/Divisor/compress.txt
IntervalAddBIT (9KB)
c:/Users/user/Documents/Programming/Mathematics/SetTheory/DirectProduct/AffineSpace/BIT/IntervalAdd/compress.txt
IntervalMaxBIT (9KB)
c:/Users/user/Documents/Programming/Mathematics/SetTheory/DirectProduct/AffineSpace/BIT/IntervalMax/compress.txt
IntervalMultiplyLazySqrtDecomposition (18KB)
c:/Users/user/Documents/Programming/Mathematics/SetTheory/DirectProduct/AffineSpace/SqrtDecomposition/LazyEvaluation/IntervalMultiply/compress.txt
Knapsack (8KB)
c:/Users/user/Documents/Programming/Mathematics/Combinatorial/KnapsackProblem/compress.txt
MinimumCostFlow/PotentialisedDijkstra/Dijkstra (16KB)
c:/Users/user/Documents/Programming/Mathematics/Geometry/Graph/Algorithm/Dijkstra/Potentialised/MinimumCostFlow/compress.txt
TruncatedPolynomial (34KB)
c:/Users/user/Documents/Programming/Mathematics/Polynomial/Truncate/NonProth/compress.txt
TwoByOneMatrix/TwoByTwoMatrix (9KB)
C:/Users/user/Documents/Programming/Mathematics/LinearAlgebra/TwoByOne/compress.txt
UnionFind (3KB)
c:/Users/user/Documents/Programming/Mathematics/Geometry/Graph/Algorithm/UnionFindForest/compress.txt
*/
// VVV
#ifdef DEBUG
#include "c:/Users/user/Documents/Programming/Mathematics/Geometry/Graph/Algorithm/Dijkstra/Potentialised/MinimumCostFlow/a_Body.hpp"
#else
TE <TY U,TY MONOID,TY SEMIGROUP>CL VirtualSemirng{PU:VI U Sum(CO U& u0,CO U& u1)= 0;VI CO U& Zero()CO NE = 0;VI U Product(CO U& u0,CO U& u1)= 0;VI
    MONOID& AdditiveMonoid()NE = 0;VI SEMIGROUP& MultiplicativeSemigroup()NE = 0;US type = U;};TE <TY U,TY MONOID,TY SEMIGROUP>CL AbstractSemirng:VI
    PU VirtualSemirng<U,MONOID,SEMIGROUP>{PU:MONOID m_R0;SEMIGROUP m_R1;IN AbstractSemirng(MONOID R0,SEMIGROUP R1);IN U Sum(CO U& u0,CO U& u1);IN CO
    U& Zero()CO NE;IN U Product(CO U& u0,CO U& u1);IN MONOID& AdditiveMonoid()NE;IN SEMIGROUP& MultiplicativeSemigroup()NE;};TE <TY U>CL Semirng:PU
    AbstractSemirng<U,AdditiveMonoid<U>,MultiplicativeMagma<U>>{PU:IN Semirng();};
TE <TY U,TY MONOID,TY SEMIGROUP> IN AbstractSemirng<U,MONOID,SEMIGROUP>::AbstractSemirng(MONOID R0,SEMIGROUP R1):m_R0(MO(R0)),m_R1(MO(R1)){}TE <TY U>
    IN Semirng<U>::Semirng():AbstractSemirng<U,AdditiveMonoid<U>,MultiplicativeMagma<U>>(AdditiveMonoid<U>(),MultiplicativeMagma()){}TE <TY U,TY
    MONOID,TY SEMIGROUP> IN U AbstractSemirng<U,MONOID,SEMIGROUP>::Sum(CO U& u0,CO U& u1){RE m_R0.Sum(u0,u1);}TE <TY U,TY MONOID,TY SEMIGROUP> IN CO
    U& AbstractSemirng<U,MONOID,SEMIGROUP>::Zero()CO NE{RE m_R0.Zero();}TE <TY U,TY MONOID,TY SEMIGROUP> IN U AbstractSemirng<U,MONOID,SEMIGROUP
    >::Product(CO U& u0,CO U& u1){RE m_R1.Product(u0,u1);}TE <TY U,TY MONOID,TY SEMIGROUP> IN MONOID& AbstractSemirng<U,MONOID,SEMIGROUP
    >::AdditiveMonoid()NE{RE m_R0;}TE <TY U,TY MONOID,TY SEMIGROUP> IN SEMIGROUP& AbstractSemirng<U,MONOID,SEMIGROUP>::MultiplicativeSemigroup()NE{RE
    m_R1;}
TE <TY U,TY GROUP,TY MONOID>CL VirtualRing:VI PU VirtualSemirng<U,GROUP,MONOID>{PU:VI U Inverse(CO U& u)= 0;VI CO U& One()CO NE = 0;IN GROUP&
    AdditiveGroup()NE;IN MONOID& MultiplicativeMonoid()NE;};TE <TY U,TY GROUP,TY MONOID>CL AbstractRing:VI PU VirtualRing<U,GROUP,MONOID>,PU
    AbstractSemirng<U,GROUP,MONOID>{PU:IN AbstractRing(GROUP R0,MONOID R1);IN U Inverse(CO U& u);IN CO U& One()CO NE;};TE <TY U = ll>CL Ring:VI PU
    AbstractRing<U,AdditiveGroup<U>,MultiplicativeMonoid<U>>{PU:IN Ring(CO U& one_U);};
TE <TY U,TY GROUP,TY MONOID> IN AbstractRing<U,GROUP,MONOID>::AbstractRing(GROUP R0,MONOID R1):AbstractSemirng<U,GROUP,MONOID>(MO(R0),MO(R1)){}TE <TY
    U> IN Ring<U>::Ring(CO U& one_U):AbstractRing<U,AdditiveGroup<U>,MultiplicativeMonoid<U>>(AdditiveGroup<U>(),MultiplicativeMonoid<U>(one_U)){}TE
    <TY U,TY GROUP,TY MONOID> IN U AbstractRing<U,GROUP,MONOID>::Inverse(CO U& u){RE TH->m_R0.Inverse(u);}TE <TY U,TY GROUP,TY MONOID> IN CO U&
    AbstractRing<U,GROUP,MONOID>::One()CO NE{RE TH->m_R1.One();}TE <TY U,TY GROUP,TY MONOID> IN GROUP& VirtualRing<U,GROUP,MONOID>::AdditiveGroup
    ()NE{RE TH->AdditiveMonoid();}TE <TY U,TY GROUP,TY MONOID> IN MONOID& VirtualRing<U,GROUP,MONOID>::MultiplicativeMonoid()NE{RE TH
    ->MultiplicativeSemigroup();}
#define DIJKSTRA_PREP(INITIALISE_PREV)CO U& one = m_M.One();AS(one < infty);auto&& i_start = m_G.Enumeration_inv(t_start);AS(0 <= i_start && i_start
    < SZ);INITIALISE_PREV;
#define DIJKSTRA_BODY_1(SET_PREV)if(path_LE == -1){path_LE = SZ - 1;}weight[i_start]= one;int i = i_start;for(int num = 0;num < path_LE;num++){CO U&
    weight_i = weight[i];fixed[i]= true;auto&& edge_i = m_G.Edge(m_G.Enumeration(i));for(auto IT = edge_i.BE(),EN = edge_i.end();IT != EN;IT
    ++){auto&& j = m_G.Enumeration_inv(IT->first);if(!fixed[j]){CO U& edge_ij = get<1>(*IT);U temp = m_M.Product(weight_i,edge_ij);AS(temp < infty
    );U& weight_j = weight[j];if(temp < weight_j){SET_PREV;weight_j = MO(temp);}}}U temp = infty;for(int j = 0;j < SZ;j++){if(!fixed[j]){U& weight_j
    = weight[j];if(weight_j < temp){temp = weight_j;i = j;}}}}
#define DIJKSTRA_BODY_2(CHECK_FINAL,SET_PREV)AS(path_LE == -1);set<pair<U,int>> vertex{};vertex.insert(pair<U,int>(weight[i_start]= one,i_start));WH
    (! vertex.empty()){auto BE = vertex.BE();auto[weight_i,i]= *BE;CHECK_FINAL;fixed[i]= true;vertex.erase(BE);auto&& edge_i = m_G.Edge(m_G
    .Enumeration(i));VE<pair<U,int>> changed_vertex{};for(auto IT = edge_i.BE(),EN = edge_i.end();IT != EN;IT++){auto&& j = m_G.Enumeration_inv(IT
    ->first);if(!fixed[j]){CO U& edge_ij = get<1>(*IT);U temp = m_M.Product(weight_i,edge_ij);AS(temp < infty);U& weight_j = weight[j];if(temp <
    weight_j){if(weight_j != infty){vertex.erase(pair<U,int>(weight_j,j));}SET_PREV;changed_vertex.push_back(pair<U,int>(weight_j = MO(temp),j
    ));}}}for(auto& v:changed_vertex){vertex.insert(v);}}
#define DIJKSTRA_BODY(INITIALISE_PREV,CHECK_FINAL,SET_PREV)DIJKSTRA_PREP(INITIALISE_PREV);if(many_edges){DIJKSTRA_BODY_1(SET_PREV
    );}else{DIJKSTRA_BODY_2(CHECK_FINAL,SET_PREV);}
TE <TY T,TY GRAPH,TY U,TY COMM_MONOID>CL AbstractDijkstra:PU PointedSet<U>{PU:GRAPH& m_G;COMM_MONOID m_M;IN AbstractDijkstra(GRAPH& G,COMM_MONOID M
    ,CO U& infty);U GetDistance(CO inner_t<GRAPH>& t_start,CO inner_t<GRAPH>& t_final,CO bool& many_edges = false,int path_LE = -1);VE<U> GetDistance
    (CO inner_t<GRAPH>& t_start,CO bool& many_edges = false,int path_LE = -1);VO SetDistance(VE<U>& weight,VE<bool>& fixed,CO inner_t<GRAPH>& t_start
    ,CO bool& many_edges = false,int path_LE = -1);pair<U,LI<inner_t<GRAPH>>> GetPath(CO inner_t<GRAPH>& t_start,CO inner_t<GRAPH>& t_final,CO bool&
    many_edges = false,int path_LE = -1);TE <TE <TY...> TY V> pair<VE<U>,VE<LI<inner_t<GRAPH>>>> GetPath(CO inner_t<GRAPH>& t_start,CO V<inner_t
    <GRAPH>>& t_finals,CO bool& many_edges = false,int path_LE = -1);pair<VE<U>,VE<LI<inner_t<GRAPH>>>> GetPath(CO inner_t<GRAPH>& t_start,CO bool&
    many_edges = false,int path_LE = -1);};TE <TY GRAPH,TY U,TY COMM_MONOID> AbstractDijkstra(GRAPH& G,COMM_MONOID M,CO U& infty)-> AbstractDijkstra
    <inner_t<GRAPH>,GRAPH,U,COMM_MONOID>;TE <TY T,TY GRAPH>CL Dijkstra:PU AbstractDijkstra<T,GRAPH,ll,AdditiveMonoid<>>{PU:IN Dijkstra(GRAPH& G,CRL
    infty = 1e18);};TE <TY GRAPH,TY...ARGS> Dijkstra(GRAPH& G,CO ARGS&... args)-> Dijkstra<inner_t<GRAPH>,GRAPH>;
TE <TY T,TY GRAPH,TY U,TY COMM_MONOID> IN AbstractDijkstra<T,GRAPH,U,COMM_MONOID>::AbstractDijkstra(GRAPH& G,COMM_MONOID M,CO U& infty):PointedSet<U
    >(infty),m_G(G),m_M(MO(M)){}TE <TY T,TY GRAPH> IN Dijkstra<T,GRAPH>::Dijkstra(GRAPH& G,CRL infty):AbstractDijkstra<T,GRAPH,ll,AdditiveMonoid<>>(G
    ,AdditiveMonoid<>(),infty){}TE <TY T,TY GRAPH,TY U,TY COMM_MONOID>U AbstractDijkstra<T,GRAPH,U,COMM_MONOID>::GetDistance(CO inner_t<GRAPH>&
    t_start,CO inner_t<GRAPH>& t_final,CO bool& many_edges,int path_LE){CRI SZ = m_G.SZ();CO U& infty = TH->Infty();VE weight(SZ,infty);VE<bool>
    fixed(SZ);auto&& i_final = m_G.Enumeration_inv(t_final);DIJKSTRA_BODY(,if(i == i_final){break;},);U AN{MO(weight[i_final])};RE AN;}TE <TY T,TY
    GRAPH,TY U,TY COMM_MONOID>VE<U> AbstractDijkstra<T,GRAPH,U,COMM_MONOID>::GetDistance(CO inner_t<GRAPH>& t_start,CO bool& many_edges,int path_LE
    ){CRI SZ = m_G.SZ();CO U& infty = TH->Infty();VE weight(SZ,infty);VE<bool> fixed(SZ);DIJKSTRA_BODY(,,);RE weight;}TE <TY T,TY GRAPH,TY U,TY
    COMM_MONOID>VO AbstractDijkstra<T,GRAPH,U,COMM_MONOID>::SetDistance(VE<U>& weight,VE<bool>& fixed,CO inner_t<GRAPH>& t_start,CO bool& many_edges
    ,int path_LE){CRI SZ = m_G.SZ();CO U& infty = TH->Infty();AS(int(weight.SZ())== SZ);AS(int(fixed.SZ())== SZ);DIJKSTRA_BODY(,,);RE;}TE <TY T,TY
    GRAPH,TY U,TY COMM_MONOID>pair<U,LI<inner_t<GRAPH>>> AbstractDijkstra<T,GRAPH,U,COMM_MONOID>::GetPath(CO inner_t<GRAPH>& t_start,CO inner_t<GRAPH
    >& t_final,CO bool& many_edges,int path_LE){CRI SZ = m_G.SZ();CO U& infty = TH->Infty();VE weight(SZ,infty);VE<bool> fixed(SZ);auto&& i_final =
    m_G.Enumeration_inv(t_final);DIJKSTRA_BODY(VE<int> prev(SZ),if(i == i_final){break;},prev[j]= i);int i = i_final;LI<inner_t<GRAPH>> path{};path
    .push_back(t_final);if(weight[i]!= infty){WH(i != i_start){i = prev[i];path.push_front(m_G.Enumeration(i));}}U AN{MO(weight[i_final])};RE{MO(AN
    ),MO(path)};}TE <TY T,TY GRAPH,TY U,TY COMM_MONOID> TE <TE <TY...> TY V>pair<VE<U>,VE<LI<inner_t<GRAPH>>>> AbstractDijkstra<T,GRAPH,U,COMM_MONOID
    >::GetPath(CO inner_t<GRAPH>& t_start,CO V<inner_t<GRAPH>>& t_finals,CO bool& many_edges,int path_LE){CRI SZ = m_G.SZ();CO U& infty = TH->Infty
    ();VE weight(SZ,infty);VE<bool> fixed(SZ);DIJKSTRA_BODY(VE<int> prev(SZ),,prev[j]= i);CO int path_SZ = t_finals.SZ();VE<LI<inner_t<GRAPH>>> path
    ;path.reserve(path_SZ);for(auto IT = t_finals.BE(),EN = t_finals.EN();IT != EN;IT++){LI<inner_t<GRAPH>> path_j{};CO inner_t<GRAPH>& t_final = *IT
    ;path_j.push_back(t_final);int i = m_G.Enumeration_inv(t_final);if(weight[i]!= infty){WH(i != i_start){i = prev[i];path_j.push_front(m_G
    .Enumeration(i));}}path.push_back(path_j);}RE{MO(weight),MO(path)};}TE <TY T,TY GRAPH,TY U,TY COMM_MONOID>pair<VE<U>,VE<LI<inner_t<GRAPH>>>>
    AbstractDijkstra<T,GRAPH,U,COMM_MONOID>::GetPath(CO inner_t<GRAPH>& t_start,CO bool& many_edges,int path_LE){CRI SZ = m_G.SZ();VE<inner_t<GRAPH>>
    t_finals(SZ);for(int i = 0;i < SZ;i++){t_finals[i]= i;}RE GetPath(t_start,t_finals,many_edges,path_LE);}
#define POTENTIALISED_DIJKSTRA_BODY(GET,WEIGHT)CO U& infty = TH->Infty();CO U& zero = m_M.Zero();auto edge =[&](CO T& t){CO U& potential_i =
    m_potential[m_G.Enumeration_inv(t)];AS(potential_i < infty);auto edge_i = m_G.Edge(t);VE<pair<T,U>> AN{};for(auto& e:edge_i){if(m_on(e)){CO auto&
    v_j = get<0>(e);U& w_j = get<1>(e);CO U& potential_j = m_potential[m_G.Enumeration_inv(v_j)];AS(w_j < infty && potential_j < infty);CO U
    potential_j_inv = m_M.Inverse(potential_j);w_j = m_M.Sum(m_M.Sum(w_j,potential_i),potential_j_inv);AS(!(w_j < zero)&& w_j < infty);AN.push_back
    ({v_j,MO(w_j)});}}RE AN;};auto G = m_G.GetGraph(MO(edge));AbstractDijkstra d{G,m_M,infty};auto value = d.GET;CRI SZ = m_G.SZ();for(int i = 0;i <
    SZ;i++){auto& weight_i = WEIGHT[i];if(weight_i != infty){weight_i = m_M.Sum(weight_i,m_potential[i]);}}RE value;
TE <TY T,TY GRAPH,TY U,TY GROUP,TY On>CL AbstractPotentialisedDijkstra:PU PointedSet<U>{PU:GRAPH& m_G;GROUP m_M;T m_t_start;On m_on;VE<U> m_potential
    ;IN AbstractPotentialisedDijkstra(GRAPH& G,GROUP M,CO T& t_start,CO U& infty,On on,VE<U> potential ={});IN CO VE<U>& Potential()CO NE;IN VO
    SetPotential(VE<U> potential);TE <TY...Args> VE<U> GetDistance(Args&&... args);TE <TY...Args> pair<VE<U>,VE<LI<T>>> GetPath(Args&&... args);};TE
    <TY T,TY GRAPH,TY On>CL PotentialisedDijkstra:PU AbstractPotentialisedDijkstra<T,GRAPH,ll,AdditiveGroup<>,On>{PU:TE <TY...Args> IN
    PotentialisedDijkstra(GRAPH& G,CO T& t_start,On on,Args&&... args);};
TE <TY T,TY GRAPH,TY U,TY GROUP,TY On> IN AbstractPotentialisedDijkstra<T,GRAPH,U,GROUP,On>::AbstractPotentialisedDijkstra(GRAPH& G,GROUP M,CO T&
    t_start,CO U& infty,On on,VE<U> potential):PointedSet<U>(infty),m_G(G),m_M(MO(M)),m_t_start(t_start),m_on(MO(on)),m_potential(potential){ST_AS
    (is_invocable_r_v<bool,On,decltype(declval<GRAPH>().Edge(declval<T>()).back())>);if(m_potential.empty()){m_potential = VE<U>(m_G.SZ(),m_M.Zero
    ());}else{AS(int(m_potential.SZ())== m_G.SZ());}}TE <TY T,TY GRAPH,TY On> TE <TY...Args> IN PotentialisedDijkstra<T,GRAPH,On
    >::PotentialisedDijkstra(GRAPH& G,CO T& t_start,On on,Args&&... args):AbstractPotentialisedDijkstra<T,GRAPH,ll,AdditiveGroup<>,On>(G
    ,AdditiveGroup<>(),t_start,1e18,MO(on),forward<decay_t<Args>>(args)...){}TE <TY T,TY GRAPH,TY U,TY GROUP,TY On> IN CO VE<U>&
    AbstractPotentialisedDijkstra<T,GRAPH,U,GROUP,On>::Potential()CO NE{RE m_potential;}TE <TY T,TY GRAPH,TY U,TY GROUP,TY On> IN VO
    AbstractPotentialisedDijkstra<T,GRAPH,U,GROUP,On>::SetPotential(VE<U> potential){AS(int(potential.SZ())== m_G.SZ());m_potential = MO(potential
    );}TE <TY T,TY GRAPH,TY U,TY GROUP,TY On> TE <TY...Args> VE<U> AbstractPotentialisedDijkstra<T,GRAPH,U,GROUP,On>::GetDistance(Args&&... args
    ){POTENTIALISED_DIJKSTRA_BODY(GetDistance(m_t_start,forward<Args>(args)...),value);}TE <TY T,TY GRAPH,TY U,TY GROUP,TY On> TE <TY...Args> pair<VE
    <U>,VE<LI<T>>> AbstractPotentialisedDijkstra<T,GRAPH,U,GROUP,On>::GetPath(Args&&... args){POTENTIALISED_DIJKSTRA_BODY(GetPath(m_t_start,forward
    <Args>(args)...),get<0>(value));}
TE <TY T,TY GRAPH,TY U,TY RING>CL AbstractMinimumCostFlow{PU:GRAPH& m_G;RING m_R;U m_infty;VE<VE<tuple<int,U,U,int>>> m_full;VE<VE<tuple<T,U>>>
    m_flow;VE<VE<int>> m_edge_num;VE<VE<int>> m_edge_rev_num;IN AbstractMinimumCostFlow(GRAPH& G,RING R,CO U& infty);pair<U,VE<VE<tuple<T,U>>>>
    GetFlow(CO T& t_start,CO T& t_final,U f,CO bool& many_edges = false,int path_LE = -1);};TE <TY GRAPH,TY U,TY RING> AbstractMinimumCostFlow(GRAPH&
    G,RING R,CO U& infty)-> AbstractMinimumCostFlow<inner_t<GRAPH>,GRAPH,U,RING>;TE <TY T,TY GRAPH,TY U>CL MinimumCostFlow:PU AbstractMinimumCostFlow
    <T,GRAPH,U,Ring<U>>{PU:IN MinimumCostFlow(GRAPH& G,CO U& one_U,CO U& infty);};TE <TY GRAPH,TY U> MinimumCostFlow(GRAPH& G,CO U& one_U,CO U& infty
    )-> MinimumCostFlow<inner_t<GRAPH>,GRAPH,U>;
TE <TY T,TY GRAPH,TY U,TY RING> IN AbstractMinimumCostFlow<T,GRAPH,U,RING>::AbstractMinimumCostFlow(GRAPH& G,RING R,CO U& infty):m_G(G),m_R(MO(R
    )),m_infty(infty),m_full(),m_flow(),m_edge_num(),m_edge_rev_num(){CO U& zero = m_R.Zero();CRI SZ = m_G.SZ();m_full.resize(SZ);m_flow.resize(SZ
    );m_edge_num.resize(SZ,VE<int>(SZ,-1));m_edge_rev_num.resize(SZ,VE<int>(SZ,-1));for(int i = 0;i < SZ;i++){auto&& vi = m_G.Enumeration(i);for
    (auto&[vj,wj,fj]:m_G.Edge(vi)){AS(vi != vj && !(wj < zero)&& wj < m_infty && !(fj < zero)&& fj < m_infty);if(zero < fj){auto&& j = m_G
    .Enumeration_inv(vj);AS(m_edge_num[i][j]== -1);m_edge_num[i][j]= m_full[i].SZ();AS(m_edge_rev_num[j][i]== -1);m_edge_rev_num[j][i]= m_full[j].SZ
    ();CO int flow_i_SZ = m_flow[i].SZ();m_full[i].push_back({j,wj,fj,flow_i_SZ});m_full[j].push_back({i,m_R.Inverse(wj),zero,flow_i_SZ});m_flow[i]
    .push_back({vj,zero});if(m_edge_num[j][i]!= -1){swap(m_full[j][m_edge_num[j][i]],m_full[j][m_edge_rev_num[j][i]]);swap(m_edge_num[j][i]
    ,m_edge_rev_num[j][i]);}}}}}TE <TY T,TY GRAPH,TY U> IN MinimumCostFlow<T,GRAPH,U>::MinimumCostFlow(GRAPH& G,CO U& one_U,CO U& infty
    ):AbstractMinimumCostFlow<T,GRAPH,U,Ring<U>>(G,Ring<U>(one_U),infty){}TE <TY T,TY GRAPH,TY U,TY RING>pair<U,VE<VE<tuple<T,U>>>>
    AbstractMinimumCostFlow<T,GRAPH,U,RING>::GetFlow(CO T& t_start,CO T& t_final,U f,CO bool& many_edges,int path_LE){CO U& zero = m_R.Zero();auto
    rest = m_full;auto flow = m_flow;auto edge =[&](CO T& t)-> CO VE<tuple<int,U,U,int>>&{RE rest[m_G.Enumeration_inv(t)];};auto on =[&](CO tuple<T,U
    ,U,int>& e){RE zero < get<2>(e);};auto G = m_G.GetGraph(MO(edge));AbstractPotentialisedDijkstra pd{G,m_R.AdditiveGroup(),t_start,m_infty,MO(on)}
    ;auto&& i_start = m_G.Enumeration_inv(t_start);auto&& i_final = m_G.Enumeration_inv(t_final);CO VE<T> t_finals ={t_final};U w = zero;WH(zero < f
    ){auto[weight,paths]= pd.GetPath(t_finals,many_edges,path_LE);CO U w_min = weight[i_final];pd.SetPotential(MO(weight));auto& path = paths.front
    ();auto IT_path = path.BE(),IT_path_prev = IT_path,EN_path = path.EN();int i = i_start;U f_min = f;VE<tuple<U*,U*,U*,bool>> update{};update
    .reserve(path.SZ()- 1);WH(++IT_path != EN_path){auto&& j = m_G.Enumeration_inv(*IT_path);bool reversed = false;if(m_edge_rev_num[i][j]!= -1
    ){auto&[j_copy,w_rev_ij,f_rev_ij,flow_num_ji]= rest[i][m_edge_rev_num[i][j]];if(zero < f_rev_ij){f_min = min(f_min,f_rev_ij);update.push_back
    ({&f_rev_ij,&(get<2>(rest[j][m_edge_num[j][i]])),&(get<1>(flow[j][flow_num_ji])),reversed = true});}}if(!reversed){auto&[j_copy,w_ij,f_ij
    ,flow_num_ij]= rest[i][m_edge_num[i][j]];f_min = min(f_min,f_ij);update.push_back({&f_ij,&(get<2>(rest[j][m_edge_rev_num[j][i]])),&(get<1
    >(flow[i][flow_num_ij])),reversed});}IT_path_prev = IT_path;i = j;}CO U f_min_inv = m_R.Inverse(f_min);f = m_R.Sum(f,f_min_inv);w = m_R.Sum(w,m_R
    .Product(f_min,w_min));for(auto&[p_f,p_f_rev,p_flow,reversed]:update){*p_f = m_R.Sum(MO(*p_f),f_min_inv);*p_f_rev = m_R.Sum(MO(*p_f_rev),f_min
    );*p_flow = m_R.Sum(MO(*p_flow),reversed?f_min_inv:f_min);}}RE{MO(w),MO(flow)};}
#endif
// AAA
#define INCLUDE_SUB
#include __FILE__
#else // INCLUDE_LIBRARY
#ifndef DEBUG
#pragma GCC optimize ( "O3" )
#pragma GCC optimize ( "unroll-loops" )
#pragma GCC target ( "sse4.2,fma,avx2,popcnt,lzcnt,bmi2" )
#define REPEAT_MAIN( BOUND ) START_MAIN; CEXPR( int , bound_test_case_num , BOUND ); int test_case_num = 1; if CE( bound_test_case_num > 1 ){
      SET_ASSERT( test_case_num , 1 , bound_test_case_num ); } FINISH_MAIN
#define DEXPR( LL , BOUND , VALUE1 , VALUE2 ) CEXPR( LL , BOUND , VALUE1 )
#define ASSERT( A , MIN , MAX ) AS( ( MIN ) <= A && A <= ( MAX ) )
#define SET_ASSERT( A , MIN , MAX ) SET_LL( A ); ASSERT( A , MIN , MAX )
#define SOLVE_ONLY
#define CERR( ... )
#define COUT( ... ) VariadicCout( cout , __VA_ARGS__ ) << ENDL
#define CERR_A( A , N )
#define COUT_A( A , N ) OUTPUT_ARRAY( cout , A , N ) << ENDL
#define CERR_ITR( A )
#define COUT_ITR( A ) OUTPUT_ITR( cout , A ) << ENDL
#endif
#ifdef REACTIVE
#define ENDL endl
#else
#define ENDL "\n"
#endif
#ifdef USE_GETLINE
#define SET_LL( A ) { GETLINE( A ## _str ); A = stoll( A ## _str ); }
#define GETLINE_SEPARATE( SEPARATOR , ... ) SOLVE_ONLY; string __VA_ARGS__; VariadicGetline( cin , SEPARATOR , __VA_ARGS__ )
#define GETLINE( ... ) SOLVE_ONLY; GETLINE_SEPARATE( '\n' , __VA_ARGS__ )
#else
#define SET_LL( A ) cin >> A
#define CIN( LL , ... ) SOLVE_ONLY; LL __VA_ARGS__; VariadicCin( cin , __VA_ARGS__ )
#define SET_A( I , N , ... ) SOLVE_ONLY; VariadicResize( N + I , __VA_ARGS__ ); FOR( VARIABLE_FOR_SET_A , 0 , N ){ VariadicSet( cin ,
      VARIABLE_FOR_SET_A + I , __VA_ARGS__ ); }
#define CIN_A( LL , I , N , ... ) VE<LL> __VA_ARGS__; SET_A( I , N , __VA_ARGS__ )
#define CIN_AA( LL , I0 , N0 , I1 , N1 , VAR ) VE<VE<LL>> VAR( N0 + I0 ); FOR( VARIABLE_FOR_CIN_AA , 0 , N0 ){ SET_A( I1 , N1 ,
      VAR[VARIABLE_FOR_CIN_AA + I0] ); }
#endif
#include <bits/stdc++.h>
using namespace std;
#define ATT __attribute__( ( target( "sse4.2,fma,avx2,popcnt,lzcnt,bmi2" ) ) )
#define START_MAIN int main(){ ios_base::sync_with_stdio( false ); cin.tie( nullptr )
#define FINISH_MAIN REPEAT( test_case_num ){ if CE( bound_test_case_num > 1 ){ CERR( "testcase " , VARIABLE_FOR_REPEAT_test_case_num , ":" ); } Solve
    (); CERR( "" ); } }
#define START_WATCH chrono::system_clock::time_point watch = chrono::system_clock::now()
#define CURRENT_TIME static_cast<double>( chrono::duration_cast<chrono::microseconds>( chrono::system_clock::now() - watch ).count() / 1000.0 )
#define CHECK_WATCH( TL_MS ) ( CURRENT_TIME < TL_MS - 100.0 )
#define CEXPR( LL , BOUND , VALUE ) CE LL BOUND = VALUE
#define SET_A_ASSERT( I , N , A , MIN , MAX ) FOR( VARIABLE_FOR_SET_A , 0 , N ){ SET_ASSERT( A[VARIABLE_FOR_SET_A + I] , MIN , MAX ); }
#define SET_AA_ASSERT( I0 , N0 , I1 , N1 , A , MIN , MAX ) FOR( VARIABLE_FOR_SET_AA0 , 0 , N0 ){ FOR( VARIABLE_FOR_SET_AA1 , 0 , N1 ){ SET_ASSERT(
    A[VARIABLE_FOR_SET_AA0 + I0][VARIABLE_FOR_SET_AA1 + I1] , MIN , MAX ); } }
#define CIN_ASSERT( A , MIN , MAX ) decldecay_t( MAX ) A; SET_ASSERT( A , MIN , MAX )
#define CIN_A_ASSERT( I , N , A , MIN , MAX ) vector<decldecay_t( MAX )> A( N + I ); SET_A_ASSERT( I , N , A , MIN , MAX )
#define CIN_AA_ASSERT( I0 , N0 , I1 , N1 , A , MIN , MAX ) vector A( N0 + I0 , vector<decldecay_t( MAX )>( N1 + I1 ) ); SET_AA_ASSERT( I0 , N0 , I1 ,
    N1 , A , MIN , MAX )
#define FOR( VAR , INITIAL , FINAL_PLUS_ONE ) for( decldecay_t( FINAL_PLUS_ONE ) VAR = INITIAL ; VAR < FINAL_PLUS_ONE ; VAR ++ )
#define FOREQ( VAR , INITIAL , FINAL ) for( decldecay_t( FINAL ) VAR = INITIAL ; VAR <= FINAL ; VAR ++ )
#define FOREQINV( VAR , INITIAL , FINAL ) for( decldecay_t( INITIAL ) VAR = INITIAL ; VAR + 1 > FINAL ; VAR -- )
#define ITR( ARRAY ) auto begin_ ## ARRAY = ARRAY .BE() , itr_ ## ARRAY = begin_ ## ARRAY , end_ ## ARRAY = ARRAY .EN()
#define FOR_ITR( ARRAY ) for( ITR( ARRAY ) , itr = itr_ ## ARRAY ; itr_ ## ARRAY != end_ ## ARRAY ; itr_ ## ARRAY ++ , itr++ )
#define RUN( ARRAY , ... ) for( auto&& __VA_ARGS__ : ARRAY )
#define REPEAT( HOW_MANY_TIMES ) FOR( VARIABLE_FOR_REPEAT_ ## HOW_MANY_TIMES , 0 , HOW_MANY_TIMES )
#define SET_PRECISION( DECIMAL_DIGITS ) cout << fixed << setprecision( DECIMAL_DIGITS )
#define RETURN( ... ) SOLVE_ONLY; COUT( __VA_ARGS__ ); RE
#define COMPARE( ... ) auto naive = Naive( __VA_ARGS__ ); auto answer = Answer( __VA_ARGS__ ); bool match = naive == answer; COUT( "(" , #__VA_ARGS__
    , ") == (" , __VA_ARGS__ , ") : Naive == " , naive , match ? "==" : "!=" , answer , "== Answer" ); if( !match ){ RE; }
//
#define TE template
#define TY typename
#define US using
#define ST static
#define AS assert
#define IN inline
#define CL class
#define PU public
#define OP operator
#define CE constexpr
#define CO const
#define NE noexcept
#define RE return
#define WH while
#define VO void
#define VE vector
#define LI list
#define BE begin
#define EN end
#define SZ size
#define LE length
#define PW Power
#define MO move
#define TH this
#define CRI CO int&
#define CRUI CO uint&
#define CRL CO ll&
#define VI virtual
#define IS basic_istream<char,Traits>
#define OS basic_ostream<char,Traits>
#define ST_AS static_assert
#define reMO_CO remove_const
#define is_COructible_v is_constructible_v
#define rBE rbegin
#define reSZ resize
//
#define decldecay_t(VAR)decay_t<decltype(VAR)>
TE <TY F,TY...Args> US ret_t = decltype(declval<F>()(declval<Args>()...));
TE <TY T> US inner_t = TY T::type;
US uint = unsigned int;
US ll = long long;
US ull = unsigned long long;
US ld = long double;
US lld = __float128;
TE <TY INT> US T2 = pair<INT,INT>;
TE <TY INT> US T3 = tuple<INT,INT,INT>;
TE <TY INT> US T4 = tuple<INT,INT,INT,INT>;
US path = pair<int,ll>;
//
// EXPRESSIONANSWER調EXPRESSION >= CO_TARGET
#define BS( ANSWER , MINIMUM , MAXIMUM , EXPRESSION , DESIRED_INEQUALITY , CO_TARGET , INEQUALITY_FOR_CHECK , UPDATE_U , UPDATE_L , UPDATE_ANSWER ) \
ST_AS( ! is_same<decldecay_t( CO_TARGET ),uint>::value && ! is_same<decldecay_t( CO_TARGET ),ull>::value ); \
ll ANSWER = MINIMUM; \
{ \
ll L_BS = MINIMUM; \
ll U_BS = MAXIMUM; \
ANSWER = UPDATE_ANSWER; \
ll EXPRESSION_BS; \
CO ll CO_TARGET_BS = ( CO_TARGET ); \
ll DIFFERENCE_BS; \
WH( L_BS < U_BS ){ \
DIFFERENCE_BS = ( EXPRESSION_BS = ( EXPRESSION ) ) - CO_TARGET_BS; \
CERR( "" , "L_BS =" , L_BS , "<=" , #ANSWER , "=" , ANSWER , "<=" , U_BS , "= U_BS : (" , #EXPRESSION , ") =" , EXPRESSION_BS ,
          DIFFERENCE_BS > 0 ? ">" : DIFFERENCE_BS < 0 ? "<" : "=" , CO_TARGET_BS , "= (" , #CO_TARGET , ")" ); \
if( DIFFERENCE_BS INEQUALITY_FOR_CHECK 0 ){ \
U_BS = UPDATE_U; \
} else { \
L_BS = UPDATE_L; \
} \
ANSWER = UPDATE_ANSWER; \
} \
if( L_BS > U_BS ){ \
CERR( "" , "L_BS =" , L_BS , ">" , U_BS , "= U_BS :" , #ANSWER , ":= (" , #MAXIMUM , ") + 1 =" , MAXIMUM + 1 ); \
CERR( "" ); \
ANSWER = MAXIMUM + 1; \
} else { \
CERR( "" , "L_BS =" , L_BS , "<=" , #ANSWER , "=" , ANSWER , "<=" , U_BS , "= U_BS" ); \
CERR( "" , #EXPRESSION , "" ); \
CERR( "" ); \
EXPRESSION_BS = ( EXPRESSION ); \
CERR( " (" , #EXPRESSION , ") =" , EXPRESSION_BS , ( EXPRESSION_BS > CO_TARGET_BS ? ">" : EXPRESSION_BS < CO_TARGET_BS ? "<" : "
          =" ) , CO_TARGET_BS ); \
if( EXPRESSION_BS DESIRED_INEQUALITY CO_TARGET_BS ){ \
CERR( "" , #ANSWER , ":=" , ANSWER ); \
} else { \
CERR( "" , #ANSWER , ":= (" , #MAXIMUM , ") + 1 =" , MAXIMUM + 1 ); \
CERR( "調調調" ); \
ANSWER = MAXIMUM + 1; \
} \
} \
} \
// 調EXPRESSION >= CO_TARGET
#define BS1( ANSWER , MINIMUM , MAXIMUM , EXPRESSION , CO_TARGET ) BS( ANSWER , MINIMUM , MAXIMUM , EXPRESSION , >= , CO_TARGET , >= , ANSWER ,
    ANSWER + 1 , ( L_BS + U_BS ) / 2 )
// 調EXPRESSION <= CO_TARGET
#define BS2( ANSWER , MINIMUM , MAXIMUM , EXPRESSION , CO_TARGET ) BS( ANSWER , MINIMUM , MAXIMUM , EXPRESSION , <= , CO_TARGET , > , ANSWER - 1 ,
    ANSWER , ( L_BS + 1 + U_BS ) / 2 )
// 調EXPRESSION >= CO_TARGET
#define BS3( ANSWER , MINIMUM , MAXIMUM , EXPRESSION , CO_TARGET ) BS( ANSWER , MINIMUM , MAXIMUM , EXPRESSION , >= , CO_TARGET , < , ANSWER - 1 ,
    ANSWER , ( L_BS + 1 + U_BS ) / 2 )
// 調EXPRESSION <= CO_TARGET
#define BS4( ANSWER , MINIMUM , MAXIMUM , EXPRESSION , CO_TARGET ) BS( ANSWER , MINIMUM , MAXIMUM , EXPRESSION , <= , CO_TARGET , <= , ANSWER ,
    ANSWER + 1 , ( L_BS + U_BS ) / 2 )
//
// VAR_TPA_LVAR_TPA_RINITVAR_TPA_RCONTINUE_CONDITION
// [VAR_TPA_L,VAR_TPA_R]ON_CONDITION
// trueVAR_TAR_LVAR_TAR_RVAR_TPA_LUPDATE_L
// VAR_TPA_RUPDATE_R
// ON_CONDITIONtrueINFOANSWER
#define TPA( ANSWER , VAR_TPA , INIT , CONTINUE_CONDITION , UPDATE_L , UPDATE_R , ON_CONDITION , INFO ) \
VE<tuple<decldecay_t( INIT ),decldecay_t( INIT ),decldecay_t( INFO )>> ANSWER{}; \
{ \
auto init_TPA = INIT; \
decldecay_t( ANSWER.front() ) ANSWER ## _temp = { init_TPA , init_TPA , INFO }; \
auto ANSWER ## _prev = ANSWER ## _temp; \
auto& VAR_TPA ## _L = get<0>( ANSWER ## _temp ); \
auto& VAR_TPA ## _R = get<1>( ANSWER ## _temp ); \
auto& VAR_TPA ## _info = get<2>( ANSWER ## _temp ); \
bool on_TPA_prev = false; \
WH( true ){ \
bool continuing = CONTINUE_CONDITION; \
bool on_TPA = continuing && ( ON_CONDITION ); \
CERR( continuing ? "" : "" , " [L,R] = [" , VAR_TPA ## _L , "," , VAR_TPA ## _R , "] ," , on_TPA_prev ? "on" : "off" , "->"
          , on_TPA ? "on" : "off" , ", info =" , VAR_TPA ## _info ); \
if( on_TPA_prev && ! on_TPA ){ \
ANSWER.push_back( ANSWER ## _prev ); \
} \
if( continuing ){ \
if( on_TPA || VAR_TPA ## _L == VAR_TPA ## _R ){ \
ANSWER ## _prev = ANSWER ## _temp; \
UPDATE_R; \
} else { \
UPDATE_L; \
} \
} else { \
break; \
} \
on_TPA_prev = on_TPA; \
} \
} \
//
TE <TY T> IN T Addition(CO T& t0,CO T& t1){RE t0 + t1;}
TE <TY T> IN T Xor(CO T& t0,CO T& t1){RE t0 ^ t1;}
TE <TY T> IN T MU(CO T& t0,CO T& t1){RE t0 * t1;}
TE <TY T> IN CO T& Zero(){ST CO T z{};RE z;}
TE <TY T> IN CO T& One(){ST CO T o = 1;RE o;}TE <TY T> IN T AdditionInv(CO T& t){RE -t;}
TE <TY T> IN T Id(CO T& v){RE v;}
TE <TY T> IN T Min(CO T& a,CO T& b){RE a < b?a:b;}
TE <TY T> IN T Max(CO T& a,CO T& b){RE a < b?b:a;}
// VVV
#ifdef DEBUG
#include "C:/Users/user/Documents/Programming/Contest/Template/include/a_Body.hpp"
#else
// Random1KB
ll GetRand(CRI Rand_min,CRI Rand_max){AS(Rand_min <= Rand_max);ll AN = time(NULL);RE AN * rand()%(Rand_max + 1 - Rand_min)+ Rand_min;}
// Map (2KB)
#define DC_OF_HASH(...)struct hash<__VA_ARGS__>{IN size_t OP()(CO __VA_ARGS__& n)CO;};
CL is_ordered{PU:is_ordered()= delete;TE <TY T> ST CE auto Check(CO T& t)-> decltype(t < t,true_type());ST CE false_type Check(...);TE <TY T> ST CE
    CO bool value = is_same_v< decltype(Check(declval<T>())),true_type >;};
TE <TY T>US Set = conditional_t<is_COructible_v<unordered_set<T>>,unordered_set<T>,conditional_t<is_ordered::value<T>,set<T>,VO>>;
#define DF_OF_AR_FOR_MAP(MAP,OPR)TE <TY T,TY U> IN MAP<T,U>& OP OPR ## =(MAP<T,U>& a,CO pair<T,U>& v){a[v.first]OPR ## = v.second;RE a;}TE <TY T,TY U
    > IN MAP<T,U>& OP OPR ## =(MAP<T,U>& a0,CO MAP<T,U>& a1){for(auto&[t,u]:a1){a0[t]OPR ## = u;}RE a0;}TE <TY T,TY U,TY ARG> IN MAP<T,U> OP OPR(MAP
    <T,U> a,CO ARG& arg){RE MO(a OPR ## = arg);}
#define DF_OF_ARS_FOR_MAP(MAP)DF_OF_AR_FOR_MAP(MAP,+);DF_OF_AR_FOR_MAP(MAP,-);DF_OF_AR_FOR_MAP(MAP,*);DF_OF_AR_FOR_MAP(MAP,/);DF_OF_AR_FOR_MAP(MAP,%
    );
TE <TY T,TY U>US Map = conditional_t<is_COructible_v<unordered_map<T,int>>,unordered_map<T,U>,conditional_t<is_ordered::value<T>,map<T,U>,VO>>;
DF_OF_ARS_FOR_MAP(map);DF_OF_ARS_FOR_MAP(unordered_map);
// Tuple3KB
#define DF_OF_AR_FOR_TUPLE(OPR)TE <TY T,TY U,TE <TY...> TY V> IN auto OP OPR ## =(V<T,U>& t0,CO V<T,U>& t1)-> decltype((get<0>(t0),t0))&{get<0>(t0
    )OPR ## = get<0>(t1);get<1>(t0)OPR ## = get<1>(t1);RE t0;}TE <TY T,TY U,TY V> IN tuple<T,U,V>& OP OPR ## =(tuple<T,U,V>& t0,CO tuple<T,U,V>& t1
    ){get<0>(t0)OPR ## = get<0>(t1);get<1>(t0)OPR ## = get<1>(t1);get<2>(t0)OPR ## = get<2>(t1);RE t0;}TE <TY T,TY U,TY V,TY W> IN tuple<T,U,V,W>& OP
    OPR ## =(tuple<T,U,V,W>& t0,CO tuple<T,U,V,W>& t1){get<0>(t0)OPR ## = get<0>(t1);get<1>(t0)OPR ## = get<1>(t1);get<2>(t0)OPR ## = get<2>(t1);get
    <3>(t0)OPR ## = get<3>(t1);RE t0;}TE <TE <TY...> TY V,TY...ARGS> IN auto OP OPR(CO V<ARGS...>& t0,CO V<ARGS...>& t1)-> decldecay_t((get<0>(t0),t0
    )){auto t = t0;RE MO(t OPR ## = t1);}
#define DF_OF_HASH_FOR_TUPLE(PAIR)TE <TY T,TY U> IN size_t hash<PAIR<T,U>>::OP()(CO PAIR<T,U>& n)CO{ST CO size_t seed =(GetRand(1e3,1e8)<< 1)| 1;ST
    CO hash<T> h0;ST CO hash<U> h1;RE(h0(get<0>(n))* seed)^ h1(get<1>(n));}
#define DF_OF_INCREMENT_FOR_TUPLE(INCR)TE <TY T,TY U,TE <TY...> TY V> IN auto OP INCR(V<T,U>& t)-> decldecay_t((get<0>(t),t))&{INCR get<0>(t);INCR
    get<1>(t);RE t;}TE <TY T,TY U,TY V> IN tuple<T,U,V>& OP INCR(tuple<T,U,V>& t){INCR get<0>(t);INCR get<1>(t);INCR get<2>(t);RE t;}TE <TY T,TY U,TY
    V,TY W> IN tuple<T,U,V,W>& OP INCR(tuple<T,U,V,W>& t){INCR get<0>(t);INCR get<1>(t);INCR get<2>(t);INCR get<3>(t);RE t;}
TE <CL Traits,TY T,TY U,TE <TY...> TY V> IN auto OP>>(IS& is,V<T,U>& arg)-> decltype((get<0>(arg),is))&{RE is >> get<0>(arg)>> get<1>(arg);}TE <CL
    Traits,TY T,TY U,TY V> IN IS& OP>>(IS& is,tuple<T,U,V>& arg){RE is >> get<0>(arg)>> get<1>(arg)>> get<2>(arg);}TE <CL Traits,TY T,TY U,TY V,TY W>
    IN IS& OP>>(IS& is,tuple<T,U,V,W>& arg){RE is >> get<0>(arg)>> get<1>(arg)>> get<2>(arg)>> get<3>(arg);}TE <CL Traits,TY T,TY U,TE <TY...> TY V>
    IN auto OP<<(OS& os,CO V<T,U>& arg)-> decltype((get<0>(arg),os))&{RE os << get<0>(arg)<< " " << get<1>(arg);}TE <CL Traits,TY T,TY U,TY V> IN OS&
    OP<<(OS& os,CO tuple<T,U,V>& arg){RE os << get<0>(arg)<< " " << get<1>(arg)<< " " << get<2>(arg);}TE <CL Traits,TY T,TY U,TY V,TY W> IN OS& OP
    <<(OS& os,CO tuple<T,U,V,W>& arg){RE os << get<0>(arg)<< " " << get<1>(arg)<< " " << get<2>(arg)<< " " << get<3>(arg);}DF_OF_AR_FOR_TUPLE
    (+);DF_OF_AR_FOR_TUPLE(-);DF_OF_AR_FOR_TUPLE(*);DF_OF_AR_FOR_TUPLE(/);DF_OF_AR_FOR_TUPLE(%);DF_OF_INCREMENT_FOR_TUPLE
    (++);DF_OF_INCREMENT_FOR_TUPLE(--);
TE <TY T> DC_OF_HASH(tuple<T>);TE <TY T,TY U> DC_OF_HASH(pair<T,U>);TE <TY T,TY U> DC_OF_HASH(tuple<T,U>);TE <TY T,TY U,TY V> DC_OF_HASH(tuple<T,U,V
    >);TE <TY T,TY U,TY V,TY W> DC_OF_HASH(tuple<T,U,V,W>);
TE <TY T> IN size_t hash<tuple<T>>::OP()(CO tuple<T>& n)CO{ST CO hash<T> h;RE h(get<0>(n));}DF_OF_HASH_FOR_TUPLE(pair);DF_OF_HASH_FOR_TUPLE(tuple);TE
    <TY T,TY U,TY V> IN size_t hash<tuple<T,U,V>>::OP()(CO tuple<T,U,V>& n)CO{ST CO size_t seed =(GetRand(1e3,1e8)<< 1)| 1;ST CO hash<pair<T,U>> h01
    ;ST CO hash<V> h2;RE(h01({get<0>(n),get<1>(n)})* seed)^ h2(get<2>(n));}TE <TY T,TY U,TY V,TY W> IN size_t hash<tuple<T,U,V,W>>::OP()(CO tuple<T,U
    ,V,W>& n)CO{ST CO size_t seed =(GetRand(1e3,1e8)<< 1)| 1;ST CO hash<pair<T,U>> h01;ST CO hash<pair<V,W>> h23;RE(h01({get<0>(n),get<1>(n)})* seed
    )^ h23({get<2>(n),get<3>(n)});}
// Vector2KB
#define DF_OF_COUT_FOR_VE(V)TE <CL Traits,TY Arg> IN OS& OP<<(OS& os,CO V<Arg>& arg){auto BE = arg.BE(),EN = arg.EN();auto IT = BE;WH(IT != EN){(IT
    == BE?os:os << " ")<< *IT;IT++;}RE os;}
#define DF_OF_AR_FOR_VE(V,OPR)TE <TY T> IN V<T>& OP OPR ## =(V<T>& a,CO T& t){for(auto& s:a){s OPR ## = t;}RE a;}TE <TY T> IN V<T>& OP OPR ## =(V<T>&
    a0,CO V<T>& a1){AS(a0.SZ()<= a1.SZ());auto IT0 = a0.BE(),EN0 = a0.EN();auto IT1 = a1.BE();WH(IT0 != EN0){*(IT0++)OPR ## = *(IT1++);}RE a0;}TE <TY
    T,TY U> IN V<T> OP OPR(V<T> a,CO U& u){RE MO(a OPR ## = u);}
#define DF_OF_INCREMENT_FOR_VE(V,INCR)TE <TY T> IN V<T>& OP INCR(V<T>& a){for(auto& i:a){INCR i;}RE a;}
#define DF_OF_ARS_FOR_VE(V)DF_OF_AR_FOR_VE(V,+);DF_OF_AR_FOR_VE(V,-);DF_OF_AR_FOR_VE(V,*);DF_OF_AR_FOR_VE(V,/);DF_OF_AR_FOR_VE(V,%
    );DF_OF_INCREMENT_FOR_VE(V,++);DF_OF_INCREMENT_FOR_VE(V,--);TE <TY T> IN V<T> OP*(CO T& scalar,V<T> v){for(auto& t:v){v *= t;}RE MO(v);}
DF_OF_COUT_FOR_VE(VE);DF_OF_COUT_FOR_VE(LI);DF_OF_COUT_FOR_VE(set);DF_OF_COUT_FOR_VE(unordered_set);DF_OF_ARS_FOR_VE(VE);DF_OF_ARS_FOR_VE(LI);IN VO
    VariadicResize(CRI SZ){}TE <TY Arg,TY... ARGS> IN VO VariadicResize(CRI SZ,Arg& arg,ARGS&... args){arg.resize(SZ);VariadicResize(SZ,args...);}TE
    <TY T> VO sort(VE<T>& a,CO bool& reversed = false){if(reversed){ST auto comp =[](CO T& t0,CO T& t1){RE t1 < t0;};sort(a.BE(),a.EN(),comp
    );}else{sort(a.BE(),a.EN());}}TE <TY V> IN auto Get(V& a){RE[&](CRI i = 0)-> CO decldecay_t(a[0])&{RE a[i];};}TE <TY T = int> IN VE<T> id(CRI SZ
    ){VE<T> AN(SZ);FOR(i,0,SZ){AN[i]= i;}RE AN;}
// StdStream1KB
TE <CL Traits> IN IS& VariadicCin(IS& is){RE is;}TE <CL Traits,TY Arg,TY... ARGS> IN IS& VariadicCin(IS& is,Arg& arg,ARGS&... args){RE VariadicCin(is
    >> arg,args...);}TE <CL Traits> IN IS& VariadicSet(IS& is,CRI i){RE is;}TE <CL Traits,TY Arg,TY... ARGS> IN IS& VariadicSet(IS& is,CRI i,Arg& arg
    ,ARGS&... args){RE VariadicSet(is >> arg[i],i,args...);}TE <CL Traits> IN IS& VariadicGetline(IS& is,CO char& separator){RE is;}TE <CL Traits,TY
    Arg,TY... ARGS> IN IS& VariadicGetline(IS& is,CO char& separator,Arg& arg,ARGS&... args){RE VariadicGetline(getline(is,arg,separator),separator
    ,args...);}TE <CL Traits,TY Arg> IN OS& VariadicCout(OS& os,CO Arg& arg){RE os << arg;}TE <CL Traits,TY Arg1,TY Arg2,TY... ARGS> IN OS&
    VariadicCout(OS& os,CO Arg1& arg1,CO Arg2& arg2,CO ARGS&... args){RE VariadicCout(os << arg1 << " ",arg2,args...);}
// Module (6KB)
#define DC_OF_CPOINT(POINT)IN CO U& POINT()CO NE
#define DC_OF_POINT(POINT)IN U& POINT()NE
#define DF_OF_CPOINT(POINT)TE <TY U> IN CO U& VirtualPointedSet<U>::POINT()CO NE{RE Point();}
#define DF_OF_POINT(POINT)TE <TY U> IN U& VirtualPointedSet<U>::POINT()NE{RE Point();}
TE <TY U>CL UnderlyingSet{PU:US type = U;};TE <TY U>CL VirtualPointedSet:VI PU UnderlyingSet<U>{PU:VI CO U& Point()CO NE = 0;VI U& Point()NE = 0
    ;DC_OF_CPOINT(Unit);DC_OF_CPOINT(Zero);DC_OF_CPOINT(One);DC_OF_CPOINT(Infty);DC_OF_POINT(init);DC_OF_POINT(root);};TE <TY U>CL PointedSet:VI PU
    VirtualPointedSet<U>{PU:U m_b_U;IN PointedSet(U b_u = U());IN CO U& Point()CO NE;IN U& Point()NE;};TE <TY U>CL VirtualNSet:VI PU UnderlyingSet<U
    >{PU:VI U Transfer(CO U& u)= 0;IN U Inverse(CO U& u);};TE <TY U,TY F_U>CL AbstractNSet:VI PU VirtualNSet<U>{PU:F_U m_f_U;IN AbstractNSet(F_U f_U
    );IN AbstractNSet<U,F_U>& OP=(CO AbstractNSet&)NE;IN U Transfer(CO U& u);};TE <TY U>CL VirtualMagma:VI PU UnderlyingSet<U>{PU:VI U Product(U u0
    ,CO U& u1)= 0;IN U Sum(U u0,CO U& u1);};TE <TY U = ll>CL AdditiveMagma:VI PU VirtualMagma<U>{PU:IN U Product(U u0,CO U& u1);};TE <TY U = ll>CL
    MultiplicativeMagma:VI PU VirtualMagma<U>{PU:IN U Product(U u0,CO U& u1);};TE <TY U,TY M_U>CL AbstractMagma:VI PU VirtualMagma<U>{PU:M_U m_m_U;IN
    AbstractMagma(M_U m_U);IN AbstractMagma<U,M_U>& OP=(CO AbstractMagma<U,M_U>&)NE;IN U Product(U u0,CO U& u1);};
TE <TY U> IN PointedSet<U>::PointedSet(U b_U):m_b_U(MO(b_U)){}TE <TY U> IN CO U& PointedSet<U>::Point()CO NE{RE m_b_U;}TE <TY U> IN U& PointedSet<U
    >::Point()NE{RE m_b_U;}DF_OF_CPOINT(Unit);DF_OF_CPOINT(Zero);DF_OF_CPOINT(One);DF_OF_CPOINT(Infty);DF_OF_POINT(init);DF_OF_POINT(root);TE <TY U
    ,TY F_U> IN AbstractNSet<U,F_U>::AbstractNSet(F_U f_U):m_f_U(MO(f_U)){ST_AS(is_invocable_r_v<U,F_U,U>);}TE <TY U,TY F_U> IN AbstractNSet<U,F_U>&
    AbstractNSet<U,F_U>::operator=(CO AbstractNSet<U,F_U>&)NE{RE *TH;}TE <TY U,TY F_U> IN U AbstractNSet<U,F_U>::Transfer(CO U& u){RE m_f_U(u);}TE
    <TY U> IN U VirtualNSet<U>::Inverse(CO U& u){RE Transfer(u);}TE <TY U,TY M_U> IN AbstractMagma<U,M_U>::AbstractMagma(M_U m_U):m_m_U(MO(m_U
    )){ST_AS(is_invocable_r_v<U,M_U,U,U>);}TE <TY U,TY M_U> IN AbstractMagma<U,M_U>& AbstractMagma<U,M_U>::OP=(CO AbstractMagma<U,M_U>&)NE{RE *TH;}TE
    <TY U> IN U AdditiveMagma<U>::Product(U u0,CO U& u1){RE MO(u0 += u1);}TE <TY U> IN U MultiplicativeMagma<U>::Product(U u0,CO U& u1){RE MO(u0 *=
    u1);}TE <TY U,TY M_U> IN U AbstractMagma<U,M_U>::Product(U u0,CO U& u1){RE m_m_U(MO(u0),u1);}TE <TY U> IN U VirtualMagma<U>::Sum(U u0,CO U& u1
    ){RE Product(MO(u0),u1);}
TE <TY U>CL VirtualMonoid:VI PU VirtualMagma<U>,VI PU VirtualPointedSet<U>{};TE <TY U = ll>CL AdditiveMonoid:VI PU VirtualMonoid<U>,PU AdditiveMagma
    <U>,PU PointedSet<U>{};TE <TY U = ll>CL MultiplicativeMonoid:VI PU VirtualMonoid<U>,PU MultiplicativeMagma<U>,PU PointedSet<U>{PU:IN
    MultiplicativeMonoid(U e_U);};TE <TY U,TY M_U>CL AbstractMonoid:VI PU VirtualMonoid<U>,PU AbstractMagma<U,M_U>,PU PointedSet<U>{PU:IN
    AbstractMonoid(M_U m_U,U e_U);};
TE <TY U> IN MultiplicativeMonoid<U>::MultiplicativeMonoid(U e_U):PointedSet<U>(MO(e_U)){}TE <TY U,TY M_U> IN AbstractMonoid<U,M_U>::AbstractMonoid
    (M_U m_U,U e_U):AbstractMagma<U,M_U>(MO(m_U)),PointedSet<U>(MO(e_U)){}
TE <TY U>CL VirtualGroup:VI PU VirtualMonoid<U>,VI PU VirtualPointedSet<U>,VI PU VirtualNSet<U>{};TE <TY U = ll>CL AdditiveGroup:VI PU VirtualGroup<U
    >,PU AdditiveMonoid<U>{PU:IN U Transfer(CO U& u);};TE <TY U,TY M_U,TY I_U>CL AbstractGroup:VI PU VirtualGroup<U>,PU AbstractMonoid<U,M_U>,PU
    AbstractNSet<U,I_U>{PU:IN AbstractGroup(M_U m_U,U e_U,I_U i_U);};
TE <TY U,TY M_U,TY I_U> IN AbstractGroup<U,M_U,I_U>::AbstractGroup(M_U m_U,U e_U,I_U i_U):AbstractMonoid<U,M_U>(MO(m_U),MO(e_U)),AbstractNSet<U,I_U
    >(MO(i_U)){}TE <TY U> IN U AdditiveGroup<U>::Transfer(CO U& u){RE -u;}
TE <TY R,TY U>CL VirtualRSet:VI PU UnderlyingSet<U>{PU:VI U Action(CO R& r,U u)= 0;IN U PW(U u,CO R& r);IN U ScalarProduct(CO R& r,U u);};TE <TY U,TY
    MAGMA>CL RegularRSet:VI PU VirtualRSet<U,U>,PU MAGMA{PU:IN RegularRSet(MAGMA magma);IN U Action(CO U& r,U u);};TE <TY MAGMA> RegularRSet(MAGMA
    magma)-> RegularRSet<inner_t<MAGMA>,MAGMA>;TE <TY R,TY U,TY O_U>CL AbstractRSet:VI PU VirtualRSet<R,U>{PU:O_U m_o_U;IN AbstractRSet(CO R& dummy0
    ,CO U& dummy1,O_U o_U);IN AbstractRSet<R,U,O_U>& OP=(CO AbstractRSet<R,U,O_U>&)NE;IN U Action(CO R& r,U u);};TE <TY R,TY U,TY O_U,TY GROUP>CL
    AbstractModule:PU AbstractRSet<R,U,O_U>,PU GROUP{PU:IN AbstractModule(CO R& dummy,O_U o_U,GROUP M);};TE <TY R,TY O_U,TY GROUP> AbstractModule(CO
    R& dummy,O_U o_U,GROUP M)-> AbstractModule<R,inner_t<GROUP>,O_U,GROUP>;TE <TY R,TY U>CL Module:VI PU VirtualRSet<R,U>,PU AdditiveGroup<U>{PU:IN U
    Action(CO R& r,U u);};
TE <TY R,TY MAGMA> IN RegularRSet<R,MAGMA>::RegularRSet(MAGMA magma):MAGMA(MO(magma)){}TE <TY R,TY U,TY O_U> IN AbstractRSet<R,U,O_U>::AbstractRSet
    (CO R& dummy0,CO U& dummy1,O_U o_U):m_o_U(MO(o_U)){ST_AS(is_invocable_r_v<U,O_U,R,U>);}TE <TY R,TY U,TY O_U,TY GROUP> IN AbstractModule<R,U,O_U
    ,GROUP>::AbstractModule(CO R& dummy,O_U o_U,GROUP M):AbstractRSet<R,U,O_U>(dummy,M.One(),MO(o_U)),GROUP(MO(M)){ST_AS(is_same_v<U,inner_t<GROUP
    >>);}TE <TY R,TY U,TY O_U> IN AbstractRSet<R,U,O_U>& AbstractRSet<R,U,O_U>::OP=(CO AbstractRSet<R,U,O_U>&)NE{RE *TH;}TE <TY U,TY MAGMA> IN U
    RegularRSet<U,MAGMA>::Action(CO U& r,U u){RE TH->Product(r,MO(u));}TE <TY R,TY U,TY O_U> IN U AbstractRSet<R,U,O_U>::Action(CO R& r,U u){RE m_o_U
    (r,MO(u));}TE <TY R,TY U> IN U Module<R,U>::Action(CO R& r,U u){RE MO(u *= r);}TE <TY R,TY U> IN U VirtualRSet<R,U>::PW(U u,CO R& r){RE Action(r
    ,MO(u));}TE <TY R,TY U> IN U VirtualRSet<R,U>::ScalarProduct(CO R& r,U u){RE Action(r,MO(u));}
// Graph (5KB)
TE <TY T,TY R1,TY R2,TY E>CL VirtualGraph:VI PU UnderlyingSet<T>{PU:VI R1 Enumeration(CRI i)= 0;IN R2 Enumeration_inv(CO T& t);TE <TY PATH> IN R2
    Enumeration_inv(CO PATH& p);IN VO Reset();VI CRI SZ()CO NE = 0;VI E& edge()NE = 0;VI ret_t<E,T> Edge(CO T& t)= 0;TE <TY PATH> IN ret_t<E,T> Edge
    (CO PATH& p);ST IN CO T& Vertex(CO T& t)NE;TE <TY PATH> ST IN CO T& Vertex(CO PATH& e)NE;VI R2 Enumeration_inv_Body(CO T& t)= 0;};TE <TY T,TY R1
    ,TY R2,TY E>CL EdgeImplimentation:VI PU VirtualGraph<T,R1,R2,E>{PU:int m_SZ;E m_edge;IN EdgeImplimentation(CRI SZ,E edge);IN CRI SZ()CO NE;IN E&
    edge()NE;IN ret_t<E,T> Edge(CO T& t);};TE <TY E>CL Graph:PU EdgeImplimentation<int,CRI,CRI,E>{PU:IN Graph(CRI SZ,E edge);IN CRI Enumeration(CRI i
    );TE <TY F> IN Graph<F> GetGraph(F edge)CO;IN CRI Enumeration_inv_Body(CRI t);};TE <TY T,TY Enum_T,TY Enum_T_inv,TY E>CL EnumerationGraph:PU
    EdgeImplimentation<T,ret_t<Enum_T,int>,ret_t<Enum_T_inv,T>,E>{PU:Enum_T m_enum_T;Enum_T_inv m_enum_T_inv;IN EnumerationGraph(CRI SZ,Enum_T enum_T
    ,Enum_T_inv enum_T_inv,E edge);IN ret_t<Enum_T,int> Enumeration(CRI i);TE <TY F> IN EnumerationGraph<T,Enum_T,Enum_T_inv,F> GetGraph(F edge)CO;IN
    ret_t<Enum_T_inv,T> Enumeration_inv_Body(CO T& t);};TE <TY Enum_T,TY Enum_T_inv,TY E> EnumerationGraph(CRI SZ,Enum_T enum_T,Enum_T_inv enum_T_inv
    ,E edge)-> EnumerationGraph<decldecay_t(declval<Enum_T>()(0)),Enum_T,Enum_T_inv,E>;TE <TY T,TY E>CL MemorisationGraph:PU EdgeImplimentation<T,T
    ,CRI,E>{PU:int m_LE;VE<T> m_memory;Map<T,int> m_memory_inv;IN MemorisationGraph(CRI SZ,CO T& dummy,E edge);IN T Enumeration(CRI i);IN VO Reset
    ();TE <TY F> IN MemorisationGraph<T,F> GetGraph(F edge)CO;IN CRI Enumeration_inv_Body(CO T& t);};
TE <TY T,TY R1,TY R2,TY E> IN EdgeImplimentation<T,R1,R2,E>::EdgeImplimentation(CRI SZ,E edge):m_SZ(SZ),m_edge(MO(edge)){ST_AS(is_COructible_v<T,R1>
    && is_COructible_v<int,R2> && is_invocable_v<E,T>);}TE <TY E> IN Graph<E>::Graph(CRI SZ,E edge):EdgeImplimentation<int,CRI,CRI,E>(SZ,MO(edge
    )){}TE <TY T,TY Enum_T,TY Enum_T_inv,TY E> IN EnumerationGraph<T,Enum_T,Enum_T_inv,E>::EnumerationGraph(CRI SZ,Enum_T enum_T,Enum_T_inv
    enum_T_inv,E edge):EdgeImplimentation<T,ret_t<Enum_T,int>,ret_t<Enum_T_inv,T>,E>(SZ,MO(edge)),m_enum_T(MO(enum_T)),m_enum_T_inv(MO(enum_T_inv
    )){}TE <TY T,TY E> IN MemorisationGraph<T,E>::MemorisationGraph(CRI SZ,CO T& dummy,E edge):EdgeImplimentation<T,T,CRI,E>(SZ,MO(edge)),m_LE
    (),m_memory(),m_memory_inv(){ST_AS(is_invocable_v<E,T>);}TE <TY E> IN CRI Graph<E>::Enumeration(CRI i){RE i;}TE <TY T,TY Enum_T,TY Enum_T_inv,TY
    E> IN ret_t<Enum_T,int> EnumerationGraph<T,Enum_T,Enum_T_inv,E>::Enumeration(CRI i){RE m_enum_T(i);}TE <TY T,TY E> IN T MemorisationGraph<T,E
    >::Enumeration(CRI i){AS(0 <= i && i < m_LE);RE m_memory[i];}TE <TY T,TY R1,TY R2,TY E> IN R2 VirtualGraph<T,R1,R2,E>::Enumeration_inv(CO T& t
    ){RE Enumeration_inv_Body(t);}TE <TY T,TY R1,TY R2,TY E> TE <TY PATH> IN R2 VirtualGraph<T,R1,R2,E>::Enumeration_inv(CO PATH& p){RE
    Enumeration_inv_Body(get<0>(p));}TE <TY E> IN CRI Graph<E>::Enumeration_inv_Body(CRI i){RE i;}TE <TY T,TY Enum_T,TY Enum_T_inv,TY E> IN ret_t
    <Enum_T_inv,T> EnumerationGraph<T,Enum_T,Enum_T_inv,E>::Enumeration_inv_Body(CO T& t){RE m_enum_T_inv(t);}TE <TY T,TY E> IN CRI MemorisationGraph
    <T,E>::Enumeration_inv_Body(CO T& t){if(m_memory_inv.count(t)== 0){AS(m_LE < TH->SZ());m_memory.push_back(t);RE m_memory_inv[t]= m_LE++;}RE
    m_memory_inv[t];}TE <TY T,TY R1,TY R2,TY E> VO VirtualGraph<T,R1,R2,E>::Reset(){}TE <TY T,TY E> IN VO MemorisationGraph<T,E>::Reset(){m_LE = 0
    ;m_memory.clear();m_memory_inv.clear();}TE <TY T,TY R1,TY R2,TY E> IN CRI EdgeImplimentation<T,R1,R2,E>::SZ()CO NE{RE m_SZ;}TE <TY T,TY R1,TY R2
    ,TY E> IN E& EdgeImplimentation<T,R1,R2,E>::edge()NE{RE m_edge;}TE <TY T,TY R1,TY R2,TY E> IN ret_t<E,T> EdgeImplimentation<T,R1,R2,E>::Edge(CO
    T& t){RE m_edge(t);}TE <TY T,TY R1,TY R2,TY E> TE <TY PATH> IN ret_t<E,T> VirtualGraph<T,R1,R2,E>::Edge(CO PATH& p){RE Edge(get<0>(p));}TE <TY E>
    TE <TY F> IN Graph<F> Graph<E>::GetGraph(F edge)CO{RE Graph<F>(TH->SZ(),MO(edge));}TE <TY T,TY Enum_T,TY Enum_T_inv,TY E> TE <TY F> IN
    EnumerationGraph<T,Enum_T,Enum_T_inv,F> EnumerationGraph<T,Enum_T,Enum_T_inv,E>::GetGraph(F edge)CO{RE EnumerationGraph<T,Enum_T,Enum_T_inv,F>(TH
    ->SZ(),m_enum_T,m_enum_T_inv,MO(edge));}TE <TY T,TY E> TE <TY F> IN MemorisationGraph<T,F> MemorisationGraph<T,E>::GetGraph(F edge)CO{RE
    MemorisationGraph<T,F>(TH->SZ(),MO(edge));}TE <TY T,TY R1,TY R2,TY E> IN CO T& VirtualGraph<T,R1,R2,E>::Vertex(CO T& t)NE{RE t;}TE <TY T,TY R1,TY
    R2,TY E> TE <TY PATH> IN CO T& VirtualGraph<T,R1,R2,E>::Vertex(CO PATH& e)NE{RE Vertex(get<0>(e));}
// Grid (2KB)
#define SET_GRID H_minus = H - 1;W_minus = W - 1;HW = ll(H)* W
#define SET_HW(h,w)H = h;W = w;SET_GRID
#define CIN_HW cin >> H >> W;SET_GRID
TE <TY E>CL GridGraph:PU EnumerationGraph<T2<int>,T2<int>(&)(CRI),int(&)(CO T2<int>&),E>{PU:IN GridGraph(E e);};int H,W,H_minus,W_minus;ll HW;VE
    <string> grid;char walkable = '.',unwalkable = '#';
IN T2<int> EnumHW(CRI v){RE{v / W,v % W};}IN int EnumHW_inv(CO T2<int>& ij){auto&[i,j]= ij;RE i * W + j;}TE <TY E> IN GridGraph<E>::GridGraph(E e
    ):EnumerationGraph<T2<int>,T2<int>(&)(CRI),int(&)(CO T2<int>&),E>(HW,EnumHW,EnumHW_inv,MO(e)){AS(HW >> 31 == 0 && H * W == HW);}VE<T2<int>>
    EdgeOnGrid(CO T2<int>& v){VE<T2<int>> AN{};auto&[i,j]= v;if(i > 0 && grid[i-1][j]== walkable){AN.push_back({i-1,j});}if(i+1 < H && grid[i+1][j]==
    walkable){AN.push_back({i+1,j});}if(j > 0 && grid[i][j-1]== walkable){AN.push_back({i,j-1});}if(j+1 < W && grid[i][j+1]== walkable){AN.push_back
    ({i,j+1});}RE AN;}VE<pair<T2<int>,ll>> WEdgeOnGrid(CO T2<int>& v){VE<pair<T2<int>,ll>> AN{};auto&[i,j]= v;if(i>0 && grid[i-1][j]== walkable){AN
    .push_back({{i-1,j},1});}if(i+1 < H && grid[i+1][j]== walkable){AN.push_back({{i+1,j},1});}if(j>0 && grid[i][j-1]== walkable){AN.push_back({{i,j
    -1},1});}if(j+1 < W && grid[i][j+1]== walkable){AN.push_back({{i,j+1},1});}RE AN;}IN VO SetWallStringOnGrid(CRI i,VE<string>& S){if(S.empty()){S
    .resize(H);}cin >> S[i];AS(int(S[i].SZ())== W);}CO string direction="URDL";IN int DirectionNumberOnGrid(CRI i,CRI j,CRI k,CRI h){RE i < k?2:i > k
    ?0:j < h?1:(AS(j > h),3);}IN int DirectionNumberOnGrid(CO T2<int>& v,CO T2<int>& w){auto&[i,j]= v;auto&[k,h]= w;RE DirectionNumberOnGrid(i,j,k,h
    );}IN int DirectionNumberOnGrid(CRI v,CRI w){RE DirectionNumberOnGrid(EnumHW(v),EnumHW(w));}IN int ReverseDirectionNumberOnGrid(CRI n){AS(0 <= n
    && n<4);RE n ^ 2;}
// ConstexprModulo (7KB)
CEXPR(uint,P,998244353);
#define RP Represent
#define DeRP Derepresent
TE <uint M,TY INT> CE INT RS(INT n)NE{RE MO(n < 0?((((++n)*= -1)%= M)*= -1)+= M - 1:n < INT(M)?n:n %= M);}TE <TY INT> CE INT& RSP(INT& n)NE{CE CO
    uint trunc =(1 << 23)- 1;INT n_u = n >> 23;n &= trunc;INT n_uq =(n_u / 7)/ 17;n_u -= n_uq * 119;n += n_u << 23;RE n < n_uq?n += P - n_uq:n -=
    n_uq;}
TE <uint M> CL Mod;TE <uint M>CL COantsForMod{PU:COantsForMod()= delete;ST CE CO uint g_memory_bound = 1e6;ST CE CO uint g_memory_LE = M <
    g_memory_bound?M:g_memory_bound;ST CE uint g_M_minus = M - 1;ST CE int g_order_minus_1 = M - 2;ST CE int g_order_minus_1_neg = -g_order_minus_1;}
    ;
#define SFINAE_FOR_MOD enable_if_t<is_COructible_v<uint,decay_t<T>>>*
#define DC_OF_CM_FOR_MOD(OPR)CE bool OP OPR(CO Mod<M>& n)CO NE
#define DC_OF_AR_FOR_MOD(OPR,EX)CE Mod<M> OP OPR(Mod<M> n)CO EX;
#define DF_OF_CM_FOR_MOD(OPR)TE <uint M> CE bool Mod<M>::OP OPR(CO Mod<M>& n)CO NE{RE m_n OPR n.m_n;}
#define DF_OF_AR_FOR_MOD(OPR,EX,LEFT,OPR2)TE <uint M> CE Mod<M> Mod<M>::OP OPR(Mod<M> n)CO EX{RE MO(LEFT OPR2 ## = *TH);}TE <uint M,TY T
    ,SFINAE_FOR_MOD = nullptr> CE Mod<M> OP OPR(T n0,CO Mod<M>& n1)EX{RE MO(Mod<M>(MO(n0))OPR ## = n1);}
TE <uint M>CL Mod{PU:uint m_n;CE Mod()NE;CE Mod(CO Mod<M>& n)NE;CE Mod(Mod<M>&& n)NE;TE <TY T,SFINAE_FOR_MOD = nullptr> CE Mod(T n)NE;CE Mod<M>& OP
    =(Mod<M> n)NE;CE Mod<M>& OP+=(CO Mod<M>& n)NE;CE Mod<M>& OP-=(CO Mod<M>& n)NE;CE Mod<M>& OP*=(CO Mod<M>& n)NE;IN Mod<M>& OP/=(Mod<M> n);TE <TY
    INT> CE Mod<M>& OP<<=(INT n);TE <TY INT> CE Mod<M>& OP>>=(INT n);CE Mod<M>& OP++()NE;CE Mod<M> OP++(int)NE;CE Mod<M>& OP--()NE;CE Mod<M> OP--(int
    )NE;DC_OF_CM_FOR_MOD(==);DC_OF_CM_FOR_MOD(!=);DC_OF_CM_FOR_MOD(<);DC_OF_CM_FOR_MOD(<=);DC_OF_CM_FOR_MOD(>);DC_OF_CM_FOR_MOD(>=);DC_OF_AR_FOR_MOD
    (+,NE);DC_OF_AR_FOR_MOD(-,NE);DC_OF_AR_FOR_MOD(*,NE);DC_OF_AR_FOR_MOD(/,);TE <TY INT> CE Mod<M> OP^(INT EX)CO;TE <TY INT> CE Mod<M> OP<<(INT n)CO
    ;TE <TY INT> CE Mod<M> OP>>(INT n)CO;CE Mod<M> OP-()CO NE;CE Mod<M>& SignInvert()NE;IN Mod<M>& Invert();TE <TY INT> CE Mod<M>& PW(INT EX);CE VO
    swap(Mod<M>& n)NE;CE CRUI RP()CO NE;ST CE Mod<M> DeRP(uint n)NE;ST IN CO Mod<M>& Inverse(CRUI n);ST IN CO Mod<M>& Factorial(CRUI n);ST IN CO Mod
    <M>& FactorialInverse(CRUI n);ST IN Mod<M> Combination(CRUI n,CRUI i);ST IN CO Mod<M>& zero()NE;ST IN CO Mod<M>& one()NE;TE <TY INT> CE Mod<M>&
    PositivePW(INT EX)NE;TE <TY INT> CE Mod<M>& NonNegativePW(INT EX)NE;US COants = COantsForMod<M>;};
US MP = Mod<P>;
TE <uint M> CE Mod<M>::Mod()NE:m_n(){}TE <uint M> CE Mod<M>::Mod(CO Mod<M>& n)NE:m_n(n.m_n){}TE <uint M> CE Mod<M>::Mod(Mod<M>&& n)NE:m_n(MO(n.m_n
    )){}TE <uint M> TE <TY T,SFINAE_FOR_MOD> CE Mod<M>::Mod(T n)NE:m_n(RS<M>(MO(n))){}TE <uint M> CE Mod<M>& Mod<M>::OP=(Mod<M> n)NE{m_n = MO(n.m_n
    );RE *TH;}TE <uint M> CE Mod<M>& Mod<M>::OP+=(CO Mod<M>& n)NE{(m_n += n.m_n)< M?m_n:m_n -= M;RE *TH;}TE <uint M> CE Mod<M>& Mod<M>::OP-=(CO Mod<M
    >& n)NE{m_n < n.m_n?(m_n += M)-= n.m_n:m_n -= n.m_n;RE *TH;}TE <uint M> CE Mod<M>& Mod<M>::OP*=(CO Mod<M>& n)NE{m_n = MO(ull(m_n)* n.m_n)% M;RE
    *TH;}TE <> CE MP& MP::OP*=(CO MP& n)NE{ull m_n_copy = m_n;m_n = MO((m_n_copy *= n.m_n)< P?m_n_copy:RSP(m_n_copy));RE *TH;}TE <uint M> IN Mod<M>&
    Mod<M>::OP/=(Mod<M> n){RE OP*=(n.Invert());}TE <uint M> TE <TY INT> CE Mod<M>& Mod<M>::OP<<=(INT n){AS(n >= 0);RE *TH *= Mod<M>(2).NonNegativePW
    (MO(n));}TE <uint M> TE <TY INT> CE Mod<M>& Mod<M>::OP>>=(INT n){AS(n >=0);WH(n-- > 0){((m_n & 1)== 0?m_n:m_n += M)>>= 1;}RE *TH;}TE <uint M> CE
    Mod<M>& Mod<M>::OP++()NE{m_n < COants::g_M_minus?++m_n:m_n = 0;RE *TH;}TE <uint M> CE Mod<M> Mod<M>::OP++(int)NE{Mod<M> n{*TH};OP++();RE n;}TE
    <uint M> CE Mod<M>& Mod<M>::OP--()NE{m_n == 0?m_n = COants::g_M_minus:--m_n;RE *TH;}TE <uint M> CE Mod<M> Mod<M>::OP--(int)NE{Mod<M> n{*TH};OP
    --();RE n;}DF_OF_CM_FOR_MOD(==);DF_OF_CM_FOR_MOD(!=);DF_OF_CM_FOR_MOD(>);DF_OF_CM_FOR_MOD(>=);DF_OF_CM_FOR_MOD(<);DF_OF_CM_FOR_MOD
    (<=);DF_OF_AR_FOR_MOD(+,NE,n,+);DF_OF_AR_FOR_MOD(-,NE,n.SignInvert(),+);DF_OF_AR_FOR_MOD(*,NE,n,*);DF_OF_AR_FOR_MOD(/,,n.Invert(),*);TE <uint M>
    TE <TY INT> CE Mod<M> Mod<M>::OP^(INT EX)CO{RE MO(Mod<M>(*TH).PW(MO(EX)));}TE <uint M> TE <TY INT> CE Mod<M> Mod<M>::OP<<(INT n)CO{RE MO(Mod<M
    >(*TH)<<= MO(n));}TE <uint M> TE <TY INT> CE Mod<M> Mod<M>::OP>>(INT n)CO{RE MO(Mod<M>(*TH)>>= MO(n));}TE <uint M> CE Mod<M> Mod<M>::OP-()CO
    NE{RE MO(Mod<M>(*TH).SignInvert());}TE <uint M> CE Mod<M>& Mod<M>::SignInvert()NE{m_n > 0?m_n = M - m_n:m_n;RE *TH;}TE <uint M> IN Mod<M>& Mod<M
    >::Invert(){AS(m_n != 0);uint m_n_neg;RE m_n < COants::g_memory_LE?(m_n = Inverse(m_n).m_n,*TH):((m_n_neg = M - m_n)< COants::g_memory_LE)?(m_n =
    M - Inverse(m_n_neg).m_n,*TH):NonNegativePW(COants::g_order_minus_1);}TE <uint M> TE <TY INT> CE Mod<M>& Mod<M>::PositivePW(INT EX)NE{Mod<M> PW{
    *TH};EX--;WH(EX != 0){(EX & 1)== 1?*TH *= PW:*TH;EX >>= 1;PW *= PW;}RE *TH;}TE <uint M> TE <TY INT> CE Mod<M>& Mod<M>::NonNegativePW(INT EX)NE{RE
    EX == 0?(m_n = 1,*TH):PositivePW(MO(EX));}TE <uint M> TE <TY INT> CE Mod<M>& Mod<M>::PW(INT EX){bool neg = EX < 0;AS(!(neg && m_n == 0));RE neg
    ?PositivePW(MO(EX *= COants::g_order_minus_1_neg)):NonNegativePW(MO(EX));}TE <uint M> CE VO Mod<M>::swap(Mod<M>& n)NE{std::swap(m_n,n.m_n);}TE
    <uint M> IN CO Mod<M>& Mod<M>::Inverse(CRUI n){AS(n < COants::g_memory_LE);ST Mod<M> memory[COants::g_memory_LE]={zero(),one()};ST uint LE_curr =
    2;WH(LE_curr <= n){memory[LE_curr].m_n = M - memory[M % LE_curr].m_n * ull(M / LE_curr)% M;LE_curr++;}RE memory[n];}TE <uint M> IN CO Mod<M>& Mod
    <M>::Factorial(CRUI n){if(M <= n){RE zero();}AS(n < COants::g_memory_LE);ST Mod<M> memory[COants::g_memory_LE]={one(),one()};ST uint LE_curr = 2
    ;WH(LE_curr <= n){(memory[LE_curr]= memory[LE_curr - 1])*= LE_curr;LE_curr++;}RE memory[n];}TE <uint M> IN CO Mod<M>& Mod<M>::FactorialInverse
    (CRUI n){ST Mod<M> memory[COants::g_memory_LE]={one(),one()};ST uint LE_curr = 2;WH(LE_curr <= n){(memory[LE_curr]= memory[LE_curr - 1])*=
    Inverse(LE_curr);LE_curr++;}RE memory[n];}TE <uint M> IN Mod<M> Mod<M>::Combination(CRUI n,CRUI i){RE i <= n?Factorial(n)* FactorialInverse(i)*
    FactorialInverse(n - i):zero();}TE <uint M> CE CRUI Mod<M>::RP()CO NE{RE m_n;}TE <uint M> CE Mod<M> Mod<M>::DeRP(uint n)NE{Mod<M> n_copy{};n_copy
    .m_n = MO(n);RE n_copy;}TE <uint M> IN CO Mod<M>& Mod<M>::zero()NE{ST CE CO Mod<M> z{};RE z;}TE <uint M> IN CO Mod<M>& Mod<M>::one()NE{ST CE CO
    Mod<M> o{1};RE o;}TE <uint M> IN Mod<M> Inverse(CO Mod<M>& n){RE MO(Mod<M>(n).Invert());}TE <uint M,TY INT> CE Mod<M> PW(Mod<M> n,INT EX){RE MO(n
    .PW(MO(EX)));}TE <uint M> CE VO swap(Mod<M>& n0,Mod<M>& n1)NE{n0.swap(n1);}TE <uint M> IN string to_string(CO Mod<M>& n)NE{RE to_string(n.RP())+
    " + " + to_string(M)+ "Z";}TE <uint M,CL Traits> IN IS& OP>>(IS& is,Mod<M>& n){ll m;is >> m;n = m;RE is;}TE <uint M,CL Traits> IN OS& OP<<(OS& os
    ,CO Mod<M>& n){RE os << n.RP();}
#define DF_OF_HASH_FOR_MOD(MOD)IN size_t hash<MOD>::OP()(CO MOD& n)CO{ST CO hash<decldecay_t(n.RP())> h;RE h(n.RP());}
TE <uint M> DC_OF_HASH(Mod<M>); TE <uint M> DF_OF_HASH_FOR_MOD(Mod<M>);
#endif
// AAA
#define INCLUDE_LIBRARY
#include __FILE__
#endif // INCLUDE_LIBRARY
#endif // INCLUDE_SUB
#endif // INCLUDE_MAIN
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0