QOJ.ac
QOJ
| ID | 题目 | 提交者 | 结果 | 用时 | 内存 | 语言 | 文件大小 | 提交时间 | 测评时间 |
|---|---|---|---|---|---|---|---|---|---|
| #389755 | #8565. Basic Blooms | ucup-team133 | WA | 101ms | 7104kb | C++23 | 23.4kb | 2024-04-14 19:22:04 | 2024-04-14 19:22:04 |
Judging History
answer
#include <bits/stdc++.h>
#ifdef LOCAL
#include <debug.hpp>
#else
#define debug(...) void(0)
#endif
template <class T> std::istream& operator>>(std::istream& is, std::vector<T>& v) {
for (auto& x : v) is >> x;
return is;
}
template <class T> std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) {
auto sep = "";
for (const auto& x : v) os << std::exchange(sep, " ") << x;
return os;
}
template <class T, class U = T> bool chmin(T& x, U&& y) { return y < x and (x = std::forward<U>(y), true); }
template <class T, class U = T> bool chmax(T& x, U&& y) { return x < y and (x = std::forward<U>(y), true); }
template <class T> void mkuni(std::vector<T>& v) {
std::sort(begin(v), end(v));
v.erase(unique(begin(v), end(v)), end(v));
}
template <class T> int lwb(const std::vector<T>& v, const T& x) {
return std::lower_bound(begin(v), end(v), x) - begin(v);
}
#include <type_traits>
#ifdef _MSC_VER
#include <intrin.h>
#endif
#ifdef _MSC_VER
#include <intrin.h>
#endif
namespace atcoder {
namespace internal {
// @param m `1 <= m`
// @return x mod m
constexpr long long safe_mod(long long x, long long m) {
x %= m;
if (x < 0) x += m;
return x;
}
// Fast modular multiplication by barrett reduction
// Reference: https://en.wikipedia.org/wiki/Barrett_reduction
// NOTE: reconsider after Ice Lake
struct barrett {
unsigned int _m;
unsigned long long im;
// @param m `1 <= m < 2^31`
explicit barrett(unsigned int m) : _m(m), im((unsigned long long)(-1) / m + 1) {}
// @return m
unsigned int umod() const { return _m; }
// @param a `0 <= a < m`
// @param b `0 <= b < m`
// @return `a * b % m`
unsigned int mul(unsigned int a, unsigned int b) const {
// [1] m = 1
// a = b = im = 0, so okay
// [2] m >= 2
// im = ceil(2^64 / m)
// -> im * m = 2^64 + r (0 <= r < m)
// let z = a*b = c*m + d (0 <= c, d < m)
// a*b * im = (c*m + d) * im = c*(im*m) + d*im = c*2^64 + c*r + d*im
// c*r + d*im < m * m + m * im < m * m + 2^64 + m <= 2^64 + m * (m + 1) < 2^64 * 2
// ((ab * im) >> 64) == c or c + 1
unsigned long long z = a;
z *= b;
#ifdef _MSC_VER
unsigned long long x;
_umul128(z, im, &x);
#else
unsigned long long x =
(unsigned long long)(((unsigned __int128)(z)*im) >> 64);
#endif
unsigned int v = (unsigned int)(z - x * _m);
if (_m <= v) v += _m;
return v;
}
};
// @param n `0 <= n`
// @param m `1 <= m`
// @return `(x ** n) % m`
constexpr long long pow_mod_constexpr(long long x, long long n, int m) {
if (m == 1) return 0;
unsigned int _m = (unsigned int)(m);
unsigned long long r = 1;
unsigned long long y = safe_mod(x, m);
while (n) {
if (n & 1) r = (r * y) % _m;
y = (y * y) % _m;
n >>= 1;
}
return r;
}
// Reference:
// M. Forisek and J. Jancina,
// Fast Primality Testing for Integers That Fit into a Machine Word
// @param n `0 <= n`
constexpr bool is_prime_constexpr(int n) {
if (n <= 1) return false;
if (n == 2 || n == 7 || n == 61) return true;
if (n % 2 == 0) return false;
long long d = n - 1;
while (d % 2 == 0) d /= 2;
constexpr long long bases[3] = {2, 7, 61};
for (long long a : bases) {
long long t = d;
long long y = pow_mod_constexpr(a, t, n);
while (t != n - 1 && y != 1 && y != n - 1) {
y = y * y % n;
t <<= 1;
}
if (y != n - 1 && t % 2 == 0) {
return false;
}
}
return true;
}
template <int n> constexpr bool is_prime = is_prime_constexpr(n);
// @param b `1 <= b`
// @return pair(g, x) s.t. g = gcd(a, b), xa = g (mod b), 0 <= x < b/g
constexpr std::pair<long long, long long> inv_gcd(long long a, long long b) {
a = safe_mod(a, b);
if (a == 0) return {b, 0};
// Contracts:
// [1] s - m0 * a = 0 (mod b)
// [2] t - m1 * a = 0 (mod b)
// [3] s * |m1| + t * |m0| <= b
long long s = b, t = a;
long long m0 = 0, m1 = 1;
while (t) {
long long u = s / t;
s -= t * u;
m0 -= m1 * u; // |m1 * u| <= |m1| * s <= b
// [3]:
// (s - t * u) * |m1| + t * |m0 - m1 * u|
// <= s * |m1| - t * u * |m1| + t * (|m0| + |m1| * u)
// = s * |m1| + t * |m0| <= b
auto tmp = s;
s = t;
t = tmp;
tmp = m0;
m0 = m1;
m1 = tmp;
}
// by [3]: |m0| <= b/g
// by g != b: |m0| < b/g
if (m0 < 0) m0 += b / s;
return {s, m0};
}
// Compile time primitive root
// @param m must be prime
// @return primitive root (and minimum in now)
constexpr int primitive_root_constexpr(int m) {
if (m == 2) return 1;
if (m == 167772161) return 3;
if (m == 469762049) return 3;
if (m == 754974721) return 11;
if (m == 998244353) return 3;
int divs[20] = {};
divs[0] = 2;
int cnt = 1;
int x = (m - 1) / 2;
while (x % 2 == 0) x /= 2;
for (int i = 3; (long long)(i)*i <= x; i += 2) {
if (x % i == 0) {
divs[cnt++] = i;
while (x % i == 0) {
x /= i;
}
}
}
if (x > 1) {
divs[cnt++] = x;
}
for (int g = 2;; g++) {
bool ok = true;
for (int i = 0; i < cnt; i++) {
if (pow_mod_constexpr(g, (m - 1) / divs[i], m) == 1) {
ok = false;
break;
}
}
if (ok) return g;
}
}
template <int m> constexpr int primitive_root = primitive_root_constexpr(m);
// @param n `n < 2^32`
// @param m `1 <= m < 2^32`
// @return sum_{i=0}^{n-1} floor((ai + b) / m) (mod 2^64)
unsigned long long floor_sum_unsigned(unsigned long long n,
unsigned long long m,
unsigned long long a,
unsigned long long b) {
unsigned long long ans = 0;
while (true) {
if (a >= m) {
ans += n * (n - 1) / 2 * (a / m);
a %= m;
}
if (b >= m) {
ans += n * (b / m);
b %= m;
}
unsigned long long y_max = a * n + b;
if (y_max < m) break;
// y_max < m * (n + 1)
// floor(y_max / m) <= n
n = (unsigned long long)(y_max / m);
b = (unsigned long long)(y_max % m);
std::swap(m, a);
}
return ans;
}
} // namespace internal
} // namespace atcoder
namespace atcoder {
namespace internal {
#ifndef _MSC_VER
template <class T>
using is_signed_int128 =
typename std::conditional<std::is_same<T, __int128_t>::value ||
std::is_same<T, __int128>::value,
std::true_type,
std::false_type>::type;
template <class T>
using is_unsigned_int128 =
typename std::conditional<std::is_same<T, __uint128_t>::value ||
std::is_same<T, unsigned __int128>::value,
std::true_type,
std::false_type>::type;
template <class T>
using make_unsigned_int128 =
typename std::conditional<std::is_same<T, __int128_t>::value,
__uint128_t,
unsigned __int128>;
template <class T>
using is_integral = typename std::conditional<std::is_integral<T>::value ||
is_signed_int128<T>::value ||
is_unsigned_int128<T>::value,
std::true_type,
std::false_type>::type;
template <class T>
using is_signed_int = typename std::conditional<(is_integral<T>::value &&
std::is_signed<T>::value) ||
is_signed_int128<T>::value,
std::true_type,
std::false_type>::type;
template <class T>
using is_unsigned_int =
typename std::conditional<(is_integral<T>::value &&
std::is_unsigned<T>::value) ||
is_unsigned_int128<T>::value,
std::true_type,
std::false_type>::type;
template <class T>
using to_unsigned = typename std::conditional<
is_signed_int128<T>::value,
make_unsigned_int128<T>,
typename std::conditional<std::is_signed<T>::value,
std::make_unsigned<T>,
std::common_type<T>>::type>::type;
#else
template <class T> using is_integral = typename std::is_integral<T>;
template <class T>
using is_signed_int =
typename std::conditional<is_integral<T>::value && std::is_signed<T>::value,
std::true_type,
std::false_type>::type;
template <class T>
using is_unsigned_int =
typename std::conditional<is_integral<T>::value &&
std::is_unsigned<T>::value,
std::true_type,
std::false_type>::type;
template <class T>
using to_unsigned = typename std::conditional<is_signed_int<T>::value,
std::make_unsigned<T>,
std::common_type<T>>::type;
#endif
template <class T>
using is_signed_int_t = std::enable_if_t<is_signed_int<T>::value>;
template <class T>
using is_unsigned_int_t = std::enable_if_t<is_unsigned_int<T>::value>;
template <class T> using to_unsigned_t = typename to_unsigned<T>::type;
} // namespace internal
} // namespace atcoder
namespace atcoder {
namespace internal {
struct modint_base {};
struct static_modint_base : modint_base {};
template <class T> using is_modint = std::is_base_of<modint_base, T>;
template <class T> using is_modint_t = std::enable_if_t<is_modint<T>::value>;
} // namespace internal
template <int m, std::enable_if_t<(1 <= m)>* = nullptr>
struct static_modint : internal::static_modint_base {
using mint = static_modint;
public:
static constexpr int mod() { return m; }
static mint raw(int v) {
mint x;
x._v = v;
return x;
}
static_modint() : _v(0) {}
template <class T, internal::is_signed_int_t<T>* = nullptr>
static_modint(T v) {
long long x = (long long)(v % (long long)(umod()));
if (x < 0) x += umod();
_v = (unsigned int)(x);
}
template <class T, internal::is_unsigned_int_t<T>* = nullptr>
static_modint(T v) {
_v = (unsigned int)(v % umod());
}
unsigned int val() const { return _v; }
mint& operator++() {
_v++;
if (_v == umod()) _v = 0;
return *this;
}
mint& operator--() {
if (_v == 0) _v = umod();
_v--;
return *this;
}
mint operator++(int) {
mint result = *this;
++*this;
return result;
}
mint operator--(int) {
mint result = *this;
--*this;
return result;
}
mint& operator+=(const mint& rhs) {
_v += rhs._v;
if (_v >= umod()) _v -= umod();
return *this;
}
mint& operator-=(const mint& rhs) {
_v -= rhs._v;
if (_v >= umod()) _v += umod();
return *this;
}
mint& operator*=(const mint& rhs) {
unsigned long long z = _v;
z *= rhs._v;
_v = (unsigned int)(z % umod());
return *this;
}
mint& operator/=(const mint& rhs) { return *this = *this * rhs.inv(); }
mint operator+() const { return *this; }
mint operator-() const { return mint() - *this; }
mint pow(long long n) const {
assert(0 <= n);
mint x = *this, r = 1;
while (n) {
if (n & 1) r *= x;
x *= x;
n >>= 1;
}
return r;
}
mint inv() const {
if (prime) {
assert(_v);
return pow(umod() - 2);
} else {
auto eg = internal::inv_gcd(_v, m);
assert(eg.first == 1);
return eg.second;
}
}
friend mint operator+(const mint& lhs, const mint& rhs) {
return mint(lhs) += rhs;
}
friend mint operator-(const mint& lhs, const mint& rhs) {
return mint(lhs) -= rhs;
}
friend mint operator*(const mint& lhs, const mint& rhs) {
return mint(lhs) *= rhs;
}
friend mint operator/(const mint& lhs, const mint& rhs) {
return mint(lhs) /= rhs;
}
friend bool operator==(const mint& lhs, const mint& rhs) {
return lhs._v == rhs._v;
}
friend bool operator!=(const mint& lhs, const mint& rhs) {
return lhs._v != rhs._v;
}
private:
unsigned int _v;
static constexpr unsigned int umod() { return m; }
static constexpr bool prime = internal::is_prime<m>;
};
template <int id> struct dynamic_modint : internal::modint_base {
using mint = dynamic_modint;
public:
static int mod() { return (int)(bt.umod()); }
static void set_mod(int m) {
assert(1 <= m);
bt = internal::barrett(m);
}
static mint raw(int v) {
mint x;
x._v = v;
return x;
}
dynamic_modint() : _v(0) {}
template <class T, internal::is_signed_int_t<T>* = nullptr>
dynamic_modint(T v) {
long long x = (long long)(v % (long long)(mod()));
if (x < 0) x += mod();
_v = (unsigned int)(x);
}
template <class T, internal::is_unsigned_int_t<T>* = nullptr>
dynamic_modint(T v) {
_v = (unsigned int)(v % mod());
}
unsigned int val() const { return _v; }
mint& operator++() {
_v++;
if (_v == umod()) _v = 0;
return *this;
}
mint& operator--() {
if (_v == 0) _v = umod();
_v--;
return *this;
}
mint operator++(int) {
mint result = *this;
++*this;
return result;
}
mint operator--(int) {
mint result = *this;
--*this;
return result;
}
mint& operator+=(const mint& rhs) {
_v += rhs._v;
if (_v >= umod()) _v -= umod();
return *this;
}
mint& operator-=(const mint& rhs) {
_v += mod() - rhs._v;
if (_v >= umod()) _v -= umod();
return *this;
}
mint& operator*=(const mint& rhs) {
_v = bt.mul(_v, rhs._v);
return *this;
}
mint& operator/=(const mint& rhs) { return *this = *this * rhs.inv(); }
mint operator+() const { return *this; }
mint operator-() const { return mint() - *this; }
mint pow(long long n) const {
assert(0 <= n);
mint x = *this, r = 1;
while (n) {
if (n & 1) r *= x;
x *= x;
n >>= 1;
}
return r;
}
mint inv() const {
auto eg = internal::inv_gcd(_v, mod());
assert(eg.first == 1);
return eg.second;
}
friend mint operator+(const mint& lhs, const mint& rhs) {
return mint(lhs) += rhs;
}
friend mint operator-(const mint& lhs, const mint& rhs) {
return mint(lhs) -= rhs;
}
friend mint operator*(const mint& lhs, const mint& rhs) {
return mint(lhs) *= rhs;
}
friend mint operator/(const mint& lhs, const mint& rhs) {
return mint(lhs) /= rhs;
}
friend bool operator==(const mint& lhs, const mint& rhs) {
return lhs._v == rhs._v;
}
friend bool operator!=(const mint& lhs, const mint& rhs) {
return lhs._v != rhs._v;
}
private:
unsigned int _v;
static internal::barrett bt;
static unsigned int umod() { return bt.umod(); }
};
template <int id> internal::barrett dynamic_modint<id>::bt(998244353);
using modint998244353 = static_modint<998244353>;
using modint1000000007 = static_modint<1000000007>;
using modint = dynamic_modint<-1>;
namespace internal {
template <class T>
using is_static_modint = std::is_base_of<internal::static_modint_base, T>;
template <class T>
using is_static_modint_t = std::enable_if_t<is_static_modint<T>::value>;
template <class> struct is_dynamic_modint : public std::false_type {};
template <int id>
struct is_dynamic_modint<dynamic_modint<id>> : public std::true_type {};
template <class T>
using is_dynamic_modint_t = std::enable_if_t<is_dynamic_modint<T>::value>;
} // namespace internal
} // namespace atcoder
namespace hash_impl {
static constexpr unsigned long long mod = (1ULL << 61) - 1;
struct modint {
modint() : _v(0) {}
modint(unsigned long long v) {
v = (v >> 61) + (v & mod);
if (v >= mod) v -= mod;
_v = v;
}
unsigned long long val() const { return _v; }
modint& operator+=(const modint& rhs) {
_v += rhs._v;
if (_v >= mod) _v -= mod;
return *this;
}
modint& operator-=(const modint& rhs) {
if (_v < rhs._v) _v += mod;
_v -= rhs._v;
return *this;
}
modint& operator*=(const modint& rhs) {
__uint128_t t = __uint128_t(_v) * rhs._v;
t = (t >> 61) + (t & mod);
if (t >= mod) t -= mod;
_v = t;
return *this;
}
modint& operator/=(const modint& rhs) { return *this = *this * rhs.inv(); }
modint operator-() const { return modint() - *this; }
modint pow(long long n) const {
assert(0 <= n);
modint x = *this, r = 1;
while (n) {
if (n & 1) r *= x;
x *= x;
n >>= 1;
}
return r;
}
modint inv() const { return pow(mod - 2); }
friend modint operator+(const modint& lhs, const modint& rhs) { return modint(lhs) += rhs; }
friend modint operator-(const modint& lhs, const modint& rhs) { return modint(lhs) -= rhs; }
friend modint operator*(const modint& lhs, const modint& rhs) { return modint(lhs) *= rhs; }
friend modint operator/(const modint& lhs, const modint& rhs) { return modint(lhs) /= rhs; }
friend bool operator==(const modint& lhs, const modint& rhs) { return lhs._v == rhs._v; }
friend bool operator!=(const modint& lhs, const modint& rhs) { return lhs._v != rhs._v; }
friend std::ostream& operator<<(std::ostream& os, const modint& rhs) { os << rhs._v; }
private:
unsigned long long _v;
};
uint64_t generate_base() {
std::mt19937_64 mt(std::chrono::steady_clock::now().time_since_epoch().count());
std::uniform_int_distribution<uint64_t> rand(2, mod - 1);
return rand(mt);
}
modint base(generate_base());
std::vector<modint> power{1};
modint get_pow(int n) {
if (n < int(power.size())) return power[n];
int m = power.size();
power.resize(n + 1);
for (int i = m; i <= n; i++) power[i] = power[i - 1] * base;
return power[n];
}
}; // namespace hash_impl
struct Hash {
using mint = hash_impl::modint;
mint x;
int len;
Hash() : x(0), len(0) {}
Hash(mint x, int len) : x(x), len(len) {}
Hash& operator+=(const Hash& rhs) {
x = x * hash_impl::get_pow(rhs.len) + rhs.x;
len += rhs.len;
return *this;
}
Hash operator+(const Hash& rhs) { return *this += rhs; }
bool operator==(const Hash& rhs) { return x == rhs.x and len == rhs.len; }
};
struct ReversibleHash {
using mint = hash_impl::modint;
mint x, rx;
int len;
ReversibleHash() : x(0), rx(0), len(0) {}
ReversibleHash(mint x) : x(x), rx(x), len(1) {}
ReversibleHash(mint x, mint rx, int len) : x(x), rx(rx), len(len) {}
ReversibleHash rev() const { return ReversibleHash(rx, x, len); }
ReversibleHash operator+=(const ReversibleHash& rhs) {
x = x * hash_impl::get_pow(rhs.len) + rhs.x;
rx = rx + rhs.rx * hash_impl::get_pow(len);
len += rhs.len;
return *this;
}
ReversibleHash operator+(const ReversibleHash& rhs) { return *this += rhs; }
bool operator==(const ReversibleHash& rhs) { return x == rhs.x and rx == rhs.rx and len == rhs.len; }
};
typedef long long ll;
#define all(x) begin(x), end(x)
using namespace std;
using mint = atcoder::modint998244353;
using Mint = hash_impl::modint;
constexpr long long IINF = (1LL << 60) - 1;
const int MAX = 1000000, MAX_BASE = 17, MAX_LEN = 30;
long double LOG[MAX_BASE];
long double LOG_POW[MAX_BASE][MAX_LEN];
struct S {
int base, digit, len;
ll val; // 実数値が IINF 以下ならその値
mint sum;
Mint hash;
long double logarithm;
S(int base, int digit, int len, ll val, mint sum, Mint hash)
: base(base), digit(digit), len(len), val(val), sum(sum), hash(hash) {
/*
dd...dd
= d * 11...11
= d * (base^len - 1) / (base - 1)
logl(dd...dd)
= logl(d) - logl(base - 1) + len * logl(base) + logl(1 - 1 / base^len)
x << 1 => logl(1 - x) ~ -x
*/
logarithm = LOG[digit] - LOG[base - 1] + len * LOG[base];
if (len < MAX_LEN) logarithm += LOG_POW[base][len];
}
bool operator<(const S& rhs) const {
if (base == rhs.base) {
if (len != rhs.len) return len < rhs.len;
return digit < rhs.digit;
}
if (sum == rhs.sum and hash == rhs.hash) return true;
if (val != IINF and rhs.val != IINF) return val < rhs.val;
if (val != IINF) return true;
if (rhs.val != IINF) return false;
return logarithm < rhs.logarithm;
}
};
template <class T> T ceil(T x, T y) {
assert(y >= 1);
return (x > 0 ? (x + y - 1) / y : x / y);
}
template <class T> T floor(T x, T y) {
assert(y >= 1);
return (x > 0 ? x / y : (x - y + 1) / y);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
for (int i = 1; i < MAX_BASE; i++) {
LOG[i] = logl(i);
ll cur = 1;
for (int j = 1; j < MAX_LEN; j++) {
cur = (cur == IINF ? cur : cur >= (IINF + i - 1) / i ? IINF : min(IINF, cur * i));
LOG_POW[i][j] = (cur == IINF ? 0 : logl(1 - 1.0 / cur));
}
}
vector<pair<int, int>> nxt(MAX_BASE, {1, 1});
vector<ll> VAL(MAX_BASE, 1);
vector<mint> SUM(MAX_BASE, 1);
vector<Mint> HASH(MAX_BASE, 1);
vector<S> cand(MAX_BASE, S(2, 2, 2, 2, 2, 2));
for (int i = 2; i < MAX_BASE; i++) cand[i] = S(i, 1, 1, VAL[i], SUM[i], HASH[i]);
Mint pre = 0;
vector<mint> sum(MAX + 1);
sum[0] = 0;
for (int i = 0; i < MAX; i++) {
for (bool ok = false; not ok;) {
int argmin = 2;
for (int j = 3; j < MAX_BASE; j++) {
if (cand[j] < cand[argmin]) {
argmin = j;
}
}
auto [digit, len] = nxt[argmin];
S go = cand[argmin];
if (pre != go.hash) {
sum[i + 1] = sum[i] + go.sum;
ok = true;
}
pre = go.hash;
if (digit + 1 < argmin)
nxt[argmin] = {digit + 1, len};
else {
nxt[argmin] = {1, len + 1};
VAL[argmin] = (ceil(IINF, 1LL * argmin) <= VAL[argmin] ? IINF : min(VAL[argmin] * argmin + 1, IINF));
SUM[argmin] = SUM[argmin] * argmin + 1;
HASH[argmin] = HASH[argmin] * argmin + 1;
}
{
auto [digit, len] = nxt[argmin];
cand[argmin] = S(argmin, digit, len,
(ceil(IINF, 1LL * digit) <= VAL[argmin] ? IINF : min(VAL[argmin] * digit, IINF)),
SUM[argmin] * digit, HASH[argmin] * digit);
}
}
}
int t;
cin >> t;
for (; t--;) {
int l, r;
cin >> l >> r;
mint ans = sum[r] - sum[l - 1];
cout << ans.val() << '\n';
}
return 0;
}
詳細信息
Test #1:
score: 100
Accepted
time: 89ms
memory: 7080kb
input:
3 1 2 1 10 15 2000
output:
3 55 736374621
result:
ok 3 number(s): "3 55 736374621"
Test #2:
score: -100
Wrong Answer
time: 101ms
memory: 7104kb
input:
100000 26 99975 57 99944 28 99973 62 99939 71 99930 25 99976 53 99948 60 99941 73 99928 72 99929 30 99971 7 99994 3 99998 35 99966 73 99928 68 99933 83 99918 37 99964 63 99938 17 99984 34 99967 74 99927 6 99995 3 99998 23 99978 91 99910 39 99962 85 99916 82 99919 17 99984 61 99940 31 99970 44 99957 ...
output:
83212469 526838526 948340069 422945900 497756046 70077601 859413147 855160620 119008941 753588144 813200467 265965782 286791604 50969840 119008941 892643514 948027515 45199020 784471549 825789977 639408575 929553761 625960854 286791604 543134062 176814189 982835569 607168618 734834139 825789977 3314...
result:
wrong answer 1st numbers differ - expected: '957904590', found: '83212469'