Submission #6905058
Source Code Expand
//#pragma GCC optimize ("-O3")
#include <iostream>
#include <cmath>
#include <vector>
#include <stack>
#include <cstdio>
#include <string>
#include <bitset>
#include <list>
#include <set>
#include <algorithm>
#include <numeric>
#include <unordered_map>
#include <functional>
#include <queue>
#include <regex>
#include <cassert>
#include <map>
#include <type_traits>
#include <array>
#include <cassert>
#include <typeinfo>
#include <time.h>
#include <iomanip>
#include <random>
#include <sstream>
#ifdef _MSC_VER
#include <intrin.h>
#define popcnt __popcnt64
//# define __builtin_popcount __popcnt
#else
#define popcnt __builtin_popcountll
#endif
//#include "boost/variant.hpp"
using namespace std;
typedef long long ll;
constexpr ll MOD = 1000000007;
constexpr ll INF = 1LL << 60;
#define rep(i, N, M) for(ll i=N, i##_len=(M); i<i##_len; ++i)
#define rep_skip(i, N, M, ...) for(ll i=N, i##_len=(M); i<i##_len; i+=(skip))
#define rrep(i, N, M) for(ll i=(M)-1, i##_len=(N-1); i>i##_len; --i)
#define pb push_back
#define fir first
#define sec second
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define perm(c) sort(all(c));for(bool c##perm=1;c##perm;c##perm=next_permutation(all(c))) //perm(c){write(c)} writes all permutation of c
typedef pair<double, double> pd;
typedef pair<ll, ll> pll;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<pll> vpll;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<string> vs;
template<typename T>
using pq_greater = priority_queue<T, vector<T>, greater<T>>;
struct Point { ll x; ll y; };
using vpt = vector<Point>;
template<int n>
struct tll_impl {
using type = decltype(tuple_cat(tuple<ll>(), declval<typename tll_impl<n - 1>::type>()));
};
template<>
struct tll_impl<1> {
using type = tuple<ll>;
};
template<int n>
using tll = typename tll_impl<n>::type;
template<class T>
constexpr ll SZ(T& v) { return static_cast<ll>(v.size()); };
template<int n, typename T>
struct vec_t_impl {
using type = vector<typename vec_t_impl<n-1,T>::type>;
};
template<typename T>
struct vec_t_impl<1,T> {
using type = vector<T>;
};
template<int n, typename T>
using vec_t = typename vec_t_impl<n, T>::type;
// check
static_assert(is_same<vec_t<3,ll>, vector<vector<vector<ll>>>>::value, "");
// decompose vector into basetype and dimension.
template<typename T>
struct vec_dec {
static constexpr int dim = 0;
using type = T;
};
template<typename T>
struct vec_dec<vector<T>> {
static constexpr int dim = vec_dec<T>::dim+1;
using type = typename vec_dec<T>::type;
};
static_assert(is_same<typename vec_dec<vec_t<3, ll>>::type, ll>::value, "");
static_assert(vec_dec<vec_t<3, ll>>::dim == 3, "");
template<typename T = ll>
vector<T> makev(size_t a) { return vector<T>(a); }
template<typename T = ll, typename... Ts>
auto makev(size_t a, Ts... ts) {
return vector<decltype(makev<T>(ts...))>(a, makev<T>(ts...));
}
// ex: auto dp = makev<ll>(4,5) => vector<vector<ll>> dp(4,vector<ll>(5));
// check if T is vector
template < typename T >
struct is_vector : std::false_type {};
template < typename T >
struct is_vector<vector<T>> : std::true_type {};
static_assert(is_vector<vector<ll>>::value == true && is_vector<ll>::value == false, "");
// check if T is vector
template < typename T>
struct is_pair : std::false_type {};
template < typename T, typename S >
struct is_pair<pair<T, S>> : std::true_type {};
static_assert(is_pair<pll>::value == true && is_pair<ll>::value == false, "");
template<typename T, typename V, typename enable_if<!is_vector<T>::value, nullptr_t>::type = nullptr>
void fill_v(T& t, const V& v) { t = v; }
template<typename T, typename V, typename enable_if<is_vector<T>::value, nullptr_t>::type = nullptr>
void fill_v(T& t, const V& v) {
for (auto &&x : t)
fill_v(x, v);
}
// ex: fill_v(dp, INF);
template<typename T, typename enable_if < !is_vector<T>::value && !is_pair<T>::value, nullptr_t > ::type = nullptr >
void read(T& x) { cin >> x;}
template<typename T, typename enable_if<is_pair<T>::value, nullptr_t>::type = nullptr>
void read(T& x) { read(x.first); read(x.second); }
template<typename T, typename enable_if<is_vector<T>::value, nullptr_t>::type = nullptr>
void read(T& x) { rep(i,0,x.size()) read(x[i]); }
template<>
void read(Point& p) { cin >> p.x >> p.y; }
template<typename T, typename Delim_t = string, typename enable_if<!is_vector<T>::value, nullptr_t>::type = nullptr>
void write(T& x, Delim_t delim = " ") { cout << x << delim; }
template<typename T, typename Delim_t = string, typename enable_if<is_vector<T>::value, nullptr_t>::type = nullptr>
void write(T& x, Delim_t delim = " ") { rep(i, 0, x.size()) write(x[i], (i == (x.size() - 1) ? "" : delim)); cout << '\n'; }
template<typename T> void chmin(T &a, T b) {
if (a > b) a = b;
}
template<typename T> void chmax(T &a, T b) {
if (a < b) a = b;
}
vll seq(ll i, ll j) {
vll res(j - i);
rep(k, i, j) res[k] = i + k;
return res;
}
constexpr ll POW_0(ll x, ll y) {
if (y == 0)return 1;
if (y == 1)return x ;
if (y == 2)return x * x ;
if (y % 2 == 0)return POW_0(POW_0(x, y / 2), 2LL);
return ((POW_0(POW_0(x, y / 2), 2LL)) * (x)) ;
}
constexpr ll POW(ll x, ll y, ll mod = 0) {
if (mod == 0)return POW_0(x, y);
if (y == 0)return 1;
if (y == 1)return x % mod;
if (y == 2)return x * x % mod;
if (y % 2 == 0)return POW(POW(x, y / 2, mod), 2LL, mod) % mod;
return ((POW(POW(x, y / 2, mod), 2LL, mod)) * (x % mod)) % mod;
}
template<
typename Inputs,
typename Functor,
typename T = typename Inputs::value_type>
void sort_by(Inputs& inputs, Functor f) {
std::sort(std::begin(inputs), std::end(inputs),
[&f](const T& lhs, const T& rhs) { return f(lhs) < f(rhs); });
}
template<
typename Inputs,
typename Functor,
typename T = typename Inputs::value_type>
void stable_sort_by(Inputs& inputs, Functor f) {
std::stable_sort(std::begin(inputs), std::end(inputs),
[&f](const T& lhs, const T& rhs) { return f(lhs) < f(rhs); });
}
template<typename Inputs>
void sort_uniq(Inputs& inputs) {
sort(all(inputs));
inputs.erase(unique(all(inputs)), inputs.end());
}
vector<string> split(const string& s, char delim) {
vector<string> elems;
stringstream ss(s);
string item;
while (getline(ss, item, delim)) {
if (!item.empty()) {
elems.push_back(item);
}
}
return elems;
}
ll div_ferm(ll val, ll b, ll mod) {
return (val* POW(b, mod - 2, mod)) % mod;
}
// === Modint ===
//static uint_fast64_t runtime_modulus = MOD;
template <ll modulus = MOD>
class modint
{
public:
ll val;
constexpr modint() : val(0) {}
constexpr modint(ll x) : val((x %= mod()) < 0 ? x + mod() : x) {}
constexpr modint(ll x, ll modulus_) {
set_modulo(modulus_); val = (x %= mod()) < 0 ? x + mod() : x;
}
template<class Ret = ll &>
static auto modulo() -> std::enable_if_t<(modulus <= 0), Ret> {
static ll runtime_modulus= numeric_limits<ll>::max(); return runtime_modulus; // singleton technique
}
template<class Ret = const ll>
static auto mod() -> std::enable_if_t<(modulus <= 0), Ret> { return modulo(); }
template<class Ret = const ll>
static constexpr auto mod()->std::enable_if_t<(modulus > 0), Ret> { return modulus; }
template<ll modulus_ = modulus, enable_if_t<(modulus_ <= 0), nullptr_t> = nullptr >
static void set_modulo(ll mod) { modulo() = mod; }
void reset_modulo(ll modulus_) { modulo() = modulus_; val %= mod();}
constexpr modint inv() { return pow(mod() - 2); }
constexpr ll value() const noexcept { return val; }
constexpr modint operator+(const modint rhs) const noexcept {
return modint(*this) += rhs;
}
constexpr modint operator-(const modint rhs) const noexcept {
return modint(*this) -= rhs;
}
constexpr modint operator*(const modint rhs) const noexcept {
return modint(*this) *= rhs;
}
constexpr modint operator/(const modint rhs) const noexcept {
return modint(*this) /= rhs;
}
modint &operator+=(const modint rhs) noexcept {
val += rhs.val;
if (val >= mod()) {
val -= mod();
}
return *this;
}
modint &operator-=(const modint rhs) noexcept {
if (val < rhs.val) {
val += mod();
}
val -= rhs.val;
return *this;
}
modint &operator*=(const modint rhs) noexcept {
val = val * rhs.val % mod();
return *this;
}
modint &operator/=(modint rhs) noexcept {
ll exp = mod() - 2;
while (exp) {
if (exp % 2) {
*this *= rhs;
}
rhs *= rhs;
exp /= 2;
}
return *this;
}
modint &operator++() noexcept {
return *this += modint(1);
}
modint operator++(int) noexcept {
modint t = *this;
*this += modint(1);
return t;
}
modint &operator--() noexcept {
return *this -= modint(1);
}
modint operator--(int) noexcept {
modint t = *this;
*this -= modint(1);
return t;
}
constexpr modint operator-() { return val ? mod() - val : val; }
constexpr bool operator==(const modint rhs) const noexcept { return val == rhs.value(); }
constexpr bool operator!=(const modint rhs)const noexcept { return val != rhs.value(); }
constexpr bool operator <(const modint rhs)const noexcept { return val < rhs.value(); }
static constexpr modint zero() { return modint(0); }
static constexpr modint unit() { return modint(1); }
modint pow(long long k) const {
modint v = *this;
modint res(1), tmp(v);
while (k) {
if (k & 1) res *= tmp;
tmp *= tmp;
k >>= 1;
}
return res;
}
ll log(modint b) {
modint val = *this;
const ll sq = 40000;
map<modint, ll> dp;
//dp.reserve(sq);
modint res(1);
for (ll r = 0; r < sq; r++) {
if (!dp.count(res)) dp[res] = r;
res *= val;
}
modint p = val.inv().pow(sq);
res = b;
for (ll q = 0; q <= mod() / sq + 1; q++) {
if (dp.count(res)) {
ll idx = q * sq + dp[res];
if (idx > 0) return idx;
}
res *= p;
}
return INF;
}
friend ostream& operator <<(ostream& o, const modint<modulus>& t) {
o << t.value();
return o;
}
friend istream& operator >>(istream& in, modint<modulus>& t) {
ll x;
in >> x;
t = modint<modulus>(x);
return in;
}
friend modint<modulus> POW(modint<modulus> x, ll n) {
return modint<modulus>(POW(x.value(), n, mod()));
}
};
// user defined literal
modint<MOD> operator"" _mod(unsigned long long x) {
return modint<MOD>(x);
}
class Combination {
// this calculates combination (nCk).
// Constructor runs in O(MAX).
// get(n,k) returns nCk in O(1).
ll mod, N_MAX;
vll fac;
vll finv;
vll inv;
public:
Combination(ll mod = MOD, ll N_MAX = 210000)
:mod(mod), N_MAX(max(N_MAX, 2LL)), fac(vll(N_MAX + 1)), finv(vll(N_MAX + 1)), inv(vll(N_MAX + 1)) {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
pre_process(2LL, N_MAX + 1);
}
ll operator()(ll n, ll k) {
// choose k from n
if (N_MAX < n)
pre_process(N_MAX + 1, n + 1);
if (n < k)return 0;
if (n < 0 || k < 0)return 0;
return fac[n] * (finv[k] * finv[n - k] % mod) % mod;
}
ll H(ll n, ll k) {
// 1) 区間[0, k) を(空を許して)n個に分割する場合の数
// 2) n個の中からk個を重複を許して選ぶ
return (n==0 && k==0)? 1 : operator()(n + k - 1, k);
}
ll P(ll n, ll k) {
// n (n-1) ... (n-k+1)
return (n<k|| n<0 )? 0 : fac[n] * finv[n - k];
}
ll Fac(ll n) { return P(n,n); }
ll FacInv(ll n) { return n<0? 0: finv[n]; }
private:
void pre_process(ll m, ll n) {
if (N_MAX < n) {
fac.resize(n); inv.resize(n); finv.resize(n);
}
rep(i, m, n) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = mod - inv[mod%i] * (mod / i) % mod;
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
};
ll choose(int n, int r) { // O(r) for small n
ll acc = 1;
rep(i, 0, r) acc = acc * (n - i) / (i + 1);
return acc;
}
ll gcd(ll val, ll b) {
if (val%b == 0) return b;
else return gcd(b, val%b);
}
vll getDivisors(ll n) {
vll res;
ll i = 1;
for (; i*i < n; i++) {
if (n%i == 0) {
res.push_back(i);
res.push_back(n / i);
}
}
if (i*i == n)res.push_back(i);
sort(res.begin(), res.end());
return res;
}
vll getDivisors(ll n, ll m) {
// O(sqrt(min(n,m)))
if (n > m) swap(n, m);
vll res;
ll i = 1;
for (; i*i < n; i++) {
if (n%i == 0) {
if (m%i == 0) res.push_back(i);
if (m % (n / i) == 0) res.push_back(n / i);
}
}
if (i*i == n) if (m%i == 0) res.push_back(i);
sort(res.begin(), res.end());
return res;
}
vector<pll >prime_factorize(ll n) {
vector<pll> res;
for (ll p = 2; p*p <= n; ++p) {
if (n%p != 0)continue;
ll num = 0;
while (n%p == 0) { ++num; n /= p; }
res.push_back({ p,num });
}
if (n != 1) res.push_back(make_pair(n, 1));
return res;
}
#include <cstdio>
#include <cassert>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> Pii;
#define FOR(i,n) for(int i = 0; i < (n); i++)
#define sz(c) ((int)(c).size())
#define ten(x) ((int)1e##x)
template<class T> T extgcd(T a, T b, T& x, T& y) { for (T u = y = 1, v = x = 0; a;) { T q = b / a; swap(x -= q * u, u); swap(y -= q * v, v); swap(b -= q * a, a); } return b; } // find the solusion of a*x + b*y = gcd(a,b)
template<class T> T mod_inv(T a, T m) { T x, y; extgcd(a, m, x, y); return (m + x % m) % m; }
ll mod_pow(ll a, ll n, ll mod) { ll ret = 1; ll p = a % mod; while (n) { if (n & 1) ret = ret * p % mod; p = p * p % mod; n >>= 1; } return ret; }
template<int mod, int primitive_root>
class NTT {
public:
int get_mod() const { return mod; }
void _ntt(vector<ll>& a, int sign) {
const int n = sz(a);
assert((n ^ (n & -n)) == 0); //n = 2^k
const int g = primitive_root; //g is primitive root of mod
int h = (int)mod_pow(g, (mod - 1) / n, mod); // h^n = 1
if (sign == -1) h = (int)mod_inv(h, mod); //h = h^-1 % mod
//bit reverse
int i = 0;
for (int j = 1; j < n - 1; ++j) {
for (int k = n >> 1; k > (i ^= k); k >>= 1);
if (j < i) swap(a[i], a[j]);
}
for (int m = 1; m < n; m *= 2) {
const int m2 = 2 * m;
const ll base = mod_pow(h, n / m2, mod);
ll w = 1;
FOR(x, m) {
for (int s = x; s < n; s += m2) {
ll u = a[s];
ll d = a[s + m] * w % mod;
a[s] = u + d;
if (a[s] >= mod) a[s] -= mod;
a[s + m] = u - d;
if (a[s + m] < 0) a[s + m] += mod;
}
w = w * base % mod;
}
}
for (auto& x : a) if (x < 0) x += mod;
}
void ntt(vector<ll>& input) {
_ntt(input, 1);
}
void intt(vector<ll>& input) {
_ntt(input, -1);
const int n_inv = mod_inv(sz(input), mod);
for (auto& x : input) x = x * n_inv % mod;
}
// 畳み込み演算を行う
vector<ll> convolution(const vector<ll>& a, const vector<ll>& b) {
int ntt_size = 1;
while (ntt_size < sz(a) + sz(b)) ntt_size *= 2;
vector<ll> _a = a, _b = b;
_a.resize(ntt_size); _b.resize(ntt_size);
ntt(_a);
ntt(_b);
FOR(i, ntt_size) {
(_a[i] *= _b[i]) %= mod;
}
intt(_a);
return _a;
}
};
ll garner(vector<Pii> mr, int mod) {
mr.emplace_back(mod, 0);
vector<ll> coffs(sz(mr), 1);
vector<ll> constants(sz(mr), 0);
FOR(i, sz(mr) - 1) {
// coffs[i] * v + constants[i] == mr[i].second (mod mr[i].first) を解く
ll v = (mr[i].second - constants[i]) * mod_inv<ll>(coffs[i], mr[i].first) % mr[i].first;
if (v < 0) v += mr[i].first;
for (int j = i + 1; j < sz(mr); j++) {
(constants[j] += coffs[j] * v) %= mr[j].first;
(coffs[j] *= mr[i].first) %= mr[j].first;
}
}
return constants[sz(mr) - 1];
}
typedef NTT<167772161, 3> NTT_1;
typedef NTT<469762049, 3> NTT_2;
typedef NTT<1224736769, 3> NTT_3;
//任意のmodで畳み込み演算 O(n log n)
vector<ll> int32mod_convolution(vector<ll> a, vector<ll> b, int mod = numeric_limits<int>::max()) {
for (auto& x : a) x %= mod;
for (auto& x : b) x %= mod;
NTT_1 ntt1; NTT_2 ntt2; NTT_3 ntt3;
auto x = ntt1.convolution(a, b);
auto y = ntt2.convolution(a, b);
auto z = ntt3.convolution(a, b);
vector<ll> ret(sz(x));
vector<Pii> mr(3);
FOR(i, sz(x)) {
mr[0].first = ntt1.get_mod(), mr[0].second = (int)x[i];
mr[1].first = ntt2.get_mod(), mr[1].second = (int)y[i];
mr[2].first = ntt3.get_mod(), mr[2].second = (int)z[i];
ret[i] = garner(mr, mod);
}
return ret;
}
// garnerのアルゴリズムを直書きしたversion,速い
vector<ll> fast_int32mod_convolution(vector<ll> a, vector<ll> b, int mod) {
for (auto& x : a) x %= mod;
for (auto& x : b) x %= mod;
NTT_1 ntt1; NTT_2 ntt2; NTT_3 ntt3;
assert(ntt1.get_mod() < ntt2.get_mod() && ntt2.get_mod() < ntt3.get_mod());
auto x = ntt1.convolution(a, b);
auto y = ntt2.convolution(a, b);
auto z = ntt3.convolution(a, b);
// garnerのアルゴリズムを極力高速化した
const ll m1 = ntt1.get_mod(), m2 = ntt2.get_mod(), m3 = ntt3.get_mod();
const ll m1_inv_m2 = mod_inv<ll>(m1, m2);
const ll m12_inv_m3 = mod_inv<ll>(m1 * m2, m3);
const ll m12_mod = m1 * m2 % mod;
vector<ll> ret(sz(x));
FOR(i, sz(x)) {
ll v1 = (y[i] - x[i]) * m1_inv_m2 % m2;
if (v1 < 0) v1 += m2;
ll v2 = (z[i] - (x[i] + m1 * v1) % m3) * m12_inv_m3 % m3;
if (v2 < 0) v2 += m3;
ll constants3 = (x[i] + m1 * v1 + m12_mod * v2) % mod;
if (constants3 < 0) constants3 += mod;
ret[i] = constants3;
}
return ret;
}
//2^23より大きく,primitive rootに3を持つもの
// const int mods[] = { 1224736769, 469762049, 167772161, 595591169, 645922817, 897581057, 998244353 };
void ntt_test() {
NTT_1 ntt;
vector<ll> v;
FOR(i, 16) v.push_back(10 + i);
auto v2 = v;
ntt.ntt(v2);
auto v3 = v2;
ntt.intt(v3);
assert(v == v3);
}
void comvolution_test() {
NTT_1 ntt1;
vector<ll> v = { 1, 2, 3 };
vector<ll> u = { 4, 5, 6 };
auto vu = ntt1.convolution(v, u);
vector<ll> vu2 = { 1 * 4, 1 * 5 + 2 * 4, 1 * 6 + 2 * 5 + 3 * 4, 2 * 6 + 3 * 5, 3 * 6, 0, 0, 0 };
assert(vu == vu2);
}
void int32mod_convolution_test() {
vector<ll> x, y;
FOR(i, 10) x.push_back(ten(8) + i);
y = x;
auto z = int32mod_convolution(x, y, ten(9) + 7);
z.resize(sz(x) + sz(y) - 1);
vector<ll> z2 = {
930000007, 60000000, 390000001, 920000004,
650000003, 580000006, 710000014, 40000021,
570000042, 300000064, 370000109, 240000144,
910000175, 380000187, 650000193, 720000185,
590000162, 260000123, 730000074 };
assert(z == z2);
}
// ============================ Header =================================
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
ll n; cin >> n;
vll a(n);
vll b(n);
rep(i, 0, n) {
cin >> a[i] >> b[i];
}
NTT_1 ntt;
auto res = fast_int32mod_convolution(a, b, numeric_limits<int>::max());
cout << 0 << endl;
rep(i, 0, 2 * n-1) {
cout << res[i] << endl;
}
return 0;
}
Submission Info
Submission Time |
|
Task |
C - 高速フーリエ変換 |
User |
pontaryagin |
Language |
C++14 (GCC 5.4.1) |
Score |
100 |
Code Size |
18427 Byte |
Status |
AC |
Exec Time |
692 ms |
Memory |
13148 KB |
Judge Result
Set Name |
Sample |
All |
Score / Max Score |
0 / 0 |
100 / 100 |
Status |
|
|
Set Name |
Test Cases |
Sample |
00_sample_01 |
All |
00_sample_01, 01_00_01, 01_01_19, 01_02_31, 01_03_22, 01_04_31, 01_05_40, 01_06_15, 01_07_39, 01_08_28, 01_09_30, 01_10_23, 01_11_33, 01_12_11, 01_13_28, 01_14_41, 01_15_26, 01_16_49, 01_17_34, 01_18_02, 01_19_33, 01_20_29, 02_00_51254, 02_01_82431, 02_02_17056, 02_03_34866, 02_04_6779, 02_05_65534, 02_06_65535, 02_07_65536, 02_08_65537, 02_09_65538, 02_10_100000 |
Case Name |
Status |
Exec Time |
Memory |
00_sample_01 |
AC |
1 ms |
256 KB |
01_00_01 |
AC |
1 ms |
256 KB |
01_01_19 |
AC |
1 ms |
256 KB |
01_02_31 |
AC |
1 ms |
256 KB |
01_03_22 |
AC |
1 ms |
256 KB |
01_04_31 |
AC |
1 ms |
256 KB |
01_05_40 |
AC |
1 ms |
256 KB |
01_06_15 |
AC |
1 ms |
256 KB |
01_07_39 |
AC |
1 ms |
256 KB |
01_08_28 |
AC |
1 ms |
256 KB |
01_09_30 |
AC |
1 ms |
256 KB |
01_10_23 |
AC |
1 ms |
256 KB |
01_11_33 |
AC |
1 ms |
256 KB |
01_12_11 |
AC |
1 ms |
256 KB |
01_13_28 |
AC |
1 ms |
256 KB |
01_14_41 |
AC |
1 ms |
256 KB |
01_15_26 |
AC |
1 ms |
256 KB |
01_16_49 |
AC |
1 ms |
256 KB |
01_17_34 |
AC |
1 ms |
256 KB |
01_18_02 |
AC |
1 ms |
256 KB |
01_19_33 |
AC |
1 ms |
256 KB |
01_20_29 |
AC |
1 ms |
256 KB |
02_00_51254 |
AC |
334 ms |
6740 KB |
02_01_82431 |
AC |
639 ms |
12396 KB |
02_02_17056 |
AC |
133 ms |
3180 KB |
02_03_34866 |
AC |
281 ms |
5972 KB |
02_04_6779 |
AC |
39 ms |
1148 KB |
02_05_65534 |
AC |
383 ms |
7420 KB |
02_06_65535 |
AC |
382 ms |
7412 KB |
02_07_65536 |
AC |
380 ms |
7412 KB |
02_08_65537 |
AC |
580 ms |
11508 KB |
02_09_65538 |
AC |
579 ms |
11508 KB |
02_10_100000 |
AC |
692 ms |
13148 KB |