// 誤解法（区間和をフェニック木の区間和取得で処理）チェック
#ifndef INCLUDE_MODE
  #define INCLUDE_MODE
  // #define REACTIVE
  // #define USE_GETLINE
#endif

#ifdef INCLUDE_MAIN

inline void Solve()
{
  // Nの入力受け取り
  CEXPR( int , bound_N , 1e7 );
  CIN_ASSERT( N , 1 , bound_N );

  // Bの入力受け取り
  CEXPR( ll , bound_B , 1e9 );
  CIN_ASSERT( B , 1 , bound_B );
  
  // Qの入力受け取り
  CEXPR( int , bound_Q , 1e6 );
  CIN_ASSERT( Q , 1 , bound_Q );

  // 合同式での四則演算を扱う型の法をBに設定
  QuotientRing<ll>::SetStaticModulo( &B );

  // C_1,D_1の入力受け取りとAの初期値計算
  CEXPR( ll , bound_CD1 , 1e9 );
  CIN_ASSERT( C_1 , 0 , bound_CD1 );
  CIN_ASSERT( D_1 , 0 , bound_CD1 );
  QuotientRing<ll> A_0 = C_1;
  QuotientRing<ll> R_1 = D_1;
  // A_1,...,A_{N-1}を格納
  vector<QuotientRing<ll>> A( N - 1 , A_0 * R_1 );
  FOR( i , 1 , N - 1 ){
    A[i] = A[i-1] * R_1;
  }
  // フェニック木を(A_1,...,A_{N-1})で初期化
  BIT<QuotientRing<ll>> bit{ A };

  // C_2,D_2の入力受け取りとi_qの初期値計算
  CEXPR( ll , bound_CD2 , 1e7 );
  CIN_ASSERT( C_2 , 0 , bound_CD2 );
  CIN_ASSERT( D_2 , 0 , bound_CD2 );
  ll i_q = move( C_2 %= N );

  // C_3,D_3の入力受け取りとj_qの初期値計算
  CEXPR( ll , bound_CD3 , 1e7 );
  CIN_ASSERT( C_3 , 0 , bound_CD3 );
  CIN_ASSERT( D_3 , 0 , bound_CD3 );
  ll j_q = move( C_3 %= N );

  // C_4,D_4の入力受け取りとx_q mod Bの初期値計算
  CEXPR( ll , bound_CD4 , 1e9 );
  CIN_ASSERT( C_4 , 0 , bound_CD4 );
  CIN_ASSERT( D_4 , 0 , bound_CD4 );
  QuotientRing<ll> x_q = C_4;
  QuotientRing<ll> D_4_mod_B = D_4;

  // C_5,D_5の入力受け取りとy_q mod Bの初期値計算
  CEXPR( ll , bound_CD5 , 1e9 );
  CIN_ASSERT( C_5 , 0 , bound_CD5 );
  CIN_ASSERT( D_5 , 0 , bound_CD5 );
  QuotientRing<ll> y_q = C_5;
  QuotientRing<ll> D_5_mod_B = D_5;

  REPEAT( Q ){
    // Aのi個目の成分をxに変更
    if( i_q == 0 ){
      A_0 = x_q;
    } else {
      bit.Set( i_q - 1 , x_q );
    }

    // f(j_q,y_q)を格納する変数
    QuotientRing<ll> fjy{};
    // y_q羃をBで割った余りを格納する変数
    QuotientRing<ll> y_power{ 1 };
    int j = j_q;
    while( j > 0 ){
      int j_next = j - ( j & -j );
      // fjyにy_q羃とAの区間和の積を加算
      fjy += y_power * bit.IntervalSum( j_next , j - 1 );
      // y羃を更新
      y_power *= y_q;
      // jを更新
      j = j_next;
    }
    // 最高次の寄与も加算
    fjy += y_power * A_0;

    // 最終的なfjyの値を出力
    const ll& answer = fjy.Represent();
    COUT( answer < 0 ? answer + B : answer );

    // クエリを更新
    ( i_q *= D_2 ) %= N;
    ( j_q *= D_3 ) %= N;
    x_q *= D_4_mod_B;
    y_q *= D_5_mod_B;
  }
}
REPEAT_MAIN(1);

#else // INCLUDE_MAIN

#ifdef INCLUDE_SUB

// グラフ用
template <typename T , template <typename...> typename V> inline auto Get( const V<T>& a ) { return [&]( const int& i ){ return a[i]; }; }

// VVV テンプレート引数用の関数は以下に挿入する。














// AAA テンプレート引数用の関数は以上に挿入する。

#define INCLUDE_MAIN
#include __FILE__

#else // INCLUDE_SUB

#ifdef INCLUDE_LIBRARY

// https://github.com/p-adic/cpp
// VVV ライブラリは以下に挿入する。

template <typename INT>
class QuotientRing
{

protected:
  INT m_n;
  const INT* m_p_M;
  static const INT* g_p_M;

public:
  inline QuotientRing() noexcept;
  inline QuotientRing( const INT& n , const INT* const& p_M = g_p_M ) noexcept;
  inline QuotientRing( const QuotientRing<INT>& n ) noexcept;

  inline QuotientRing<INT>& operator+=( const QuotientRing<INT>& n ) noexcept;
  template <typename T> inline QuotientRing<INT>& operator+=( const T& n ) noexcept;
  // operator<が定義されていても負の数は正に直さず剰余を取ることに注意。
  inline QuotientRing<INT>& operator-=( const QuotientRing<INT>& n ) noexcept;
  template <typename T> inline QuotientRing<INT>& operator-=( const T& n ) noexcept;
  inline QuotientRing<INT>& operator*=( const QuotientRing<INT>& n ) noexcept;
  template <typename T> inline QuotientRing<INT>& operator*=( const T& n ) noexcept;
  // *m_p_Mが素数でかつnの逆元が存在する場合のみサポート。
  inline QuotientRing<INT>& operator/=( const QuotientRing<INT>& n );
  template <typename T> inline QuotientRing<INT>& operator/=( const T& n );

  // m_nの正負やm_p_Mの一致込みの等号。
  inline bool operator==( const QuotientRing<INT>& n ) const noexcept;
  // m_nの正負込みの等号。
  template <typename T> inline bool operator==( const T& n ) const noexcept;
  template <typename T> inline bool operator!=( const T& n ) const noexcept;

  template <typename T> inline QuotientRing<INT> operator+( const T& n1 ) const noexcept;
  inline QuotientRing<INT> operator-() const noexcept;
  template <typename T> inline QuotientRing<INT> operator-( const T& n1 ) const noexcept;
  template <typename T> inline QuotientRing<INT> operator*( const T& n1 ) const noexcept;
  // *m_p_Mが素数でかつn1の逆元が存在する場合のみサポート。
  template <typename T> inline QuotientRing<INT> operator/( const T& n1 ) const;

  inline const INT& Represent() const noexcept;
  inline const INT& GetModulo() const noexcept;
  inline void SetModulo( const INT* const& p_M = nullptr ) noexcept;
  static inline const INT& GetStaticModulo() noexcept;
  static inline void SetStaticModulo( const INT* const& p_M ) noexcept;

  template <typename T> static QuotientRing<INT> Power( const QuotientRing<INT>& n , T exponent );
  // *m_p_Mが素数でかつnの逆元が存在する場合のみサポート。
  static QuotientRing<INT> Inverse( const QuotientRing<INT>& n );
  
};

template <typename INT , typename T> inline QuotientRing<INT> Power( const QuotientRing<INT>& n , T exponent );
// *(n.m_p_M)が素数でかつnの逆元が存在する場合のみサポート。
template <typename INT> inline QuotientRing<INT> Inverse( const QuotientRing<INT>& n );

template <typename INT , class Traits> inline basic_istream<char,Traits>& operator>>( basic_istream<char,Traits>& is , QuotientRing<INT>& n );
template <typename INT , class Traits> inline basic_ostream<char,Traits>& operator<<( basic_ostream<char,Traits>& os , const QuotientRing<INT>& n );



template <typename INT> const INT* QuotientRing<INT>::g_p_M = nullptr;
template <typename INT> inline QuotientRing<INT>::QuotientRing() noexcept : m_n() , m_p_M( g_p_M ) {}
template <typename INT> inline QuotientRing<INT>::QuotientRing( const INT& n , const INT* const& p_M ) noexcept : m_n( p_M == nullptr ? n : n % *p_M ) , m_p_M( p_M ) {}
template <typename INT> inline QuotientRing<INT>::QuotientRing( const QuotientRing<INT>& n ) noexcept : m_n( n.m_n ) , m_p_M( n.m_p_M ) {}

template <typename INT> inline QuotientRing<INT>& QuotientRing<INT>::operator+=( const QuotientRing<INT>& n ) noexcept { if( m_p_M == nullptr ){ m_p_M = n.m_p_M; } m_n += n.m_n; if( m_p_M != nullptr ){ m_n %= *m_p_M; } return *this; }
template <typename INT> template <typename T> inline QuotientRing<INT>& QuotientRing<INT>::operator+=( const T& n ) noexcept { m_p_M == nullptr ? m_n += n : ( m_n += n % *m_p_M ) %= *m_p_M; return *this; }
template <typename INT> inline QuotientRing<INT>& QuotientRing<INT>::operator-=( const QuotientRing<INT>& n ) noexcept { if( m_p_M == nullptr ){ m_p_M = n.m_p_M; } m_n -= n.m_n; if( m_p_M != nullptr ){ m_n %= *m_p_M; } return *this; }
template <typename INT> template <typename T> inline QuotientRing<INT>& QuotientRing<INT>::operator-=( const T& n ) noexcept { m_p_M == nullptr ? m_n -= n : ( m_n -= n % *m_p_M ) %= *m_p_M; return *this; }
template <typename INT> inline QuotientRing<INT>& QuotientRing<INT>::operator*=( const QuotientRing<INT>& n ) noexcept { if( m_p_M == nullptr ){ m_p_M = n.m_p_M; } m_n *= n.m_n; if( m_p_M != nullptr ){ m_n %= *m_p_M; } return *this; }
template <typename INT> template <typename T> inline QuotientRing<INT>& QuotientRing<INT>::operator*=( const T& n ) noexcept { m_p_M == nullptr ? m_n *= n : ( m_n *= n % *m_p_M ) %= *m_p_M; return *this; }
template <typename INT> inline QuotientRing<INT>& QuotientRing<INT>::operator/=( const QuotientRing<INT>& n ) { if( m_p_M == nullptr ){ if( n.m_p_M == nullptr ){ assert( n.m_n != 0 ); m_n /= n.m_n; return *this; } else { m_p_M = n.m_p_M; } } return operator*=( Inverse( QuotientRing<INT>( n.m_n , m_p_M ) ) ); }
template <typename INT> template <typename T> inline QuotientRing<INT>& QuotientRing<INT>::operator/=( const T& n ) { if( m_p_M == nullptr ){ assert( n.m_n != 0 ); m_n /= n.m_n; return *this; } return operator*=( Inverse( Q( n.m_n , m_p_M ) ) ); }

template <typename INT> inline bool QuotientRing<INT>::operator==( const QuotientRing<INT>& n ) const noexcept { return m_p_M == n.m_p_M && m_n == n.m_n; }
template <typename INT> template <typename T> inline bool QuotientRing<INT>::operator==( const T& n ) const noexcept { return m_n == n; }
template <typename INT> template <typename T> inline bool QuotientRing<INT>::operator!=( const T& n ) const noexcept { return !operator==( n ); }

template <typename INT> template<typename T> inline QuotientRing<INT> QuotientRing<INT>::operator+( const T& n ) const noexcept { return QuotientRing<INT>( *this ).operator+=( n ); }
template <typename INT> inline QuotientRing<INT> QuotientRing<INT>::operator-() const noexcept { return QuotientRing<INT>( -m_n , m_p_M ); }
template <typename INT> template<typename T> inline QuotientRing<INT> QuotientRing<INT>::operator-( const T& n ) const noexcept { return QuotientRing<INT>( *this ).operator-=( n ); }
template <typename INT> template<typename T> inline QuotientRing<INT> QuotientRing<INT>::operator*( const T& n ) const noexcept { return QuotientRing<INT>( *this ).operator*=( n ); }
template <typename INT> template<typename T> inline QuotientRing<INT> QuotientRing<INT>::operator/( const T& n ) const { return QuotientRing<INT>( *this ).operator/=( n ); }
  
template <typename INT> inline const INT& QuotientRing<INT>::Represent() const noexcept { return m_n; }
template <typename INT> inline const INT& QuotientRing<INT>::GetModulo() const noexcept { static const INT zero{ 0 }; return m_p_M == nullptr ? zero : *m_p_M; }
template <typename INT> inline void QuotientRing<INT>::SetModulo( const INT* const& p_M ) noexcept { m_p_M = p_M; if( m_p_M != nullptr ){ m_n %= *m_p_M; } }
template <typename INT> inline const INT& QuotientRing<INT>::GetStaticModulo() noexcept { static const INT zero{ 0 }; return g_p_M == nullptr ? zero : *g_p_M; }
template <typename INT> inline void QuotientRing<INT>::SetStaticModulo( const INT* const& p_M ) noexcept { g_p_M = p_M; }

template <typename INT> template <typename T>
QuotientRing<INT> QuotientRing<INT>::Power( const QuotientRing<INT>& n , T exponent )
{

  QuotientRing<INT> answer{ 1 , n.m_p_M };
  QuotientRing<INT> power{ n };

  while( exponent != 0 ){

    if( exponent % 2 == 1 ){

      answer *= power;

    }

    power *= power;
    exponent /= 2;

  }

  return answer;

}

template <typename INT> inline QuotientRing<INT> QuotientRing<INT>::Inverse( const QuotientRing<INT>& n ) { assert( n.m_p_M != nullptr ); return Power( n , *( n.m_p_M ) - 2 ); }

template <typename INT , typename T> inline QuotientRing<INT> Power( const QuotientRing<INT>& n , T exponent ) { return QuotientRing<INT>::template Power<T>( n , exponent ); }
template <typename INT> inline QuotientRing<INT> Inverse( const QuotientRing<INT>& n ) { return QuotientRing<INT>::Inverse( n ); }

template <typename INT , class Traits> inline basic_istream<char,Traits>& operator>>( basic_istream<char,Traits>& is , QuotientRing<INT>& n ) { INT m; is >> m; n = m; return is; }
template <typename INT , class Traits> inline basic_ostream<char,Traits>& operator<<( basic_ostream<char,Traits>& os , const QuotientRing<INT>& n ) { return os << n.Represent(); }

// 使用演算：
// U& U::operator=( const U& )
// U& U::operator+=( const U& )
// U operator-( const U& , const U& )（ただしIntervalSumを用いない場合は不要）
// U operator<( const U& , const U& )（ただしBinarySearchを用いない場合は不要）

// U()による初期化O(size)
// 配列による初期化O(size)

// 一点更新O(log_2 size)
// +による一点更新O(log_2 size)
// 配列の加算による全体更新O(size)

// 一点取得O(log_2 size)
// LSB切片和取得O(1)
// 始切片和取得O(log_2 size)
// 区間和取得O(log_2 size)

// 始切片和がn以上となる要素の添字の最小値の二分探索O(log_2 size)
template <typename U>
class BIT
{
private:
  int m_size;
  vector<U> m_fenwick;

  // m_size以上である最小の2羃。
  int m_power;

public:
  inline BIT( const int& size = 0 );
  BIT( const vector<U>& a );

  inline BIT<U>& operator=( BIT<U>&& a );

  inline void Set( const int& i , const U& u );
  inline void Set( const vector<U>& a );
  inline void Initialise( const int& size = 0 );

  inline BIT<U>& operator+=( const vector<U>& a );
  void Add( const int& i , const U& u );

  inline const int& size() const noexcept;
  // const参照でないことに注意。
  inline U operator[]( const int& i ) const;
  inline U Get( const int& i ) const;
  // a[j-(j&-j)]+...+a[j-1]を返す。
  inline const U& LSBSegmentSum( const int& j ) const;
  // a[0]+...+a[i_final]を返す。
  U InitialSegmentSum( const int& i_final ) const;
  // a[i_start]+...+a[i_final]を返す。
  inline U IntervalSum( const int& i_start , const int& i_final ) const;
  
  // operator+=の単位元U()より小さくない要素のみを成分に持つ場合のみサポート。
  // InitialSegmentSum( i )がn以上となるiが存在する場合にその最小値を2進法で探索。
  // 存在しない場合はsize以上の最小の2羃×2-1を返す（size以上であることで判定可能）。
  int BinarySearch( const U& u ) const;
  // IntervalSum( i_start , i )がu以上となるi_start以上のiが存在する場合にその最小値を2進法で探索。
  // 存在しない場合はsize以上の最小の2羃×2-1を返す（size以上であることで判定可能）。
  inline int BinarySearch( const int& i_start , const U& u ) const;
  
};

template <typename U> inline BIT<U>::BIT( const int& size ) : m_size( size ) , m_fenwick( m_size + 1 ) , m_power( 1 ) { static_assert( ! is_same<U,int>::value ); while( m_power < m_size ){ m_power <<= 1; } }

template <typename U>
BIT<U>::BIT( const vector<U>& a ) : BIT( a.size() )
{

  for( int j = 1 ; j <= m_size ; j++ ){

    U& fenwick_j = m_fenwick[j];
    int i = j - 1;
    fenwick_j = a[i];
    int i_lim = j - ( j & -j );

    while( i > i_lim ){

      fenwick_j += m_fenwick[i];
      i -= ( i & -i );

    }

  }

}

template <typename U> inline void BIT<U>::Set( const int& i , const U& u ) { Add( i , u - IntervalSum( i , i ) ); }
template <typename U> inline void BIT<U>::Set( const vector<U>& a ) { *this = BIT<U>{ a }; }
template <typename U> inline void BIT<U>::Initialise( const int& size ) { *this = BIT<U>( size ); }

template <typename U> inline BIT<U>& BIT<U>::operator+=( const vector<U>& a ) { BIT<U> a_copy{ a }; assert( m_size == a.m_size ); for( int j = 1 ; j <= m_size ; j++ ){ m_fenwick[j] += a.m_fenwick[j]; } return *this; }

template <typename U>
void BIT<U>::Add( const int& i , const U& u )
{

  assert( 0 <= i && i < m_size );
  int j = i + 1;

  while( j <= m_size ){

    m_fenwick[j] += u;
    j += ( j & -j );

  }

  return;
  
}

template <typename U> inline const int& BIT<U>::size() const noexcept { return m_size; }
template <typename U> inline U BIT<U>::operator[]( const int& i ) const { assert( 0 <= i && i < m_size ); return IntervalSum( i , i ); }
template <typename U> inline U BIT<U>::Get( const int& i ) const { return operator[]( i ); }
template <typename U> inline const U& BIT<U>::LSBSegmentSum( const int& j ) const { assert( 0 < j && j <= m_size ); return m_fenwick[j]; }

template <typename U> 
U BIT<U>::InitialSegmentSum( const int& i_final ) const
{

  U sum = 0;
  int j = ( i_final < m_size ? i_final : m_size - 1 ) + 1;

  while( j > 0 ){

    sum += m_fenwick[j];
    j -= j & -j;
    
  }

  return sum;
  
}

template <typename U> inline U BIT<U>::IntervalSum( const int& i_start , const int& i_final ) const { return InitialSegmentSum( i_final ) - InitialSegmentSum( i_start - 1 ); }


template <typename U>
int BIT<U>::BinarySearch( const U& u ) const
{

  int power = m_power;
  int j = 0;
  U sum{};
  U sum_next{};
  
  while( power > 0 ){

    int j_next = j | power;

    if( j_next < m_size ){
      
      sum_next += m_fenwick[j_next];

      if( sum_next < u ){
	
	sum = sum_next;
	j = j_next;

      } else {

	sum_next = sum;
	
      }
      
    }
    
    power >>= 1;

  }

  // InitialSegmentSum( i )がu未満となるiが存在するならばjはその最大値に1を足したものとなり、
  // InitialSegmentSum( i )がu未満となるiが存在しないならばj=0となり、
  // いずれの場合もInitialSegmentSum( i )がu以上となるiが存在するならば
  // jはそのような最小のiと等しい。
  return j;

}

template <typename U> inline int BIT<U>::BinarySearch( const int& i_start , const U& u ) const { return max( i_start , BinarySearch( InitialSegmentSum( i_start ) + u ) ); }

// AAA ライブラリは以上に挿入する。

#define INCLUDE_SUB
#include __FILE__

#else // INCLUDE_LIBRARY

#ifdef DEBUG
  #define _GLIBCXX_DEBUG
  #define SIGNAL signal( SIGABRT , &AlertAbort );
  #define DEXPR( LL , BOUND , VALUE , DEBUG_VALUE ) CEXPR( LL , BOUND , DEBUG_VALUE )
  #define ASSERT( A , MIN , MAX ) CERR( "ASSERTチェック： " , ( MIN ) , ( ( MIN ) <= A ? "<=" : ">" ) , A , ( A <= ( MAX ) ? "<=" : ">" ) , ( MAX ) ); assert( ( MIN ) <= A && A <= ( MAX ) )
  #define CERR( ... ) VariadicCout( cerr , __VA_ARGS__ ) << endl
  #define COUT( ... ) VariadicCout( cout << "出力： " , __VA_ARGS__ ) << endl
  #define CERR_A( A , N ) OUTPUT_ARRAY( cerr , A , N ) << endl
  #define COUT_A( A , N ) cout << "出力： "; OUTPUT_ARRAY( cout , A , N ) << endl
  #define CERR_ITR( A ) OUTPUT_ITR( cerr , A ) << endl
  #define COUT_ITR( A ) cout << "出力： "; OUTPUT_ITR( cout , A ) << endl
#else
  #pragma GCC optimize ( "O3" )
  #pragma GCC optimize ( "unroll-loops" )
  #pragma GCC target ( "sse4.2,fma,avx2,popcnt,lzcnt,bmi2" )
  #define SIGNAL 
  #define DEXPR( LL , BOUND , VALUE , DEBUG_VALUE ) CEXPR( LL , BOUND , VALUE )
  #define ASSERT( A , MIN , MAX ) assert( ( MIN ) <= A && A <= ( MAX ) )
  #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 , ... ) string __VA_ARGS__; VariadicGetline( cin , SEPARATOR , __VA_ARGS__ )
  #define GETLINE( ... ) GETLINE_SEPARATE( '\n' , __VA_ARGS__ )
#else
  #define SET_LL( A ) cin >> A
  #define CIN( LL , ... ) LL __VA_ARGS__; VariadicCin( cin , __VA_ARGS__ )
  #define SET_A( A , N ) FOR( VARIABLE_FOR_CIN_A , 0 , N ){ cin >> A[VARIABLE_FOR_CIN_A]; }
  #define CIN_A( LL , A , N ) vector<LL> A( N ); SET_A( A , N );
#endif
#include <bits/stdc++.h>
using namespace std;
#define REPEAT_MAIN( BOUND ) int main(){ ios_base::sync_with_stdio( false ); cin.tie( nullptr ); SIGNAL; DEXPR( int , bound_test_case_num , BOUND , min( BOUND , 100 ) ); int test_case_num = 1; if constexpr( bound_test_case_num > 1 ){ SET_ASSERT( test_case_num , 1 , bound_test_case_num ); } REPEAT( test_case_num ){ if constexpr( 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 ) constexpr LL BOUND = VALUE
#define SET_ASSERT( A , MIN , MAX ) SET_LL( A ); ASSERT( A , MIN , MAX )
#define CIN_ASSERT( A , MIN , MAX ) decldecay_t( MAX ) A; SET_ASSERT( 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 AUTO_ITR( ARRAY ) auto itr_ ## ARRAY = ARRAY .begin() , end_ ## ARRAY = ARRAY .end()
#define FOR_ITR( ARRAY ) for( AUTO_ITR( ARRAY ) , itr = itr_ ## ARRAY ; itr_ ## ARRAY != end_ ## ARRAY ; itr_ ## ARRAY ++ , itr++ )
#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 OUTPUT_ARRAY( OS , A , N ) FOR( VARIABLE_FOR_OUTPUT_ARRAY , 0 , N ){ OS << A[VARIABLE_FOR_OUTPUT_ARRAY] << (VARIABLE_FOR_OUTPUT_ARRAY==N-1?"":" "); } OS
#define OUTPUT_ITR( OS , A ) { auto ITERATOR_FOR_OUTPUT_ITR = A.begin() , END_FOR_OUTPUT_ITR = A.end(); bool VARIABLE_FOR_OUTPUT_ITR = ITERATOR_FOR_COUT_ITR != END_FOR_COUT_ITR; while( VARIABLE_FOR_OUTPUT_ITR ){ OS << *ITERATOR_FOR_COUT_ITR; ( VARIABLE_FOR_OUTPUT_ITR = ++ITERATOR_FOR_COUT_ITR != END_FOR_COUT_ITR ) ? OS : OS << " "; } } OS
#define RETURN( ... ) COUT( __VA_ARGS__ ); return

// 型のエイリアス
#define decldecay_t( VAR ) decay_t<decltype( VAR )>
template <typename F , typename...Args> using ret_t = decltype( declval<F>()( declval<Args>()... ) );
template <typename T> using inner_t = typename T::type;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using lld = __float128;
template <typename INT> using T2 = pair<INT,INT>;
template <typename INT> using T3 = tuple<INT,INT,INT>;
template <typename INT> using T4 = tuple<INT,INT,INT,INT>;

// 入出力用
template <class Traits> inline basic_istream<char,Traits>& VariadicCin( basic_istream<char,Traits>& is ) { return is; }
template <class Traits , typename Arg , typename... ARGS> inline basic_istream<char,Traits>& VariadicCin( basic_istream<char,Traits>& is , Arg& arg , ARGS&... args ) { return VariadicCin( is >> arg , args... ); }
template <class Traits> inline basic_istream<char,Traits>& VariadicGetline( basic_istream<char,Traits>& is , const char& separator ) { return is; }
template <class Traits , typename Arg , typename... ARGS> inline basic_istream<char,Traits>& VariadicGetline( basic_istream<char,Traits>& is , const char& separator , Arg& arg , ARGS&... args ) { return VariadicGetline( getline( is , arg , separator ) , separator , args... ); }
template <class Traits , typename Arg> inline basic_ostream<char,Traits>& operator<<( basic_ostream<char,Traits>& os , const vector<Arg>& arg ) { auto begin = arg.begin() , end = arg.end(); auto itr = begin; while( itr != end ){ ( itr == begin ? os : os << " " ) << *itr; itr++; } return os; }
template <class Traits , typename Arg> inline basic_ostream<char,Traits>& VariadicCout( basic_ostream<char,Traits>& os , const Arg& arg ) { return os << arg; }
template <class Traits , typename Arg1 , typename Arg2 , typename... ARGS> inline basic_ostream<char,Traits>& VariadicCout( basic_ostream<char,Traits>& os , const Arg1& arg1 , const Arg2& arg2 , const ARGS&... args ) { return VariadicCout( os << arg1 << " " , arg2 , args... ); }

// デバッグ用
#ifdef DEBUG
  inline void AlertAbort( int n ) { CERR( "abort関数が呼ばれました。assertマクロのメッセージが出力されていない場合はオーバーフローの有無を確認をしてください。" ); }
  void AutoCheck( bool& auto_checked );
#endif

#define INCLUDE_LIBRARY
#include __FILE__

#endif // INCLUDE_LIBRARY

#endif // INCLUDE_SUB

#endif // INCLUDE_MAIN