problem_id stringlengths 6 6 | buggy_code stringlengths 8 526k | fixed_code stringlengths 12 526k | labels listlengths 0 15 ⌀ | buggy_submission_id int64 1 1.54M | fixed_submission_id int64 2 1.54M | user_id stringlengths 10 10 | language stringclasses 8
values |
|---|---|---|---|---|---|---|---|
p03252 | #include <bits/stdc++.h>
#define reps(i, j, k) for (int i = j; i < k; i++)
#define rep(i, j) reps(i, 0, j)
#define fs first
#define sc second
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef long long ll;
int main() {
string s, t;
cin >> s >> t;
map<char, char> m, n;
int l = s... | #include <bits/stdc++.h>
#define reps(i, j, k) for (int i = j; i < k; i++)
#define rep(i, j) reps(i, 0, j)
#define fs first
#define sc second
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef long long ll;
int main() {
string s, t;
cin >> s >> t;
map<char, char> m, n;
int l = s... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 1,041,459 | 1,041,460 | u431402610 | cpp |
p03252 | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
char s[200100];
char t[200100];
char sc[26] = {0};
bool bj[26] = {0};
int main() {
scanf("%s", s);
scanf("%s", t);
int l, i, j;
l = strlen(s);
for (i = 0; i < 26; i++)
sc[i] = 'a' + i;
fo... | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
char s[200100];
char t[200100];
char sc[26] = {0};
bool bj[26] = {0};
int main() {
scanf("%s", s);
scanf("%s", t);
int l, i, j;
l = strlen(s);
for (i = 0; i < 26; i++)
sc[i] = 'a' + i;
fo... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 1,041,463 | 1,041,464 | u396496228 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
#define x first
#... | #include <bits/stdc++.h>
using namespace std;
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
#define x first
#... | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"assignment.variable.change",
"variable_access.subscript.index.change",
"assignment.value.change",
"call.arguments.change",
"control_flow.loop.for.... | 1,041,465 | 1,041,466 | u487172668 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
// 型定義
typedef long long ll;
typedef pair<ll, ll> P;
// forループ
#define REP(i, n) for (ll i = 0; i < (ll)(n); ++i)
// 定数宣言
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
// グラフ表現
using Graph = vector<vector<int>>;
// グラフの辺表現
using Edge = map<pair<in... | #include <bits/stdc++.h>
using namespace std;
// 型定義
typedef long long ll;
typedef pair<ll, ll> P;
// forループ
#define REP(i, n) for (ll i = 0; i < (ll)(n); ++i)
// 定数宣言
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
// グラフ表現
using Graph = vector<vector<int>>;
// グラフの辺表現
using Edge = map<pair<in... | [
"expression.operation.binary.remove"
] | 1,041,472 | 1,041,473 | u443975466 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
// 型定義
typedef long long ll;
typedef pair<ll, ll> P;
// forループ
#define REP(i, n) for (ll i = 0; i < (ll)(n); ++i)
// 定数宣言
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
// グラフ表現
using Graph = vector<vector<int>>;
// グラフの辺表現
using Edge = map<pair<in... | #include <bits/stdc++.h>
using namespace std;
// 型定義
typedef long long ll;
typedef pair<ll, ll> P;
// forループ
#define REP(i, n) for (ll i = 0; i < (ll)(n); ++i)
// 定数宣言
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
// グラフ表現
using Graph = vector<vector<int>>;
// グラフの辺表現
using Edge = map<pair<in... | [
"literal.number.change",
"variable_declaration.value.change"
] | 1,041,474 | 1,041,473 | u443975466 | cpp |
p03253 | //#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define all(v) v.begin(), v.end()
using in = int64_t;
#define rep(i, n) for (in i = 0; i < (in)(n); i++)
#define REP(i, a, b) for (in i = (in)(a); i < (in)(b); i++)
#define Yes cout << "Yes" << endl
#define No cout << "No" << endl
#define yes cout <... | //#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define all(v) v.begin(), v.end()
using in = int64_t;
#define rep(i, n) for (in i = 0; i < (in)(n); i++)
#define REP(i, a, b) for (in i = (in)(a); i < (in)(b); i++)
#define Yes cout << "Yes" << endl
#define No cout << "No" << endl
#define yes cout <... | [
"assignment.add"
] | 1,041,479 | 1,041,480 | u424602097 | cpp |
p03253 | #include <bits/stdc++.h>
#define ALL(a) (a).begin(), (a).end()
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<long long, long long> Pll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<long long> vll;
typedef vector<vector<long long>> vvll;
template <typename T... | #include <bits/stdc++.h>
#define ALL(a) (a).begin(), (a).end()
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<long long, long long> Pll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<long long> vll;
typedef vector<vector<long long>> vvll;
template <typename T... | [
"control_flow.loop.for.initializer.change",
"variable_declaration.type.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,041,485 | 1,041,486 | u455266724 | cpp |
p03253 | #include <iostream>
#include <vector>
using namespace std;
const long long SIZE = 100030, MOD = 1000000007;
int main() {
long long n, m, factorial[SIZE], ifactorial[SIZE], inv[SIZE], result = 1;
cin >> n >> m;
inv[1] = 1;
factorial[0] = 1;
factorial[1] = 1;
ifactorial[0] = 1;
ifactorial[1] = 1;
for (l... | #include <iostream>
#include <vector>
using namespace std;
const long long SIZE = 100030, MOD = 1000000007;
int main() {
long long n, m, factorial[SIZE], ifactorial[SIZE], inv[SIZE], result = 1;
cin >> n >> m;
inv[1] = 1;
factorial[0] = 1;
factorial[1] = 1;
ifactorial[0] = 1;
ifactorial[1] = 1;
for (l... | [
"literal.number.change",
"variable_declaration.value.change",
"assignment.change",
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,041,492 | 1,041,493 | u085367022 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MAX = 510000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i %... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MAX = 510000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i %... | [
"variable_declaration.type.change",
"assignment.add"
] | 1,041,496 | 1,041,497 | u446371873 | cpp |
p03253 | #include <algorithm>
#include <iostream>
#include <map>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rep1(i, n) for (int i = 1; i <= n; ++i)
using namespace std;
typedef long long ll;
const ll MOD = 1e+9 + 7;
struct mint {
ll x;
mint(ll x = 0) : x(x % MOD) {}
mint &operator+=(const mint... | #include <algorithm>
#include <iostream>
#include <map>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rep1(i, n) for (int i = 1; i <= n; ++i)
using namespace std;
typedef long long ll;
const ll MOD = 1e+9 + 7;
struct mint {
ll x;
mint(ll x = 0) : x(x % MOD) {}
mint &operator+=(const mint... | [
"literal.number.change",
"variable_declaration.value.change"
] | 1,041,502 | 1,041,503 | u110996038 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, j, n) for (int i = (int)(j); i < (int)(n); i++)
#define REP(i, j, n) for (int i = (int)(j); i <= (int)(n); i++)
#define MOD 1000000007
#define int long long
#define ALL(a) (a).begin(), (a).end()
#define vi vector<int>
#define vii vector<vi>
#define pii pair<i... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, j, n) for (int i = (int)(j); i < (int)(n); i++)
#define REP(i, j, n) for (int i = (int)(j); i <= (int)(n); i++)
#define MOD 1000000007
#define int long long
#define ALL(a) (a).begin(), (a).end()
#define vi vector<int>
#define vii vector<vi>
#define pii pair<i... | [
"call.add"
] | 1,041,504 | 1,041,505 | u347057617 | cpp |
p03253 | #include <iostream>
using namespace std;
typedef long long ll;
ll mod = 1000000007;
// nが素数かを判定する関数
bool prime(int n) {
bool x = true;
for (int i = 2; i * i <= n; i++)
if (n % i == 0)
x = false;
return x;
}
// a^pを求める関数
ll modpow(ll a, ll p) {
if (p == 0)
return 1;
if (p % 2 == 0) {
ll ... | #include <iostream>
using namespace std;
typedef long long ll;
ll mod = 1000000007;
// nが素数かを判定する関数
bool prime(int n) {
bool x = true;
for (int i = 2; i * i <= n; i++)
if (n % i == 0)
x = false;
return x;
}
// a^pを求める関数
ll modpow(ll a, ll p) {
if (p == 0)
return 1;
if (p % 2 == 0) {
ll ... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 1,041,508 | 1,041,509 | u366398972 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define ALL(v) v.begin(), v.end()
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<int, ll> pil;
typedef pair<ll,... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define ALL(v) v.begin(), v.end()
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<int, ll> pil;
typedef pair<ll,... | [
"literal.number.change",
"variable_declaration.value.change"
] | 1,041,519 | 1,041,520 | u864667985 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define ALL(v) v.begin(), v.end()
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<int, ll> pil;
typedef pair<ll,... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define ALL(v) v.begin(), v.end()
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<int, ll> pil;
typedef pair<ll,... | [
"literal.number.change",
"variable_declaration.value.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 1,041,521 | 1,041,520 | u864667985 | cpp |
p03253 | #include "bits/stdc++.h"
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pi;
typedef pair<pair<ll, ll>, ll> pii;
vector<ll> vec;
vector<vector<ll>> vec2;
ll MOD = 1000000007;
ll INF = 11451419194545;
//階乗
vector<ll> fact;
//逆元
vector<ll> inv;
//逆元階乗
vector<ll> finv;
pii extgcd(ll a, ll b) {
//前... | #include "bits/stdc++.h"
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pi;
typedef pair<pair<ll, ll>, ll> pii;
vector<ll> vec;
vector<vector<ll>> vec2;
ll MOD = 1000000007;
ll INF = 11451419194545;
//階乗
vector<ll> fact;
//逆元
vector<ll> inv;
//逆元階乗
vector<ll> finv;
pii extgcd(ll a, ll b) {
//前... | [
"literal.number.change",
"call.arguments.change"
] | 1,041,526 | 1,041,527 | u048791623 | cpp |
p03253 | #include <bits/stdc++.h>
#define rep(i, n, m) for (int i = n; i < (int)(m); i++)
#define rrep(i, n, m) for (int i = ((int)(n)-1); i >= m; i--)
#define all(x) (x).begin(), (x).end()
typedef long long ll;
const int MOD = 1000000007;
using namespace std;
ll modinv(ll a, ll m) {
ll b = m, u = 1, v = 0;
while (b) {
... | #include <bits/stdc++.h>
#define rep(i, n, m) for (int i = n; i < (int)(m); i++)
#define rrep(i, n, m) for (int i = ((int)(n)-1); i >= m; i--)
#define all(x) (x).begin(), (x).end()
typedef long long ll;
const int MOD = 1000000007;
using namespace std;
ll modinv(ll a, ll m) {
ll b = m, u = 1, v = 0;
while (b) {
... | [
"literal.number.change",
"call.arguments.change",
"assignment.variable.change"
] | 1,041,530 | 1,041,531 | u649915042 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll solve() {
ll N, M;
cin >> N >> M;
map<ll, ll> p;
for (ll k = 2; k * k < M; k++) {
while (M % k == 0) {
p[k]++;
M /= k;
}
}
if (M != 1)
p[M]++;
const ll MOD = 1e9 + 7;
auto Add = [&](ll &x, ll y) { x = (x % M... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll solve() {
ll N, M;
cin >> N >> M;
map<ll, ll> p;
for (ll k = 2; k * k <= M; k++) {
while (M % k == 0) {
p[k]++;
M /= k;
}
}
if (M != 1)
p[M]++;
const ll MOD = 1e9 + 7;
auto Add = [&](ll &x, ll y) { x = (x % ... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,041,536 | 1,041,537 | u930841425 | cpp |
p03253 | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using vll = std::vector<ll>;
using vvll = std::vector<vll>;
using vvvll = std::vector<vvll>;
using dd = double;
using vdd = std::vector<dd>;
using vvdd = std::vector<vdd>;
using vvvdd = std::vector<vvdd>;
constexpr ll INF = 1LL << 60;
constexpr dd EPS... | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using vll = std::vector<ll>;
using vvll = std::vector<vll>;
using vvvll = std::vector<vvll>;
using dd = double;
using vdd = std::vector<dd>;
using vvdd = std::vector<vdd>;
using vvvdd = std::vector<vvdd>;
constexpr ll INF = 1LL << 60;
constexpr dd EPS... | [
"literal.number.change",
"call.arguments.change",
"function.return_value.change"
] | 1,041,554 | 1,041,555 | u450922311 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
template <class T> using lim = numeric_limits<T>;
typedef long long ll;
typedef long double ld;
const int MOD = 1000000007;
const int maxN = 100000;
const int maxF = 200001;
ll fact[maxF + 1];
vector<ll> primes;
// sieving primes
void sieve() {
for (int i = 2; i <= ... | #include <bits/stdc++.h>
using namespace std;
template <class T> using lim = numeric_limits<T>;
typedef long long ll;
typedef long double ld;
const int MOD = 1000000007;
const int maxN = 100000;
const int maxF = 200001;
ll fact[maxF + 1];
vector<ll> primes;
// sieving primes
void sieve() {
for (int i = 2; i <= ... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 1,041,556 | 1,041,557 | u712768978 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int ll
const ll mod = 1e9 + 7;
ll pow(ll x, ll y) {
if (y == 0)
return 1;
ll res = pow(x, y / 2);
res *= res;
res %= mod;
if (y % 2 == 1)
res *= x;
return res % mod;
}
ll gyaku(ll x) { return pow(x, mod - 2); }
vector<ll> fr... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int ll
const ll mod = 1e9 + 7;
ll pow(ll x, ll y) {
if (y == 0)
return 1;
ll res = pow(x, y / 2);
res *= res;
res %= mod;
if (y % 2 == 1)
res *= x;
return res % mod;
}
ll gyaku(ll x) { return pow(x, mod - 2); }
vector<ll> fr... | [
"expression.operation.binary.add"
] | 1,041,558 | 1,041,559 | u440213743 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int ll
const ll mod = 1e9 + 7;
ll pow(ll x, ll y) {
if (y == 0)
return 1;
ll res = pow(x, y / 2);
res *= res;
res %= mod;
if (y % 2 == 1)
res *= x;
return res % mod;
}
ll gyaku(ll x) { return pow(x, mod - 2); }
vector<ll> fr... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int ll
const ll mod = 1e9 + 7;
ll pow(ll x, ll y) {
if (y == 0)
return 1;
ll res = pow(x, y / 2);
res *= res;
res %= mod;
if (y % 2 == 1)
res *= x;
return res % mod;
}
ll gyaku(ll x) { return pow(x, mod - 2); }
vector<ll> fr... | [
"literal.number.change",
"call.arguments.change"
] | 1,041,560 | 1,041,559 | u440213743 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)n; ++i)
static const int dx[4] = {0, 1, 0, -1};
static const int dy[4] = {1, 0, -1, 0};
static const char dir[4] = {'u', 'r', 'd', 'l'};
static const ll INF = 1 << 21;
static const ll MOD = 1e9 + 7;
ll N, M;
ve... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)n; ++i)
static const int dx[4] = {0, 1, 0, -1};
static const int dy[4] = {1, 0, -1, 0};
static const char dir[4] = {'u', 'r', 'd', 'l'};
static const ll INF = 1 << 21;
static const ll MOD = 1e9 + 7;
ll N, M;
ve... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,041,561 | 1,041,562 | u946090308 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
template <typename T> void out(T x) {
cout << x << endl;
exit(0);
}
#define watch(x) cout << (#x) << " is " << (x) << endl
const int maxn = 1e6 + 5;
const ll mod = 1e9 + 7;
ll fac[maxn], ifac[maxn];
ll modpow(ll, ll);
ll inv(ll);
ll nck(ll, ll... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
template <typename T> void out(T x) {
cout << x << endl;
exit(0);
}
#define watch(x) cout << (#x) << " is " << (x) << endl
const int maxn = 1e6 + 5;
const ll mod = 1e9 + 7;
ll fac[maxn], ifac[maxn];
ll modpow(ll, ll);
ll inv(ll);
ll nck(ll, ll... | [
"variable_declaration.remove",
"variable_declaration.add"
] | 1,041,563 | 1,041,564 | u774417629 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll MOD = 1000000007;
ll INF = 10000000000000000;
int PI = 3.1415926535;
template <typename T> void remove(std::vector<T> &vector, unsigned int index) {
vector.erase(vector.begin() + index);
}
using Graph = vector<vector<pair<ll, ll>>>;
vector<ll... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll MOD = 1000000007;
ll INF = 10000000000000000;
int PI = 3.1415926535;
template <typename T> void remove(std::vector<T> &vector, unsigned int index) {
vector.erase(vector.begin() + index);
}
using Graph = vector<vector<pair<ll, ll>>>;
vector<ll... | [
"assignment.add"
] | 1,041,574 | 1,041,575 | u393754572 | cpp |
p03253 | #define rep(i, a, b) for (int i = a; i < (int)(b); i++)
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
template <class T> inline void chmax(T &a, const T &b) {
if (a < b)
a = b;
}
template <class T> inline void chmin(T &a, const T &b) {
if (a > b)
a = b;
}
const long long INF = 1LL << ... | #define rep(i, a, b) for (int i = a; i < (int)(b); i++)
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
template <class T> inline void chmax(T &a, const T &b) {
if (a < b)
a = b;
}
template <class T> inline void chmin(T &a, const T &b) {
if (a > b)
a = b;
}
const long long INF = 1LL << ... | [
"literal.number.change",
"expression.operation.binary.change"
] | 1,041,576 | 1,041,577 | u381755004 | cpp |
p03253 | #include <iostream>
#include <vector>
typedef long long ll;
using namespace std;
// a^p
// 2^3 = 2 * 2^2
// 2^2 = 2 * (2^1)
// 2^1 = 2
ll modpow(ll a, ll p, ll mod) {
if (p == 0)
return 1;
if (p % 2 == 0) {
ll half = modpow(a, p / 2, mod) % mod;
return half * half % mod;
} else {
return a * mod... | #include <iostream>
#include <vector>
typedef long long ll;
using namespace std;
// a^p
// 2^3 = 2 * 2^2
// 2^2 = 2 * (2^1)
// 2^1 = 2
ll modpow(ll a, ll p, ll mod) {
if (p == 0)
return 1;
if (p % 2 == 0) {
ll half = modpow(a, p / 2, mod) % mod;
return half * half % mod;
} else {
return a * mod... | [
"expression.operation.binary.change",
"assignment.change"
] | 1,041,586 | 1,041,587 | u237620737 | cpp |
p03253 | #include <iostream>
#include <vector>
typedef long long ll;
using namespace std;
// a^p
// 2^3 = 2 * 2^2
// 2^2 = 2 * (2^1)
// 2^1 = 2
ll modpow(ll a, ll p, ll mod) {
if (p == 0)
return 1;
if (p % 2 == 0) {
ll half = modpow(a, p / 2, mod) % mod;
return half * half % mod;
} else {
return a * mod... | #include <iostream>
#include <vector>
typedef long long ll;
using namespace std;
// a^p
// 2^3 = 2 * 2^2
// 2^2 = 2 * (2^1)
// 2^1 = 2
ll modpow(ll a, ll p, ll mod) {
if (p == 0)
return 1;
if (p % 2 == 0) {
ll half = modpow(a, p / 2, mod) % mod;
return half * half % mod;
} else {
return a * mod... | [
"expression.operation.binary.change",
"assignment.change"
] | 1,041,588 | 1,041,587 | u237620737 | cpp |
p03253 | #include <algorithm>
#include <complex>
#include <ctype.h>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define FOR(i, a, b) ... | #include <algorithm>
#include <complex>
#include <ctype.h>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define FOR(i, a, b) ... | [
"literal.number.change",
"variable_declaration.value.change"
] | 1,041,589 | 1,041,590 | u432688695 | cpp |
p03253 | // copied from https://atcoder.jp/contests/abc110/submissions/8089381
#include <bits/stdc++.h>
using namespace std;
#define MAX_COMB_F 100010
long long MOD = pow(10, 9) + 7;
long long comb[MAX_COMB_F][50];
main() {
long long n, m, temp;
// n=100000;
// m=1000000000;
cin >> n >> m;
vector<long long> p;
... | // copied from https://atcoder.jp/contests/abc110/submissions/8089381
#include <bits/stdc++.h>
using namespace std;
#define MAX_COMB_F 100100
long long MOD = pow(10, 9) + 7;
long long comb[MAX_COMB_F][50];
main() {
long long n, m, temp;
// n=100000;
// m=536870912;
cin >> n >> m;
vector<long long> p;
t... | [
"preprocessor.define.value.change",
"literal.integer.change"
] | 1,041,591 | 1,041,592 | u021358975 | cpp |
p03253 | // warm heart, wagging tail,and a smile just for you!
// ▓▓▓▓▓▓▓▓▓▓▓▓
// ▓▓▓▓▓▓▓▓╬╬╬╬╬╬╬╬╬╬╬╬▓▓▓▓▓▓▓▓▓▓▓▓▓▓
// ▓▓▓▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓▓▓▓▓▓
// ▓▓▓▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓▓▓▓
// ... | // warm heart, wagging tail,and a smile just for you!
// ▓▓▓▓▓▓▓▓▓▓▓▓
// ▓▓▓▓▓▓▓▓╬╬╬╬╬╬╬╬╬╬╬╬▓▓▓▓▓▓▓▓▓▓▓▓▓▓
// ▓▓▓▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓▓▓▓▓▓
// ▓▓▓▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓▓▓▓
// ... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,041,602 | 1,041,603 | u239493918 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
using Int = long long;
// BEGIN CUT HERE
template <typename T, T MOD = 1000000007> struct Mint {
T v;
Mint() : v(0) {}
Mint(signed v) : v(v) {}
Mint(long long t) {
v = t % MOD;
if (v < 0)
v += MOD;
}
Mint pow(int k) {
Mint res(1), tmp(v);
... | #include <bits/stdc++.h>
using namespace std;
using Int = long long;
// BEGIN CUT HERE
template <typename T, T MOD = 1000000007> struct Mint {
T v;
Mint() : v(0) {}
Mint(signed v) : v(v) {}
Mint(long long t) {
v = t % MOD;
if (v < 0)
v += MOD;
}
Mint pow(int k) {
Mint res(1), tmp(v);
... | [
"identifier.change",
"call.function.change"
] | 1,041,604 | 1,041,605 | u687214625 | cpp |
p03253 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
namespace {
ll ModPow(ll a, ... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
namespace {
ll ModPow(ll a, ... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,041,615 | 1,041,616 | u227117171 | cpp |
p03253 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <unordered_map>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define all(s) s.begin(), s.end()
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
typedef pai... | #include <algorithm>
#include <cassert>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <unordered_map>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define all(s) s.begin(), s.end()
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
typedef pai... | [
"literal.number.change",
"assignment.variable.change",
"variable_access.subscript.index.change"
] | 1,041,617 | 1,041,618 | u328294851 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
using edge = pair<ll, P>;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep2(i, m, n) for (ll i = m; i < (ll)(n); i++)
#define rrep(i, n, m) for (ll i = n; i >= (ll)(m); i--)
using Graph = vector<vector<ll>>;
cons... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
using edge = pair<ll, P>;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep2(i, m, n) for (ll i = m; i < (ll)(n); i++)
#define rrep(i, n, m) for (ll i = n; i >= (ll)(m); i--)
using Graph = vector<vector<ll>>;
cons... | [
"assignment.add"
] | 1,041,623 | 1,041,624 | u427344224 | cpp |
p03253 | #include <bits/stdc++.h>
#define WHOLE(v) (v).begin(), (v).end()
using i64 = int64_t;
using namespace std;
const i64 MOD = 1e9 + 7;
// 素数列を作る
// N: 上限
// v: 出力先
void GetPrimes(int N, vector<int> &v) {
v = vector<int>();
int c = 1;
while (c <= N) {
c++;
bool flag = true;
int d = (int)sqrt(c);
for... | #include <bits/stdc++.h>
#define WHOLE(v) (v).begin(), (v).end()
using i64 = int64_t;
using namespace std;
const i64 MOD = 1e9 + 7;
// 素数列を作る
// N: 上限
// v: 出力先
void GetPrimes(int N, vector<int> &v) {
v = vector<int>();
int c = 1;
while (c <= N) {
c++;
bool flag = true;
int d = (int)sqrt(c);
for... | [
"control_flow.branch.if.condition.change"
] | 1,041,634 | 1,041,635 | u936555566 | cpp |
p03253 | // https://atcoder.jp/contests/abc110/tasks/abc110_d
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
#define EPS (1e-9)
#define INF (1e9)
#define INFL (1e18)
#define MOD (1000000007)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define R... | // https://atcoder.jp/contests/abc110/tasks/abc110_d
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
#define EPS (1e-9)
#define INF (1e9)
#define INFL (1e18)
#define MOD (1000000007)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define R... | [
"assignment.value.change",
"identifier.change",
"call.function.change",
"expression.operation.binary.change"
] | 1,041,636 | 1,041,637 | u858107870 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef long long ll;
typedef pair<ll, ll> P;
const int MAX = 1e5 + 10;
const int INF = 1e9;
const int MOD = 1e9 + 7;
int N, M;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef long long ll;
typedef pair<ll, ll> P;
const int MAX = 1e6 + 10;
const int INF = 1e9;
const int MOD = 1e9 + 7;
int N, M;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1... | [
"literal.number.change",
"expression.operation.binary.change"
] | 1,041,642 | 1,041,643 | u992875223 | cpp |
p03253 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> P1;
typedef pair<P, P> P2;
#define pu push
#define pb push_back
#define ... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> P1;
typedef pair<P, P> P2;
#define pu push
#define pb push_back
#define ... | [
"variable_declaration.type.change",
"assignment.variable.change",
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change"
] | 1,041,646 | 1,041,647 | u284045566 | cpp |
p03253 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <numeric>
#include <set>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using lli = long long int;
// #define DEBUG
#ifdef DEBUG
#define debug(var) cout << (#var) << ": " << (var)... | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <numeric>
#include <set>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using lli = long long int;
// #define DEBUG
#ifdef DEBUG
#define debug(var) cout << (#var) << ": " << (var)... | [
"literal.number.change",
"assignment.value.change",
"call.arguments.change"
] | 1,041,648 | 1,041,649 | u090994275 | cpp |
p03253 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <numeric>
#include <set>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using lli = long long int;
// #define DEBUG
#ifdef DEBUG
#define debug(var) cout << (#var) << ": " << (var)... | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <numeric>
#include <set>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using lli = long long int;
// #define DEBUG
#ifdef DEBUG
#define debug(var) cout << (#var) << ": " << (var)... | [
"literal.number.change",
"assignment.value.change",
"call.arguments.change"
] | 1,041,650 | 1,041,649 | u090994275 | cpp |
p03253 | #include <algorithm>
#include <cstdio>
#include <cstring>
#define ll long long
using namespace std;
const ll PR = 1e9 + 7;
ll n, m;
ll f[50], e[50];
ll pwr(ll x, ll y) {
y = y % (PR - 1);
ll ans = 1;
while (y) {
if (y & 1)
ans = ans * x % PR;
x = x * x % PR;
y >>= 1;
}
return ans;
}
ll C(ll ... | #include <algorithm>
#include <cstdio>
#include <cstring>
#define ll long long
using namespace std;
const ll PR = 1e9 + 7;
ll n, m;
ll f[100050], e[100050];
ll pwr(ll x, ll y) {
y = y % (PR - 1);
ll ans = 1;
while (y) {
if (y & 1)
ans = ans * x % PR;
x = x * x % PR;
y >>= 1;
}
return ans;
}
... | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,041,659 | 1,041,660 | u514525096 | cpp |
p03253 | #define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
using namespace std;
#ifndef FAST_IO
#define IOS \
ios_base::sync_with_stdio(false); \
cin.tie(nullptr);
#endif
#define FILE_IO freopen("input.txt",... | #define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
using namespace std;
#ifndef FAST_IO
#define IOS \
ios_base::sync_with_stdio(false); \
cin.tie(nullptr);
#endif
#define FILE_IO freopen("input.txt",... | [
"literal.number.change",
"expression.operation.binary.change"
] | 1,041,667 | 1,041,668 | u572138437 | cpp |
p03253 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <utility>
#include <vector>
#define INF 1e9 + 7
#define rep(i, n) for (int i = 0; i < n; i++)
#define NO cout << "NO" << endl;
#define YES cout << "YES" << endl;
#define No cout << "No" << endl;
#define... | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <utility>
#include <vector>
#define INF 1e9 + 7
#define rep(i, n) for (int i = 0; i < n; i++)
#define NO cout << "NO" << endl;
#define YES cout << "YES" << endl;
#define No cout << "No" << endl;
#define... | [
"control_flow.branch.if.condition.change"
] | 1,041,671 | 1,041,672 | u297203024 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> m >> n;
int k = sqrt(n);
vector<bool> ju(k, false);
vector<long long> da(0);
long long ki = 2, co = 1;
while (ki < k + 1) {
if (n % ki == 0) {
n /= ki;
if (ju[ki]) {
da[co]++;
} else {
co++;
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> m >> n;
int k = sqrt(n);
vector<bool> ju(k, false);
vector<long long> da(0);
long long ki = 2, co = -1;
while (ki < k + 1) {
if (n % ki == 0) {
n /= ki;
if (ju[ki]) {
da[co]++;
} else {
co++;
... | [
"expression.operation.unary.arithmetic.add"
] | 1,041,673 | 1,041,674 | u057079894 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
// from
// https://atcoder.jp/contests/abc110/submissions/3254887
const int mod = 1e0 + 7;
struct com {
int mod;
vector<long long> mfact, rfact;
com(int sz, int mod) : mfact(sz + 1), rfact(sz + 1), mod(mod) {
mfact[0] = 1;
for (int i = 1; i < mfact.size(); ... | #include <bits/stdc++.h>
using namespace std;
// from
// https://atcoder.jp/contests/abc110/submissions/3254887
const int mod = 1e9 + 7;
struct com {
int mod;
vector<long long> mfact, rfact;
com(int sz, int mod) : mfact(sz + 1), rfact(sz + 1), mod(mod) {
mfact[0] = 1;
for (int i = 1; i < mfact.size(); ... | [
"literal.number.change",
"expression.operation.binary.change"
] | 1,041,687 | 1,041,688 | u123756661 | cpp |
p03253 | // Created by sz
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m, cnt = 0;
map<int, int> e;
void unique_factorization(int n) {
int m = sqrt(n + 0.5);
for (int i = 2; i <= m; i++) {
while (n % i == 0) {
n /= i;
e[i]++;
cnt++;
}
if (n == 1)
break;
... | // Created by sz
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 33;
int n, m, cnt = 0;
map<int, int> e;
void unique_factorization(int n) {
int m = sqrt(n + 0.5);
for (int i = 2; i <= m; i++) {
while (n % i == 0) {
n /= i;
e[i]++;
cnt++;
}
if (n == 1)
break;
... | [
"literal.number.change",
"expression.operation.binary.change"
] | 1,041,690 | 1,041,691 | u041075929 | cpp |
p03253 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define ALL(obj) (obj).begin(), (obj).end()
#define RALL(obj) (obj).rbegin(), (obj).rend()
#define P pair<int, int>
#define MOD 1000000007
#de... | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define ALL(obj) (obj).begin(), (obj).end()
#define RALL(obj) (obj).rbegin(), (obj).rend()
#define P pair<int, int>
#define MOD 1000000007
#de... | [
"variable_declaration.name.change",
"identifier.change",
"literal.number.change",
"variable_declaration.value.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,041,700 | 1,041,701 | u165374901 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll INFL = 1000000000000000010; // 10^18 = 2^60
int INF = 2000000000; // 10^9
ll MOD = 1000000007;
vector<ll> fac(300001); // n!(mod M)
vector<ll> ifac(300001); // k!^{M-2} (mod M)
// a,bの範囲的にこれだけ配列を用意していけば十分
vector<int> p(40000);
ll mpow(ll... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll INFL = 1000000000000000010; // 10^18 = 2^60
int INF = 2000000000; // 10^9
ll MOD = 1000000007;
vector<ll> fac(300001); // n!(mod M)
vector<ll> ifac(300001); // k!^{M-2} (mod M)
// a,bの範囲的にこれだけ配列を用意していけば十分
vector<int> p(40000);
ll mpow(ll... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 1,041,704 | 1,041,705 | u633284019 | cpp |
p03253 | #include "bits/stdc++.h"
using namespace std;
int mod = 1'000'000'007;
long modpow(long a, int p) {
if (p == 1)
return 1;
if (p % 2 == 0) {
int half = p / 2;
int halfpow = modpow(a, half);
return halfpow * halfpow % mod;
} else {
return a * modpow(a, p - 1) % mod;
}
}
long calcC(int a, int... | #include "bits/stdc++.h"
using namespace std;
int mod = 1'000'000'007;
long modpow(long a, int p) {
if (p == 0)
return 1;
if (p % 2 == 0) {
int half = p / 2;
long halfpow = modpow(a, half);
return halfpow * halfpow % mod;
} else {
return a * modpow(a, p - 1) % mod;
}
}
long calcC(int a, in... | [
"literal.number.change",
"control_flow.branch.if.condition.change",
"variable_declaration.type.primitive.change"
] | 1,041,706 | 1,041,707 | u013408661 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e5 + 5;
const ll mod = 1e9 + 7;
ll fact[N];
int n, m;
ll bigmod(ll p, ll q) {
ll res = 1;
while (q > 0) {
if (q & 1) {
res = (res * p) % mod;
}
q >>= 1;
p = (p * p) % mod;
}
return res;
}
ll inverse(ll... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e5 + 5;
const ll mod = 1e9 + 7;
ll fact[N];
int n, m;
ll bigmod(ll p, ll q) {
ll res = 1;
while (q > 0) {
if (q & 1) {
res = (res * p) % mod;
}
q >>= 1;
p = (p * p) % mod;
}
return res;
}
ll inverse(ll... | [
"literal.number.change",
"expression.operation.binary.change"
] | 1,041,708 | 1,041,709 | u264950268 | cpp |
p03253 |
#include <bits/stdc++.h>
typedef long long ll;
#define INF 100000000
#define MOD 100000007
const int MAX = 210000;
using namespace std;
long long fac[MAX], finv[MAX], inv[MAX];
vector<pair<ll, ll>> prime(ll n) {
vector<pair<ll, ll>> res;
for (ll p = 2; p * p <= n; p++) {
if (n % p != 0)
continue;
ll ... |
#include <bits/stdc++.h>
typedef long long ll;
#define INF 100000000
#define MOD 1000000007
const int MAX = 210000;
using namespace std;
long long fac[MAX], finv[MAX], inv[MAX];
vector<pair<ll, ll>> prime(ll n) {
vector<pair<ll, ll>> res;
for (ll p = 2; p * p <= n; p++) {
if (n % p != 0)
continue;
ll... | [
"preprocessor.define.value.change",
"literal.integer.change"
] | 1,041,712 | 1,041,713 | u962206827 | cpp |
p03253 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#inc... | #define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#inc... | [
"literal.number.change",
"expression.operation.binary.change"
] | 1,041,714 | 1,041,715 | u112723190 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
#define int long long
int mod = 1e9 + 7;
int nPr(int n, int r, int m) {
if (r == 0)
return 1;
int ret = 1;
for (int i = 0; i < r; i++) {
ret = (ret * (n - i) % m) % m;
}
return ret;
}
int inv(int i, int m) {
if (i == 1)
return 1;
int ret;
ret =... | #include <bits/stdc++.h>
using namespace std;
#define int long long
int mod = 1e9 + 7;
int nPr(int n, int r, int m) {
if (r == 0)
return 1;
int ret = 1;
for (int i = 0; i < r; i++) {
ret = (ret * (n - i) % m) % m;
}
return ret;
}
int inv(int i, int m) {
if (i == 1)
return 1;
int ret;
ret =... | [
"assignment.change"
] | 1,041,718 | 1,041,719 | u731175398 | cpp |
p03253 | #include <iostream>
using namespace std;
typedef long long ll;
const ll mod = 1e9 + 7;
ll fact[3000005];
ll pow(ll a, ll x) {
ll res = 1;
while (x > 0) {
if (x & 1)
res = res * a % mod;
a = a * a % mod;
x >>= 1;
}
return res;
}
ll nCr(ll n, ll r) {
return fact[n] * (pow(fact[n - r], mod - ... | #include <iostream>
using namespace std;
typedef long long ll;
const ll mod = 1e9 + 7;
ll fact[3000005];
ll pow(ll a, ll x) {
ll res = 1;
while (x > 0) {
if (x & 1)
res = res * a % mod;
a = a * a % mod;
x >>= 1;
}
return res;
}
ll nCr(ll n, ll r) {
return fact[n] * (pow(fact[n - r], mod - ... | [
"expression.operation.binary.add"
] | 1,041,720 | 1,041,721 | u126361752 | cpp |
p03253 | #include <algorithm>
#include <array>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
constexpr int inf = 1e9 + 7;
vector<long long> fac(1000001);
vector<long long> ifac(1000001);
long long mpow(long long _x, long long _n) {
long long ans = 1;
while (_n != 0) {
... | #include <algorithm>
#include <array>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
constexpr int inf = 1e9 + 7;
vector<long long> fac(1000001);
vector<long long> ifac(1000001);
long long mpow(long long _x, long long _n) {
long long ans = 1;
while (_n != 0) {
... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"control_flow.loop.for.initializer.change",
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,041,728 | 1,041,729 | u085825481 | cpp |
p03253 | #include <algorithm>
#include <array>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
constexpr int inf = 1e9 + 7;
vector<long long> fac(1000001);
vector<long long> ifac(1000001);
long long mpow(long long _x, long long _n) {
long long ans = 1;
while (_n != 0) {
... | #include <algorithm>
#include <array>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
constexpr int inf = 1e9 + 7;
vector<long long> fac(1000001);
vector<long long> ifac(1000001);
long long mpow(long long _x, long long _n) {
long long ans = 1;
while (_n != 0) {
... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"control_flow.loop.for.initializer.change",
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,041,730 | 1,041,729 | u085825481 | cpp |
p03253 | #include <algorithm>
#include <array>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
constexpr int inf = 1e9 + 7;
vector<long long> fac(1000001);
vector<long long> ifac(1000001);
long long mpow(long long _x, long long _n) {
long long ans = 1;
while (_n != 0) {
... | #include <algorithm>
#include <array>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
constexpr int inf = 1e9 + 7;
vector<long long> fac(1000001);
vector<long long> ifac(1000001);
long long mpow(long long _x, long long _n) {
long long ans = 1;
while (_n != 0) {
... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"control_flow.loop.for.initializer.change"
] | 1,041,731 | 1,041,729 | u085825481 | cpp |
p03253 | #include <algorithm>
#include <iostream>
#include <map>
#include <utility>
#include <vector>
using namespace std;
vector<long long> item;
map<long long, long long> factor;
long long MOD = 1000000007;
long long modpow(long long a, long long p) {
if (p == 1)
return a;
long long adash = a * a % MOD;
if (p % 2)... | #include <algorithm>
#include <iostream>
#include <map>
#include <utility>
#include <vector>
using namespace std;
vector<long long> item;
map<long long, long long> factor;
long long MOD = 1000000007;
long long modpow(long long a, long long p) {
if (p == 1)
return a;
long long adash = a * a % MOD;
if (p % 2)... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 1,041,732 | 1,041,733 | u650243369 | cpp |
p03253 | #include <algorithm>
#include <cctype>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define repi(i, a, b) for (ll i = ll(a); i < ll(b); i++)
#define all(x)... | #include <algorithm>
#include <cctype>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define repi(i, a, b) for (ll i = ll(a); i < ll(b); i++)
#define all(x)... | [] | 1,041,757 | 1,041,758 | u834415466 | cpp |
p03253 | #ifdef LOCAL
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
#else
#include <bits/stdc++.h>
#endif
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; i++)
#define _sort(arg) sort(begin(arg), end(arg))
#define MOD 1000000007
#define pb pus... | #ifdef LOCAL
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
#else
#include <bits/stdc++.h>
#endif
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; i++)
#define _sort(arg) sort(begin(arg), end(arg))
#define MOD 1000000007
#define pb pus... | [
"assignment.value.change",
"assignment.change"
] | 1,041,766 | 1,041,767 | u528744583 | cpp |
p03253 | #include <algorithm>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define modulo 1000000007 // 10^9 + 7
#d... | #include <algorithm>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define modulo 1000000007 // 10^9 + 7
#d... | [
"assignment.change"
] | 1,041,768 | 1,041,769 | u774652316 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vb = vector<bool>;
using vvb = vector<vb>;
using vd = vector<double>;
using vvd = vector<vd>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using pll = pair<ll, ll>;
using tll = tuple<ll, ll>;
usin... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vb = vector<bool>;
using vvb = vector<vb>;
using vd = vector<double>;
using vvd = vector<vd>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using pll = pair<ll, ll>;
using tll = tuple<ll, ll>;
usin... | [
"literal.number.change",
"call.arguments.change"
] | 1,041,770 | 1,041,771 | u364618491 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
map<int, int> cnt;
int n, m;
int fact[1000005], factInv[1000005];
int mul(int w, int u) { return (long long)w * u % M; }
int power(int a, int k) {
if (k == 0)
return 1;
return mul(power(mul(a, a), k / 2), k % 2 ? a : 1);
}
int inv(int w)... | #include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
map<int, int> cnt;
int n, m;
int fact[1000005], factInv[1000005];
int mul(int w, int u) { return (long long)w * u % M; }
int power(int a, int k) {
if (k == 0)
return 1;
return mul(power(mul(a, a), k / 2), k % 2 ? a : 1);
}
int inv(int w)... | [
"expression.operation.binary.remove",
"assignment.change"
] | 1,041,772 | 1,041,773 | u929642109 | cpp |
p03253 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespace std;... | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespace std;... | [
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change"
] | 1,041,774 | 1,041,775 | u626129192 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
const int MAX = 200000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i]... | #include <bits/stdc++.h>
using namespace std;
const int MAX = 200000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i]... | [
"expression.operation.unary.arithmetic.remove"
] | 1,041,776 | 1,041,777 | u645369394 | cpp |
p03253 |
// include
//------------------------------------------
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
... |
// include
//------------------------------------------
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
... | [
"literal.number.change",
"call.arguments.change"
] | 1,041,784 | 1,041,785 | u874996917 | cpp |
p03253 |
// include
//------------------------------------------
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
... |
// include
//------------------------------------------
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
... | [
"literal.number.change",
"call.arguments.change"
] | 1,041,786 | 1,041,785 | u874996917 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (ll i = (a); i < (b); i++)
typedef uint64_t ull;
typedef int64_t ll;
typedef std::pair<ll, ll> PLL;
map<ll, ll> decomposePrime(ll n) {
map<ll, ll> m;
ll x = 2;
while (x * x <= n) {
if (n % x == 0) {
m[x]++;
n /= x;
} else... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (ll i = (a); i < (b); i++)
typedef uint64_t ull;
typedef int64_t ll;
typedef std::pair<ll, ll> PLL;
map<ll, ll> decomposePrime(ll n) {
map<ll, ll> m;
ll x = 2;
while (x * x <= n) {
if (n % x == 0) {
m[x]++;
n /= x;
} else... | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,041,796 | 1,041,797 | u702996070 | cpp |
p03253 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
//#include <math.h>
#include <algorithm>
//#include <vector>
const long MOD = 1000000007;
static long long st_factrial(long n) {
long long ans = 1;
long i;
for (i = 1; i <= n; i++) {
ans = ans * i % MOD;
}
return ans;
}
static long long st_pow(... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
//#include <math.h>
#include <algorithm>
//#include <vector>
const long MOD = 1000000007;
static long long st_factrial(long n) {
long long ans = 1;
long i;
for (i = 1; i <= n; i++) {
ans = ans * i % MOD;
}
return ans;
}
static long long st_pow(... | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,041,813 | 1,041,814 | u209713918 | cpp |
p03253 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <list>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
ll mod = 1000000007;
ll gyaku(ll n) {
ll mo = mod - 2;
ll now = n;
ll ret = 1;
while (mo > 0) {
if (mo & 1)
ret *= now;
ret ... | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <list>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
ll mod = 1000000007;
ll gyaku(ll n) {
ll mo = mod - 2;
ll now = n;
ll ret = 1;
while (mo > 0) {
if (mo & 1)
ret *= now;
ret ... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 1,041,818 | 1,041,819 | u242680486 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
// Define
using ll = int64_t;
using ul = uint64_t;
using ld = long double;
using pii = pair<int, int>;
const ll MOD = 1e9 + 7;
const ll INF = LONG_MAX;
const ul MAX = ULONG_MAX;
const char nl = '\n';
#define elif else if
#define def inline auto
#define run __attribute__((... | #include <bits/stdc++.h>
using namespace std;
// Define
using ll = int64_t;
using ul = uint64_t;
using ld = long double;
using pii = pair<int, int>;
const ll MOD = 1e9 + 7;
const ll INF = LONG_MAX;
const ul MAX = ULONG_MAX;
const char nl = '\n';
#define elif else if
#define def inline auto
#define run __attribute__((... | [
"control_flow.branch.if.add"
] | 1,041,824 | 1,041,825 | u874039158 | cpp |
p03253 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <unordered_map>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const ll mod = 1000000007ll;
unordered_map<ll, ll> facto... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <unordered_map>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const ll mod = 1000000007ll;
unordered_map<ll, ll> facto... | [
"expression.operation.binary.change",
"assignment.change",
"expression.operation.binary.remove"
] | 1,041,837 | 1,041,838 | u200030766 | cpp |
p03253 |
#define debug_interval ','
#define dump_interval ' '
#define debug_toggle 1
//{
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define INT_MAX LLONG_MAX
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define pb push_back
#define all(v) (v).begin()... |
#define debug_interval ','
#define dump_interval ' '
#define debug_toggle 1
//{
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define INT_MAX LLONG_MAX
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define pb push_back
#define all(v) (v).begin()... | [
"expression.operation.binary.change",
"assignment.change"
] | 1,041,849 | 1,041,850 | u130196064 | cpp |
p03253 | #include <cstdio>
#include <map>
#include <vector>
using namespace std;
#define MOD 1000000007
long long factorial[100010] = {};
long long fact_inv[100010] = {};
long long inv[100010] = {};
int N = 100000;
long long power(long long n, int p) {
if (p == 0) {
return 1;
}
if (p == 1) {
return n % MOD;
... | #include <cstdio>
#include <map>
#include <vector>
using namespace std;
#define MOD 1000000007
long long factorial[200010] = {};
long long fact_inv[200010] = {};
long long inv[200010] = {};
int N = 200001;
long long power(long long n, int p) {
if (p == 0) {
return 1;
}
if (p == 1) {
return n % MOD;
... | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"variable_declaration.value.change"
] | 1,041,851 | 1,041,852 | u429843511 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define Rep(i, n0, n) for (ll i = n0; i < n; i++)
#define Com(i, j, n) \
for (int i = 0; i < n - 1; i++) \
for (int j =... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define Rep(i, n0, n) for (ll i = n0; i < n; i++)
#define Com(i, j, n) \
for (int i = 0; i < n - 1; i++) \
for (int j =... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 1,041,854 | 1,041,855 | u987208743 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
//#include <boost/multiprecision/cpp_int.hpp>
// using multiInt = boost::multiprecision::cpp_int;
using ll = long long int;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename Q_temp>
using smaller_queue = priority_queue<Q_temp,... | #include <bits/stdc++.h>
using namespace std;
//#include <boost/multiprecision/cpp_int.hpp>
// using multiInt = boost::multiprecision::cpp_int;
using ll = long long int;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename Q_temp>
using smaller_queue = priority_queue<Q_temp,... | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,041,860 | 1,041,861 | u878615689 | cpp |
p03253 | #include <bits/stdc++.h>
#define LL long long
using namespace std;
const int maxn = 1e5 + 10;
const int mod = 1e9 + 7;
inline LL qpow(LL a, LL t) {
LL ans = 1LL;
a %= mod;
for (; t; t >>= 1, a = a * a % mod)
if (t & 1)
ans = ans * a % mod;
return ans;
}
LL fac[maxn], inv[maxn];
bool vis[maxn];
void in... | #include <bits/stdc++.h>
#define LL long long
using namespace std;
const int maxn = 2e5 + 10;
const int mod = 1e9 + 7;
inline LL qpow(LL a, LL t) {
LL ans = 1LL;
a %= mod;
for (; t; t >>= 1, a = a * a % mod)
if (t & 1)
ans = ans * a % mod;
return ans;
}
LL fac[maxn], inv[maxn];
bool vis[maxn];
void in... | [
"literal.number.change",
"expression.operation.binary.change"
] | 1,041,865 | 1,041,866 | u682322833 | cpp |
p03253 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <vector>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(a) (a).begin(), (a).end()
typedef long lon... | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <vector>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(a) (a).begin(), (a).end()
typedef long lon... | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 1,041,867 | 1,041,868 | u484460274 | cpp |
p03253 | typedef long long ll;
#include <bits/stdc++.h>
using namespace std;
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
const ll MOD = 1000000007;
const int SIZE = 110000;
ll inv[SIZE], fac[SIZE], finv[SIZE];
void make() {
fac[0] = fa... | typedef long long ll;
#include <bits/stdc++.h>
using namespace std;
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
const ll MOD = 1000000007;
const int SIZE = 110000;
ll inv[SIZE], fac[SIZE], finv[SIZE];
void make() {
fac[0] = fa... | [
"assignment.add"
] | 1,041,869 | 1,041,870 | u121794232 | cpp |
p03253 | #include <cmath>
#include <cstdio>
using namespace std;
long long int f(long long int x, long long int y, long long int p) {
int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) {
res = (res * x) % p;
}
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int ncr(int n, int r) {
long l... | #include <cmath>
#include <cstdio>
using namespace std;
long long int f(long long int x, long long int y, long long int p) {
int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) {
res = (res * x) % p;
}
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int ncr(int n, int r) {
long l... | [
"assignment.add"
] | 1,041,873 | 1,041,874 | u340969800 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
constexpr long Mod = 1000000007;
long N, M, c, ans = 1;
long modinv(long a) {
long ret = 1, n = Mod - 2;
while (n) {
if (n & 1)
ret = ret * a % Mod;
a = a * a % Mod;
n /= 2;
}
return ret;
}
long C(long b) {
long ret = 1, den = 1;
for (; b; -... | #include <bits/stdc++.h>
using namespace std;
constexpr long Mod = 1000000007;
long N, M, c, ans = 1;
long modinv(long a) {
long ret = 1, n = Mod - 2;
while (n) {
if (n & 1)
ret = ret * a % Mod;
a = a * a % Mod;
n /= 2;
}
return ret;
}
long C(long b) {
long ret = 1, den = 1;
for (; b; -... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,041,875 | 1,041,876 | u462437857 | cpp |
p03253 | #include <cmath>
#include <cstdio>
#define M 1000000007
bool f[100005];
int c[50005], dp[100050][105];
int main() {
int n, m, i, j, k, l, cnt = 0, ans = 1;
scanf("%d%d", &n, &m);
k = sqrt(m + 0.5);
l = sqrt(k + 0.5);
for (i = 2; i <= l; i++)
for (j = i * i; j <= k; j += i)
f[j] = 1;
k = 0;
for (... | #include <cmath>
#include <cstdio>
#define M 1000000007
bool f[100005];
int c[50005], dp[100050][35];
int main() {
int n, m, i, j, k, l, cnt = 0, ans = 1;
scanf("%d%d", &n, &m);
k = sqrt(m + 0.5);
l = sqrt(k + 0.5);
for (i = 2; i <= l; i++)
for (j = i * i; j <= k; j += i)
f[j] = 1;
l = k;
k = 0;... | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"assignment.add",
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,041,877 | 1,041,878 | u070422134 | cpp |
p03253 | #include <cmath>
#include <cstdio>
#define M 1000000007
bool f[100005];
int c[50005], dp[100050][35];
int main() {
int n, m, i, j, k, l, cnt = 0, ans = 1;
scanf("%d%d", &n, &m);
k = sqrt(m + 0.5);
l = sqrt(k + 0.5);
for (i = 2; i <= l; i++)
for (j = i * i; j <= k; j += i)
f[j] = 1;
k = 0;
for (i... | #include <cmath>
#include <cstdio>
#define M 1000000007
bool f[100005];
int c[50005], dp[100050][35];
int main() {
int n, m, i, j, k, l, cnt = 0, ans = 1;
scanf("%d%d", &n, &m);
k = sqrt(m + 0.5);
l = sqrt(k + 0.5);
for (i = 2; i <= l; i++)
for (j = i * i; j <= k; j += i)
f[j] = 1;
l = k;
k = 0;... | [
"assignment.add",
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,041,879 | 1,041,878 | u070422134 | cpp |
p03253 | #include <bits/stdc++.h>
using namespace std;
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
using LL = long long;
using VL = vector<LL>;
using VVL = vector<VL>;
using PLL = pair<LL, LL>;
using VS = vector<string>;
#define ALL(a) begin((a)), end((a))
#define RALL(a) (a).rbegin(), (a).rend... | #include <bits/stdc++.h>
using namespace std;
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
using LL = long long;
using VL = vector<LL>;
using VVL = vector<VL>;
using PLL = pair<LL, LL>;
using VS = vector<string>;
#define ALL(a) begin((a)), end((a))
#define RALL(a) (a).rbegin(), (a).rend... | [
"control_flow.loop.for.condition.change"
] | 1,041,880 | 1,041,881 | u157085392 | cpp |
p03253 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < ((int)(n)); i++)
#define reg(i, a, b) for (in... | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < ((int)(n)); i++)
#define reg(i, a, b) for (in... | [
"literal.number.change",
"call.arguments.change"
] | 1,041,892 | 1,041,893 | u372786981 | cpp |
p03253 | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ld, ld> pdd;
#define X first
#define Y second
//#include <boost/unordered_map.hpp>
// using na... | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ld, ld> pdd;
#define X first
#define Y second
//#include <boost/unordered_map.hpp>
// using na... | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 1,041,898 | 1,041,899 | u918714262 | cpp |
p03253 | #include <iostream>
#include <map>
using namespace std;
typedef long long ll;
int N, M;
ll inf = 1e9 + 7;
ll func[100010] = {0};
ll inv[100010] = {0};
ll mult(ll n, ll m) {
if (n == 0 || m == 0)
return 1;
if (m == 1)
return n % inf;
else if (m % 2 == 0) {
ll t = mult(n, m / 2);
return (t * t) % ... | #include <iostream>
#include <map>
using namespace std;
typedef long long ll;
ll N, M;
ll inf = 1e9 + 7;
ll func[200010] = {0};
ll inv[200010] = {0};
ll mult(ll n, ll m) {
if (n == 0 || m == 0)
return 1;
if (m == 1)
return n % inf;
else if (m % 2 == 0) {
ll t = mult(n, m / 2);
return (t * t) % i... | [
"variable_declaration.type.change",
"literal.number.change",
"variable_declaration.array_dimensions.change",
"call.arguments.change"
] | 1,041,900 | 1,041,901 | u623954643 | cpp |
p03254 | #include <bits/stdc++.h>
using namespace std;
int a[110];
int main() {
int n, x, i, cou = 0, ch = 0;
scanf("%d %d", &n, &x);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a, a + n);
for (i = 0; i < n; i++) {
if (a[i] <= x) {
ch++;
cou++;
x -= a[i];
}
}
if (x && ch)
... | #include <bits/stdc++.h>
using namespace std;
int a[110];
int main() {
int n, x, i, cou = 0, ch = 0;
scanf("%d %d", &n, &x);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a, a + n);
for (i = 0; i < n; i++) {
if (a[i] <= x) {
ch++;
cou++;
x -= a[i];
}
}
if (x && ch &&... | [
"control_flow.branch.if.condition.change"
] | 1,041,902 | 1,041,903 | u816631826 | cpp |
p03254 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
const int M = 1e7;
int si[] = {-1, 0, 1, 0};
int sj[] = {0, -1, 0, 1};
int main() {
int n;
ll x;
cin >> n >> x;
vector<int> a(n);
rep(i, n) cin >> a[i];
sort(a.begin(), a.end());
int... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
const int M = 1e7;
int si[] = {-1, 0, 1, 0};
int sj[] = {0, -1, 0, 1};
int main() {
int n;
ll x;
cin >> n >> x;
vector<int> a(n);
rep(i, n) cin >> a[i];
sort(a.begin(), a.end());
int... | [
"control_flow.branch.if.condition.change"
] | 1,041,906 | 1,041,907 | u106342872 | cpp |
p03254 | #include <bits/stdc++.h>
using namespace std;
#define SPEED \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
#define int long ... | #include <bits/stdc++.h>
using namespace std;
#define SPEED \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
#define int long ... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 1,041,910 | 1,041,911 | u597003860 | cpp |
p03254 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(v) begin(v), end(v)
using ll = long long;
int main() {
ll n, x;
cin >> n >> x;
vector<ll> a(n);
rep(i, n) cin >> a[i];
sort(all(a));
int cnt = 0;
rep(i, n) {
x -= a[i];
if (x <= 0)
brea... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(v) begin(v), end(v)
using ll = long long;
int main() {
ll n, x;
cin >> n >> x;
vector<ll> a(n);
rep(i, n) cin >> a[i];
sort(all(a));
int cnt = 0;
rep(i, n) {
x -= a[i];
if (x < 0)
break... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 1,041,923 | 1,041,924 | u587622858 | cpp |
p03254 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef long long ll;
int main(void) {
int N, x, cnt = 0;
cin >> N >> x;
vector<int> a(N);
rep(i, N) { cin >> a[i]; }
sort(a.begin(), a.end());
rep(i, N) {
if (x >= a[i]) {
x -= a[i];
cnt++;
... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef long long ll;
int main(void) {
int N, x, cnt = 0;
cin >> N >> x;
vector<int> a(N);
rep(i, N) { cin >> a[i]; }
sort(a.begin(), a.end());
rep(i, N) {
if (x >= a[i]) {
x -= a[i];
cnt++;
... | [] | 1,041,941 | 1,041,942 | u457950793 | cpp |
p03254 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long N, x;
cin >> N >> x;
vector<long long> a(N);
for (int i = 0; i < N; i++) {
cin >> a.at(i);
}
sort(a.begin(), a.end());
long long sum = 0, ans = N;
for (int i = 0; i < N; i++) {
sum += a.at(i);
}
while (sum > x) {
sum -=... | #include <bits/stdc++.h>
using namespace std;
int main() {
long long N, x;
cin >> N >> x;
vector<long long> a(N);
for (int i = 0; i < N; i++) {
cin >> a.at(i);
}
sort(a.begin(), a.end());
long long sum = 0, ans = N;
for (int i = 0; i < N; i++) {
sum += a.at(i);
}
while (sum > x) {
sum -=... | [] | 1,041,943 | 1,041,944 | u201304522 | cpp |
p03254 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long N, x;
cin >> N >> x;
vector<long long> a(N);
for (int i = 0; i < N; i++) {
cin >> a.at(i);
}
sort(a.begin(), a.end());
long long sum = 0, ans = N;
for (int i = 0; i < N; i++) {
sum += a.at(i);
}
while (sum > x) {
sum -=... | #include <bits/stdc++.h>
using namespace std;
int main() {
long long N, x;
cin >> N >> x;
vector<long long> a(N);
for (int i = 0; i < N; i++) {
cin >> a.at(i);
}
sort(a.begin(), a.end());
long long sum = 0, ans = N;
for (int i = 0; i < N; i++) {
sum += a.at(i);
}
while (sum > x) {
sum -=... | [
"control_flow.branch.if.condition.change"
] | 1,041,945 | 1,041,944 | u201304522 | cpp |
p03254 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define Rep(i, s, f) for (int i = (int)s; i < (int)f; i++)
using ll = long long;
using namespace std;
int main() {
int N;
cin >> N;
int x;
cin >> x;
vector<ll> A(N);
rep(i, N) cin >> A[i];
sort(A.begin(), A.end());
int ans = 0;... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define Rep(i, s, f) for (int i = (int)s; i < (int)f; i++)
using ll = long long;
using namespace std;
int main() {
int N;
cin >> N;
int x;
cin >> x;
vector<ll> A(N);
rep(i, N) cin >> A[i];
sort(A.begin(), A.end());
int ans = 0;... | [] | 1,041,952 | 1,041,953 | u415400221 | cpp |
p03254 | #include <bits/stdc++.h>
using namespace std;
int main() {
int64_t N, x, ans = 0;
cin >> N >> x;
vector<int64_t> A(N);
for (int i = 0; i < N; i++) {
cin >> A.at(i);
}
sort(A.begin(), A.end());
for (int i = 0; i < N; i++) {
if (x - A.at(i) >= 0) {
x -= A.at(i);
ans++;
}
}
if (x... | #include <bits/stdc++.h>
using namespace std;
int main() {
int64_t N, x, ans = 0;
cin >> N >> x;
vector<int64_t> A(N);
for (int i = 0; i < N; i++) {
cin >> A.at(i);
}
sort(A.begin(), A.end());
for (int i = 0; i < N; i++) {
if (x - A.at(i) >= 0) {
x -= A.at(i);
ans++;
}
}
if (x... | [
"control_flow.branch.if.condition.change"
] | 1,041,954 | 1,041,955 | u543466827 | cpp |
p03254 | #pragma region header
#include <assert.h>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>... | #pragma region header
#include <assert.h>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>... | [
"variable_declaration.add",
"identifier.change",
"control_flow.branch.if.condition.change"
] | 1,041,958 | 1,041,959 | u851044959 | cpp |
p03254 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N;
long long x;
cin >> N >> x;
vector<long long> a;
for (int i = 0; i < N; i++) {
long long tmp;
cin >> tmp;
a.push_back(tmp);
}
sort(a.begin(), a.end());
int ans = 0;
for (int i = 0; i < N;... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N;
long long x;
cin >> N >> x;
vector<long long> a;
for (int i = 0; i < N; i++) {
long long tmp;
cin >> tmp;
a.push_back(tmp);
}
sort(a.begin(), a.end());
int ans = 0;
for (int i = 0; i < N;... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 1,041,960 | 1,041,961 | u154904553 | cpp |
p03254 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, x;
cin >> N >> x;
vector<int> a(N);
for (int i = 0; i < N; i++) {
cin >> a.at(i);
}
sort(a.begin(), a.end());
int ans = 0, c = 0;
for (int i = 0; i < N && x - a.at(i) >= 0; i++) {
x -= a.at(i);
... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, x;
cin >> N >> x;
vector<int> a(N);
for (int i = 0; i < N; i++) {
cin >> a.at(i);
}
sort(a.begin(), a.end());
int ans = 0, c = 0;
for (int i = 0; i < N && x - a.at(i) >= 0; i++) {
x -= a.at(i);
... | [
"control_flow.branch.if.condition.change"
] | 1,041,966 | 1,041,967 | u235321041 | cpp |
p03254 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, x;
cin >> N >> x;
int a;
vector<int> A(N);
for (int i = 0; i < N; i++) {
cin >> a;
A.at(i) = a;
}
sort(A.begin(), A.end());
int count = 0;
for (int i = 0; i < N; i++) {
x =... | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, x;
cin >> N >> x;
int a;
vector<int> A(N);
for (int i = 0; i < N; i++) {
cin >> a;
A.at(i) = a;
}
sort(A.begin(), A.end());
int count = 0;
for (int i = 0; i < N; i++) {
x =... | [
"expression.operation.compare.replace.add",
"assignment.replace.remove",
"misc.typo"
] | 1,041,972 | 1,041,973 | u125180853 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.