結果

問題 No.2489 X and Xor 2
コンテスト
ユーザー ecottea
提出日時 2025-05-15 03:28:33
言語 C++17
(gcc 13.3.0 + boost 1.87.0)
結果
AC  
実行時間 71 ms / 2,000 ms
コード長 19,138 bytes
コンパイル時間 11,534 ms
コンパイル使用メモリ 449,468 KB
実行使用メモリ 7,844 KB
最終ジャッジ日時 2025-05-15 03:28:48
合計ジャッジ時間 14,298 ms
ジャッジサーバーID
（参考情報） 		judge2 / judge5
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 3
other AC * 34
権限があれば一括ダウンロードができます

ソースコード

diff # 

#ifndef HIDDEN_IN_VS // 折りたたみ用

// 警告の抑制
#define _CRT_SECURE_NO_WARNINGS

// ライブラリの読み込み
#include <bits/stdc++.h>
using namespace std;

// 型名の短縮
using ll = long long; using ull = unsigned long long; // -2^63 ～ 2^63 = 9e18（int は -2^31 ～ 2^31 = 2e9）
using pii = pair<int, int>;	using pll = pair<ll, ll>;	using pil = pair<int, ll>;	using pli = pair<ll, int>;
using vi = vector<int>;		using vvi = vector<vi>;		using vvvi = vector<vvi>;	using vvvvi = vector<vvvi>;
using vl = vector<ll>;		using vvl = vector<vl>;		using vvvl = vector<vvl>;	using vvvvl = vector<vvvl>;
using vb = vector<bool>;	using vvb = vector<vb>;		using vvvb = vector<vvb>;
using vc = vector<char>;	using vvc = vector<vc>;		using vvvc = vector<vvc>;
using vd = vector<double>;	using vvd = vector<vd>;		using vvvd = vector<vvd>;
template <class T> using priority_queue_rev = priority_queue<T, vector<T>, greater<T>>;
using Graph = vvi;

// 定数の定義
const double PI = acos(-1);
int DX[4] = { 1, 0, -1, 0 }; // 4 近傍（下，右，上，左）
int DY[4] = { 0, 1, 0, -1 };
int INF = 1001001001; ll INFL = 4004004003094073385LL; // (int)INFL = INF, (int)(-INFL) = -INF;

// 入出力高速化
struct fast_io { fast_io() { cin.tie(nullptr); ios::sync_with_stdio(false); cout << fixed << setprecision(18); } } fastIOtmp;

// 汎用マクロの定義
#define all(a) (a).begin(), (a).end()
#define sz(x) ((int)(x).size())
#define lbpos(a, x) (int)distance((a).begin(), std::lower_bound(all(a), (x)))
#define ubpos(a, x) (int)distance((a).begin(), std::upper_bound(all(a), (x)))
#define Yes(b) {cout << ((b) ? "Yes\n" : "No\n");}
#define rep(i, n) for(int i = 0, i##_len = int(n); i < i##_len; ++i) // 0 から n-1 まで昇順
#define repi(i, s, t) for(int i = int(s), i##_end = int(t); i <= i##_end; ++i) // s から t まで昇順
#define repir(i, s, t) for(int i = int(s), i##_end = int(t); i >= i##_end; --i) // s から t まで降順
#define repe(v, a) for(const auto& v : (a)) // a の全要素（変更不可能）
#define repea(v, a) for(auto& v : (a)) // a の全要素（変更可能）
#define repb(set, d) for(int set = 0, set##_ub = 1 << int(d); set < set##_ub; ++set) // d ビット全探索（昇順）
#define repis(i, set) for(int i = lsb(set), bset##i = set; i < 32; bset##i -= 1 << i, i = lsb(bset##i)) // set の全要素（昇順）
#define repp(a) sort(all(a)); for(bool a##_perm = true; a##_perm; a##_perm = next_permutation(all(a))) // a の順列全て（昇順）
#define uniq(a) {sort(all(a)); (a).erase(unique(all(a)), (a).end());} // 重複除去
#define EXIT(a) {cout << (a) << endl; exit(0);} // 強制終了
#define inQ(x, y, u, l, d, r) ((u) <= (x) && (l) <= (y) && (x) < (d) && (y) < (r)) // 半開矩形内判定

// 汎用関数の定義
template <class T> inline ll powi(T n, int k) { ll v = 1; rep(i, k) v *= n; return v; }
template <class T> inline bool chmax(T& M, const T& x) { if (M < x) { M = x; return true; } return false; } // 最大値を更新（更新されたら true を返す）
template <class T> inline bool chmin(T& m, const T& x) { if (m > x) { m = x; return true; } return false; } // 最小値を更新（更新されたら true を返す）
template <class T> inline T getb(T set, int i) { return (set >> i) & T(1); }
template <class T> inline T smod(T n, T m) { n %= m; if (n < 0) n += m; return n; } // 非負mod

// 演算子オーバーロード
template <class T, class U> inline istream& operator>>(istream& is, pair<T, U>& p) { is >> p.first >> p.second; return is; }
template <class T> inline istream& operator>>(istream& is, vector<T>& v) { repea(x, v) is >> x; return is; }
template <class T> inline vector<T>& operator--(vector<T>& v) { repea(x, v) --x; return v; }
template <class T> inline vector<T>& operator++(vector<T>& v) { repea(x, v) ++x; return v; }

#endif // 折りたたみ用


#if __has_include(<atcoder/all>)
#include <atcoder/all>
using namespace atcoder;

#ifdef _MSC_VER
#include "localACL.hpp"
#endif

using mint = modint998244353;
//using mint = static_modint<(int)1e9 + 7>;
//using mint = modint; // mint::set_mod(m);

namespace atcoder {
	inline istream& operator>>(istream& is, mint& x) { ll x_; is >> x_; x = x_; return is; }
	inline ostream& operator<<(ostream& os, const mint& x) { os << x.val(); return os; }
}
using vm = vector<mint>; using vvm = vector<vm>; using vvvm = vector<vvm>; using vvvvm = vector<vvvm>; using pim = pair<int, mint>;
#endif


#ifdef _MSC_VER // 手元環境（Visual Studio）
#include "local.hpp"
#else // 提出用（gcc）
inline int popcount(int n) { return __builtin_popcount(n); }
inline int popcount(ll n) { return __builtin_popcountll(n); }
inline int lsb(int n) { return n != 0 ? __builtin_ctz(n) : 32; }
inline int lsb(ll n) { return n != 0 ? __builtin_ctzll(n) : 64; }
inline int msb(int n) { return n != 0 ? (31 - __builtin_clz(n)) : -1; }
inline int msb(ll n) { return n != 0 ? (63 - __builtin_clzll(n)) : -1; }
#define dump(...)
#define dumpel(v)
#define dump_math(v)
#define input_from_file(f)
#define output_to_file(f)
#define Assert(b) { if (!(b)) { vc MLE(1<<30); EXIT(MLE.back()); } } // RE の代わりに MLE を出す
#endif


mint TLE(ll n, ll m) {
	int B = msb(m - 1) + 1;

	vm dp(m, 1);

	rep(i, n - 1) {
		dump("-------------- i:", i, "----------------");
		
		vm ndp(m);

		rep(j, m) {
			rep(nj, m) {
				ndp[nj] += dp[j] * (j ^ nj);
			}
		}

		dp = move(ndp);
		dump(dp);

		mint w0 = dp[0];
		vm ws(B);
		rep(k, B) ws[k] = dp[1LL << k] - w0;
		dump("w0:", w0, "ws:", ws);

		vm dp2(m, w0);
		rep(j, m) repis(b, j) dp2[j] += ws[b];
		dump(dp2);
	}

	return accumulate(all(dp), mint(0));
}
/*
10 5
-------------- i: 0 ----------------
10 11 12 13 22
w0: 10 ws: 1 2 12
10 11 12 13 22
-------------- i: 1 ----------------
162 182 198 218 258
w0: 162 ws: 20 36 96
162 182 198 218 258
-------------- i: 2 ----------------
2264 2482 2636 2854 4272
w0: 2264 ws: 218 372 2008
2264 2482 2636 2854 4272
-------------- i: 3 ----------------
33404 37240 40460 44296 57260
w0: 33404 ws: 3836 7056 23856
33404 37240 40460 44296 57260
-------------- i: 4 ----------------
480088 529676 566384 615972 872648
w0: 480088 ws: 49588 86296 392560
480088 529676 566384 615972 872648
-------------- i: 5 ----------------
7000952 7774424 8401064 9174536 12278840
w0: 7000952 ws: 773472 1400112 5277888
7000952 7774424 8401064 9174536 12278840
-------------- i: 6 ----------------
101215520 111947416 120172752 130904648 181504064
w0: 101215520 ws: 10731896 18957232 80288544
101215520 111947416 120172752 130904648 181504064
-------------- i: 7 ----------------
472778767 632819039 759957967 919998239 605479502
w0: 472778767 ws: 160040272 287179200 132700735
472778767 632819039 759957967 919998239 605479502
-------------- i: 8 ----------------
346937227 632336185 409179431 694578389 83036090
w0: 346937227 ws: 285398958 62242204 734343216
346937227 632336185 409179431 694578389 83036090
169578616
======
*/


//【アダマール変換】O(2^n n)
/*
* a[0..2^n) を
*       A[set] = Σset2 (-1)^popcount(set ∩ set2) a[set2]
* なる A[0..2^n) に上書きする．
*/
template <class T>
void hadamard(vector<T>& a) {
	// verify : https://judge.yosupo.jp/problem/bitwise_xor_convolution

	// 具体例：
	//	A[0] = a[0] + a[1] + a[2] + a[3] + a[4] + a[5] + a[6] + a[7] + ...
	//	A[1] = a[0] - a[1] + a[2] - a[3] + a[4] - a[5] + a[6] - a[7] + ...
	//	A[2] = a[0] + a[1] - a[2] - a[3] + a[4] + a[5] - a[6] - a[7] + ...
	//	A[3] = a[0] - a[1] - a[2] + a[3] + a[4] - a[5] - a[6] + a[7] + ...
	//	A[4] = a[0] + a[1] + a[2] + a[3] - a[4] - a[5] - a[6] - a[7] + ...
	//	A[5] = a[0] - a[1] + a[2] - a[3] - a[4] + a[5] - a[6] + a[7] + ...
	//	A[6] = a[0] + a[1] - a[2] - a[3] - a[4] - a[5] + a[6] + a[7] + ...
	//	A[7] = a[0] - a[1] - a[2] + a[3] - a[4] + a[5] + a[6] - a[7] + ...

	int n = msb(sz(a));

	rep(i, n) repb(set, n) {
		if (!(set & (1 << i))) {
			T x = a[set];
			T y = a[set | (1 << i)];

			a[set] = x + y;
			a[set + (1 << i)] = x - y;
		}
	}
}


//【逆アダマール変換】O(2^n n)
/*
* A[0..2^n) を
*       A[set] = Σset2 (-1)^popcount(set ∩ set2) a[set2]
* なる a[0..2^n) に上書きする．
*
* 制約：A の要素は 2 で割れる．
*/
template <class T>
void hadamard_inv(vector<T>& A) {
	// verify : https://judge.yosupo.jp/problem/bitwise_xor_convolution

	int n = msb(sz(A));

	rep(i, n) repb(set, n) {
		if (!(set & (1 << i))) {
			T x = A[set];
			T y = A[set | (1 << i)];

			// オーバーフローの危険があるので都度 /2 しないといけない．
			A[set] = (x + y) >> 1;
			A[set + (1 << i)] = (x - y) >> 1;
		}
	}
}


#include <boost/multiprecision/cpp_int.hpp>
using Bint = boost::multiprecision::cpp_int;
using vB = vector<Bint>; using vvB = vector<vB>; using vvvB = vector<vvB>;


Bint TLE2(ll n, ll m) {
	int B = msb(m - 1) + 1;

	vB coef(1LL << B);
	iota(all(coef), Bint(0));

	hadamard(coef);
	dump("H(coef):"); dump(coef);

	vB dp(1LL << B);
	rep(j, m) dp[j] = 1;

	rep(i, n - 1) {
		dump("-------------- i:", i, "----------------");

		hadamard(dp);
		dump(dp);

		repb(j, B) if (popcount(j) >= 2) dp[j] = 0;
		dump(dp);

		repb(j, B) dp[j] *= coef[j];
		dump(dp);
		hadamard_inv(dp);

		repi(j, m, (1LL << B) - 1) dp[j] = 0; // これが扱いにくい
		dump(dp);
	}

	return accumulate(all(dp), Bint(0));
}


void zikken() {
	int m = 15;

	vvm mat;

	rep(j0, m) {
		vm dp(m);
		dp[j0] = 1;

		vm ndp(m);
		rep(j, m) {
			rep(nj, m) {
				ndp[nj] += dp[j] * (j ^ nj);
			}
		}

		mat.push_back(ndp);
	}
	
	rep(i, m) {
		rep(j, m) {
			cout << setw(2) << mat[i][j] << " ";
		}
		cout << endl;
	}

	exit(0);
}
/*
 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14
 1  0  3  2  5  4  7  6  9  8 11 10 13 12 15
 2  3  0  1  6  7  4  5 10 11  8  9 14 15 12
 3  2  1  0  7  6  5  4 11 10  9  8 15 14 13
 4  5  6  7  0  1  2  3 12 13 14 15  8  9 10
 5  4  7  6  1  0  3  2 13 12 15 14  9  8 11
 6  7  4  5  2  3  0  1 14 15 12 13 10 11  8
 7  6  5  4  3  2  1  0 15 14 13 12 11 10  9
 8  9 10 11 12 13 14 15  0  1  2  3  4  5  6
 9  8 11 10 13 12 15 14  1  0  3  2  5  4  7
10 11  8  9 14 15 12 13  2  3  0  1  6  7  4
11 10  9  8 15 14 13 12  3  2  1  0  7  6  5
12 13 14 15  8  9 10 11  4  5  6  7  0  1  2
13 12 15 14  9  8 11 10  5  4  7  6  1  0  3
14 15 12 13 10 11  8  9  6  7  4  5  2  3  0
*/


void zikken2() {
	int m = 15;

	vvm mat; int j0 = 0;

	repir(k, msb(m), 0) {
		int j1 = j0 + (1 << k);
		if (j1 > m) continue;

		vm dp(m);
		repi(j, j0, j1 - 1) dp[j] = 1;
		j0 = j1;

		vm ndp(m);
		rep(j, m) {
			rep(nj, m) {
				ndp[nj] += dp[j] * (j ^ nj);
			}
		}

		mat.push_back(ndp);
	}

	rep(i, sz(mat)) {
		rep(j, m) {
			cout << setw(2) << mat[i][j] << " ";
		}
		cout << endl;
	}

	exit(0);
}
/*
28 28 28 28 28 28 28 28 92 92 92 92 92 92 92
38 38 38 38 54 54 54 54  6  6  6  6 22 22 22
25 25 29 29 17 17 21 21  9  9 13 13  1  1  5
14 15 12 13 10 11  8  9  6  7  4  5  2  3  0
*/


//【XOR 区間の分割】O(log max(r, c))
/*
* 集合 [l..r) XOR c を O(log max(r, c)) 個の半開区間に分割し，そのリストを返す．
*/
template <class T>
vector<pair<T, T>> XOR_interval_division(T l, T r, T c) {
	// verify : https://yukicoder.me/problems/no/2505

	chmax(l, T(0));
	if (l >= r) return vector<pair<T, T>>();

	int n = max(msb(r), msb(c));

	vector<pair<T, T>> lrs; T val_l = 0, val_r = 0; bool eq = true;
	repir(i, n, 0) {
		T lb = getb(l, i), rb = getb(r, i), cb = getb(c, i);

		if (eq) {
			if (lb != rb) eq = false;
		}
		else {
			if (!lb) {
				T val_l2 = val_l + ((1 ^ cb) << i);
				lrs.emplace_back(val_l2, val_l2 + (T(1) << i));
			}
			if (rb) {
				T val_r2 = val_r + ((0 ^ cb) << i);
				lrs.emplace_back(val_r2, val_r2 + (T(1) << i));
			}
		}
		val_l += (lb ^ cb) << i;
		val_r += (rb ^ cb) << i;
	}
	lrs.emplace_back(val_l, val_l + 1);

	return lrs;
}


//【連続整数の剰余の数え上げ（範囲指定）】O(1)
/*
* i∈[0..n) のうち i mod m ∈ [l..r) を満たすものの個数を返す．
*
* 制約：0 ≦ l, r ≦ m
*/
template <class T>
T count_by_mod_range(T n, T m, T l, T r) {
	// verify : https://atcoder.jp/contests/agc072/tasks/agc072_c

	//【方法】
	// n = m Q + R と表す．
	// i∈[0..m Q) なる i については (r-l)Q 個ある．
	// 残りについては max(min(r,R)-l, 0) 個ある．

	Assert(m > 0);
	if (l >= r || n <= 0) return 0;

	T Q = n / m;
	T R = n % m;

	return (r - l) * Q + max(min(r, R) - l, T(0));
}


//【連続整数の剰余の総和（範囲指定）】O(1)
/*
* i∈[0..n) のうち i mod m ∈ [l..r) を満たすものの総和を返す．
*
* 制約：0 ≦ l, r ≦ m
*/
template <class T, class S = T>
S continuous_mod_range_sum(T n, T m, T l, T r) {
	Assert(m > 0);
	if (l >= r || n <= 0) return 0;

	T Q = n / m;
	T R = n % m;

	T cnt0 = r - l;
	T sum0 = l + r - 1;
	S res = 0;
	if (cnt0 % 2 == 0) res = (S)(cnt0 / 2) * Q * (sum0 + m * (Q - 1));
	else if (Q % 2 == 0) res = (S)(Q / 2) * cnt0 * (sum0 + m * (Q - 1));
	else res = (S)((sum0 + m * (Q - 1)) / 2) * cnt0 * Q;

	l = m * Q + l;
	r = m * Q + min(r, R);
	if (l < r) {
		T cnt = r - l;
		T sum = l + r - 1;
		res += (cnt % 2 == 0) ? (S)(cnt / 2) * sum : (S)(sum / 2) * cnt;
	}

	return res;
}


//【行列】
/*
* Matrix<T>(int n, int m) : O(n m)
*	n×m 零行列で初期化する．
*
* Matrix<T>(int n) : O(n^2)
*	n×n 単位行列で初期化する．
*
* Matrix<T>(vvT a) : O(n m)
*	二次元配列 a[0..n)[0..m) の要素で初期化する．
*
* bool empty() : O(1)
*	行列が空かを返す．
*
* A + B : O(n m)
*	n×m 行列 A, B の和を返す．+= も使用可．
*
* A - B : O(n m)
*	n×m 行列 A, B の差を返す．-= も使用可．
*
* c * A ／ A * c : O(n m)
*	n×m 行列 A とスカラー c のスカラー積を返す．*= も使用可．
*
* A * x : O(n m)
*	n×m 行列 A と n 次元列ベクトル x の積を返す．
*
* x * A : O(n m)（やや遅い）
*	m 次元行ベクトル x と n×m 行列 A の積を返す．
*
* A * B : O(n m l)
*	n×m 行列 A と m×l 行列 B の積を返す．
*
* Mat pow(ll d) : O(n^3 log d)
*	自身を d 乗した行列を返す．
*/
template <class T>
struct Matrix {
	int n, m; // 行列のサイズ（n 行 m 列）
	vector<vector<T>> v; // 行列の成分

	// n×m 零行列で初期化する．
	Matrix(int n, int m) : n(n), m(m), v(n, vector<T>(m)) {}

	// n×n 単位行列で初期化する．
	Matrix(int n) : n(n), m(n), v(n, vector<T>(n)) { rep(i, n) v[i][i] = T(1); }

	// 二次元配列 a[0..n)[0..m) の要素で初期化する．
	Matrix(const vector<vector<T>>& a) : n(sz(a)), m(sz(a[0])), v(a) {}
	Matrix() : n(0), m(0) {}

	// 代入
	Matrix(const Matrix&) = default;
	Matrix& operator=(const Matrix&) = default;

	// アクセス
	inline vector<T> const& operator[](int i) const { return v[i]; }
	inline vector<T>& operator[](int i) {
		// verify : https://judge.yosupo.jp/problem/matrix_product

		// inline を付けて [] でアクセスするとなぜか v[] への直接アクセスより速くなった．
		return v[i];
	}

	// 入力
	friend istream& operator>>(istream& is, Matrix& a) {
		rep(i, a.n) rep(j, a.m) is >> a.v[i][j];
		return is;
	}

	// 行の追加
	void push_back(const vector<T>& a) {
		Assert(sz(a) == m);
		v.push_back(a);
		n++;
	}

	// 行の削除
	void pop_back() {
		Assert(n > 0);
		v.pop_back();
		n--;
	}

	// サイズ変更
	void resize(int n_) {
		v.resize(n_);
		n = n_;
	}

	void resize(int n_, int m_) {
		n = n_;
		m = m_;

		v.resize(n);
		rep(i, n) v[i].resize(m);
	}

	// 空か
	bool empty() const { return min(n, m) == 0; }

	// 比較
	bool operator==(const Matrix& b) const { return n == b.n && m == b.m && v == b.v; }
	bool operator!=(const Matrix& b) const { return !(*this == b); }

	// 加算，減算，スカラー倍
	Matrix& operator+=(const Matrix& b) {
		rep(i, n) rep(j, m) v[i][j] += b[i][j];
		return *this;
	}
	Matrix& operator-=(const Matrix& b) {
		rep(i, n) rep(j, m) v[i][j] -= b[i][j];
		return *this;
	}
	Matrix& operator*=(const T& c) {
		rep(i, n) rep(j, m) v[i][j] *= c;
		return *this;
	}
	Matrix operator+(const Matrix& b) const { return Matrix(*this) += b; }
	Matrix operator-(const Matrix& b) const { return Matrix(*this) -= b; }
	Matrix operator*(const T& c) const { return Matrix(*this) *= c; }
	friend Matrix operator*(const T& c, const Matrix<T>& a) { return a * c; }
	Matrix operator-() const { return Matrix(*this) *= T(-1); }

	// 行列ベクトル積 : O(m n)
	vector<T> operator*(const vector<T>& x) const {
		vector<T> y(n);
		rep(i, n) rep(j, m)	y[i] += v[i][j] * x[j];
		return y;
	}

	// ベクトル行列積 : O(m n)
	friend vector<T> operator*(const vector<T>& x, const Matrix& a) {
		vector<T> y(a.m);
		rep(i, a.n) rep(j, a.m) y[j] += x[i] * a[i][j];
		return y;
	}

	// 積：O(n^3)
	Matrix operator*(const Matrix& b) const {
		// verify : https://judge.yosupo.jp/problem/matrix_product

		Matrix res(n, b.m);
		rep(i, res.n) rep(k, m) rep(j, res.m) res[i][j] += v[i][k] * b[k][j];
		return res;
	}
	Matrix& operator*=(const Matrix& b) { *this = *this * b; return *this; }

	// 累乗：O(n^3 log d)
	Matrix pow(ll d) const {
		// verify : https://judge.yosupo.jp/problem/pow_of_matrix

		Matrix res(n), pow2 = *this;
		while (d > 0) {
			if (d & 1) res *= pow2;
			pow2 *= pow2;
			d >>= 1;
		}
		return res;
	}

#ifdef _MSC_VER
	friend ostream& operator<<(ostream& os, const Matrix& a) {
		rep(i, a.n) {
			os << "[";
			rep(j, a.m) os << a[i][j] << " ]"[j == a.m - 1];
			if (i < a.n - 1) os << "\n";
		}
		return os;
	}
#endif
};


mint solve(ll n, ll m) {
	int B = msb(m - 1) + 1;

	Matrix<mint> mat(B + 1, B + 1);

	mat[0][0] = continuous_mod_range_sum<ll, mint>(m, 1, 0, 1);
	rep(j, B) {
		mat[0][j + 1] = continuous_mod_range_sum<ll, mint>(m, 1LL << (j + 1), 1LL << j, 1LL << (j + 1));
	}
	rep(i, B) {
		auto lrs = XOR_interval_division<ll>(0, m, 1LL << i);
		for (auto [l, r] : lrs) {
			mat[i + 1][0] += continuous_mod_range_sum<ll, mint>(r, 1, 0, 1);
			mat[i + 1][0] -= continuous_mod_range_sum<ll, mint>(l, 1, 0, 1);
		}
		mat[i + 1][0] -= mat[0][0];

		rep(j, B) {
			auto lrs = XOR_interval_division<ll>(0, m, 1LL << i);
			for (auto [l, r] : lrs) {
				if (i != j) {
					mat[i + 1][j + 1] += continuous_mod_range_sum<ll, mint>(r, 1LL << (j + 1), 1LL << j, 1LL << (j + 1));
					mat[i + 1][j + 1] -= continuous_mod_range_sum<ll, mint>(l, 1LL << (j + 1), 1LL << j, 1LL << (j + 1));
				}
				else {
					mat[i + 1][j + 1] += continuous_mod_range_sum<ll, mint>(r, 1LL << (j + 1), 0, 1LL << j);
					mat[i + 1][j + 1] -= continuous_mod_range_sum<ll, mint>(l, 1LL << (j + 1), 0, 1LL << j);
				}
			}
			mat[i + 1][j + 1] -= mat[0][j + 1];
		}
	}
	dump(mat);

	mat = mat.pow(n - 1);

	vm vec(B + 1);
	vec[0] = 1;

	vec = mat * vec;

	mint res = 0;

	res += vec[0] * count_by_mod_range<ll>(m, 1, 0, 1);
	rep(j, B) {
		res += vec[j + 1] * count_by_mod_range<ll>(m, 1LL << (j + 1), 1LL << j, 1LL << (j + 1));
	}

	return res;
}


int main() {
//	input_from_file("input.txt");
//	output_to_file("output.txt");
	
//	zikken2();

	ll n, m;
	cin >> n >> m;

//	dump(TLE(n, m)); dump("======");
	//dump(TLE2(n, m)); dump("======");

	EXIT(solve(n, m));
}
0