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 |
|---|---|---|---|---|---|---|---|
p03196 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
#define repl(i, l, r) for (ll i = l; i < r; i++)
#define rep(i, n) repl(i, 0, n)
using namespac... | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
#define repl(i, l, r) for (ll i = l; i < r; i++)
#define rep(i, n) repl(i, 0, n)
using namespac... | [
"identifier.change",
"io.output.change"
] | 990,672 | 990,673 | u401139594 | cpp |
p03196 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
#define repl(i, l, r) for (ll i = l; i < r; i++)
#define rep(i, n) repl(i, 0, n)
using namespac... | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
#define repl(i, l, r) for (ll i = l; i < r; i++)
#define rep(i, n) repl(i, 0, n)
using namespac... | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 990,674 | 990,673 | u401139594 | cpp |
p03196 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <ctype.h>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define REP(i, n) for (ll i = 0; i < (ll)(n); ++i)
templa... | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <ctype.h>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define REP(i, n) for (ll i = 0; i < (ll)(n); ++i)
templa... | [
"assignment.change"
] | 990,677 | 990,678 | u450883456 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long>> pf(long long n) {
vector<pair<long long, long long>> res;
for (long long p = 2; p * p <= n; ++p) {
if (n % p != 0)
continue;
int num = 0;
while (n % p == 0) {
++num;
n /= p;
}
res.push_back(make_p... | #include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long>> pf(long long n) {
vector<pair<long long, long long>> res;
for (long long p = 2; p * p <= n; ++p) {
if (n % p != 0)
continue;
int num = 0;
while (n % p == 0) {
++num;
n /= p;
}
res.push_back(make_p... | [] | 990,689 | 990,690 | u367131219 | cpp |
p03196 | #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <st... | #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <st... | [
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.add"
] | 990,705 | 990,706 | u631558039 | cpp |
p03196 | #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <st... | #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <st... | [
"call.arguments.change",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.add"
] | 990,707 | 990,706 | u631558039 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
#define debug(n) cerr << #n << ':' << n << endl;
#define dline cerr << __LINE__ << endl;
using ll = long long;
using ull = unsigned long long;
template <class T, class U> using P = pair<T, U>;
template <class T> using Heap = priority_queue<T>;
template <class T> using he... | #include <bits/stdc++.h>
using namespace std;
#define debug(n) cerr << #n << ':' << n << endl;
#define dline cerr << __LINE__ << endl;
using ll = long long;
using ull = unsigned long long;
template <class T, class U> using P = pair<T, U>;
template <class T> using Heap = priority_queue<T>;
template <class T> using he... | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 990,708 | 990,709 | u691380397 | cpp |
p03196 | #include <iostream>
#include <utility>
#include <vector>
int main() {
static bool sieve[1000001];
long long n, p;
std::cin >> n >> p;
long long c = 2;
bool end = false;
long long nfact = 0;
long long ans = 1;
if (n == 1) {
std::cout << n << "\n";
return 0;
}
while (p > 1 && c < 1000001 && !... | #include <iostream>
#include <utility>
#include <vector>
int main() {
static bool sieve[1000001];
long long n, p;
std::cin >> n >> p;
long long c = 2;
bool end = false;
long long nfact = 0;
long long ans = 1;
if (n == 1) {
std::cout << p << "\n";
return 0;
}
while (p > 1 && c < 1000001 && !... | [
"identifier.change",
"expression.operation.binary.change"
] | 990,724 | 990,725 | u060431747 | cpp |
p03196 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using ll = long long int;
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using ll = long long int;
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
... | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change"
] | 990,726 | 990,727 | u167245594 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define ld long double
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
... | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define ld long double
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
... | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change"
] | 990,732 | 990,733 | u876953939 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
map<long long int, ll> prime_factor(long long int n) {
map<ll, ll> ret;
for (long long int i = 2; i * i <= n; i++) {
while (n % i == 0) {
ret[i]++;
n /= i;
}
}
if (n != 1)
ret[n] = 1;
return ret;
}
int main() {
ll ... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
map<long long int, ll> prime_factor(long long int n) {
map<ll, ll> ret;
for (long long int i = 2; i * i <= n; i++) {
while (n % i == 0) {
ret[i]++;
n /= i;
}
}
if (n != 1)
ret[n] = 1;
return ret;
}
int main() {
ll ... | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 990,736 | 990,737 | u412408615 | cpp |
p03196 | // C
#ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#i... | // C
#ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#i... | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change"
] | 990,746 | 990,747 | u274657603 | cpp |
p03196 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> ii;
typedef long long ll;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll MOD = 1e9 + 7;
i... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> ii;
typedef long long ll;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll MOD = 1e9 + 7;
i... | [
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.add"
] | 990,770 | 990,771 | u765815947 | cpp |
p03196 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> ii;
typedef long long ll;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll MOD = 1e9 + 7;
i... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> ii;
typedef long long ll;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll MOD = 1e9 + 7;
i... | [
"control_flow.loop.for.initializer.change",
"variable_declaration.type.change",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.add"
] | 990,772 | 990,771 | u765815947 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (long long i = 0; i < N; i++)
using ll = long long;
/////////////////////////////////////////////////////
// 素因数分解 pair<指数, 乗数>
vector<pair<ll, ll>> prime_factorize(ll N) {
vector<pair<ll, ll>> res;
for (ll a = 2; a * a <= N; ++a) {
if (N % a ... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (long long i = 0; i < N; i++)
using ll = long long;
/////////////////////////////////////////////////////
// 素因数分解 pair<指数, 乗数>
vector<pair<ll, ll>> prime_factorize(ll N) {
vector<pair<ll, ll>> res;
for (ll a = 2; a * a <= N; ++a) {
if (N % a ... | [
"assignment.value.change",
"expression.operation.binary.change"
] | 990,775 | 990,776 | u314642288 | cpp |
p03196 | #include <bits/stdc++.h>
#define irep(i, n) for (int i = 0; i < (int)(n); i++)
#define irep2(i, a, n) for (int i = (int)(a); i <= (int)(n); i++)
#define lrep(i, n) for (long long i = 0; i < (long long)(n); i++)
#define lrep2(i, a, n) \
for (long long i = (long ... | #include <bits/stdc++.h>
#define irep(i, n) for (int i = 0; i < (int)(n); i++)
#define irep2(i, a, n) for (int i = (int)(a); i <= (int)(n); i++)
#define lrep(i, n) for (long long i = 0; i < (long long)(n); i++)
#define lrep2(i, a, n) \
for (long long i = (long ... | [
"call.arguments.add",
"control_flow.branch.if.condition.change"
] | 990,783 | 990,784 | u829260400 | cpp |
p03196 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using Graph = vector<vector<int>>;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define rep2(i, n, m) for (ll i = n; i <= m; i++)
#define rep3(i, n, m) for (ll i = n; ... | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using Graph = vector<vector<int>>;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define rep2(i, n, m) for (ll i = n; i <= m; i++)
#define rep3(i, n, m) for (ll i = n; ... | [
"assignment.change",
"call.arguments.change"
] | 990,793 | 990,794 | u449123607 | cpp |
p03196 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using Graph = vector<vector<int>>;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define rep2(i, n, m) for (ll i = n; i <= m; i++)
#define rep3(i, n, m) for (ll i = n; ... | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using Graph = vector<vector<int>>;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define rep2(i, n, m) for (ll i = n; i <= m; i++)
#define rep3(i, n, m) for (ll i = n; ... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"call.arguments.change"
] | 990,795 | 990,794 | u449123607 | cpp |
p03196 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using Graph = vector<vector<int>>;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define rep2(i, n, m) for (ll i = n; i <= m; i++)
#define rep3(i, n, m) for (ll i = n; ... | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using Graph = vector<vector<int>>;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define rep2(i, n, m) for (ll i = n; i <= m; i++)
#define rep3(i, n, m) for (ll i = n; ... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"variable_declaration.type.change",
"call.arguments.change"
] | 990,796 | 990,794 | u449123607 | cpp |
p03196 | #include "bits/stdc++.h"
#define rep(i, N) for (int i = 0; i < N; i++)
typedef long long ll;
const int mod = 1e9 + 7;
using namespace std;
//素因数分解
map<ll, int> factor(ll n) {
map<ll, int> f;
for (ll i = 2; i * i < n; i++) {
int x = 0;
while (n % i == 0)
n /= i, x++;
if (x != 0)
f[i] = x... | #include "bits/stdc++.h"
#define rep(i, N) for (int i = 0; i < N; i++)
typedef long long ll;
const int mod = 1e9 + 7;
using namespace std;
//素因数分解
map<ll, int> factor(ll n) {
map<ll, int> f;
for (ll i = 2; i * i <= n; i++) {
int x = 0;
while (n % i == 0)
n /= i, x++;
if (x != 0)
f[i] = ... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 990,803 | 990,804 | u909017535 | cpp |
p03196 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctype.h>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <unordered_map>
#include <vector>
using... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctype.h>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <unordered_map>
#include <vector>
using... | [
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.add"
] | 990,812 | 990,813 | u277153875 | cpp |
p03196 | // include
// ------------------------------------------------
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
// func
// ------------------------------------------------
int CalcSumOfDigit(int n); // 各桁の和を計算する。
int getDigit(int n); // 数字の桁数を取得する。
string upper(string str); // 英字を大文字に変換する。
strin... | // include
// ------------------------------------------------
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
// func
// ------------------------------------------------
int CalcSumOfDigit(int n); // 各桁の和を計算する。
int getDigit(int n); // 数字の桁数を取得する。
string upper(string str); // 英字を大文字に変換する。
strin... | [
"variable_declaration.add",
"assignment.value.change",
"identifier.change"
] | 990,814 | 990,815 | u610897920 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, cc, n) for (int i = cc; i < n; ++i)
#define lrep(i, cc, n) for (long long i = cc; i < n; ++i)
#define rrep(i, cc, n) for (long i = cc; i > n; --i)
#define pii pair<int, int>
#define pll pair<long long, long long>
using ll = long long;
const ll inf = 10010010... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, cc, n) for (int i = cc; i < n; ++i)
#define lrep(i, cc, n) for (long long i = cc; i < n; ++i)
#define rrep(i, cc, n) for (long i = cc; i > n; --i)
#define pii pair<int, int>
#define pll pair<long long, long long>
using ll = long long;
const ll inf = 10010010... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 990,816 | 990,817 | u330518333 | cpp |
p03196 | // #include <bits/stdc++.h>
// #define rep(i,n) for (int i = 0; i < (n); ++i)
// using namespace std;
// typedef long long ll;
//
//
//
// int main(){
// ll n,p;
// std::cin >> n>>p;
// if(n==1){
// std::cout << p << '\n';
// return 0;
// }
//
//
//
// //素数列挙
// ll now=2;
// std::vector<ll> pri(po... | // #include <bits/stdc++.h>
// #define rep(i,n) for (int i = 0; i < (n); ++i)
// using namespace std;
// typedef long long ll;
//
//
//
// int main(){
// ll n,p;
// std::cin >> n>>p;
// if(n==1){
// std::cout << p << '\n';
// return 0;
// }
//
//
//
// //素数列挙
// ll now=2;
// std::vector<ll> pri(po... | [
"expression.operation.binary.remove"
] | 990,846 | 990,847 | u280097533 | cpp |
p03196 | #include <bits/stdc++.h>
//----***やべーやつら***----
using namespace std;
#define int long long
//----***型定義***----
using ll = long long;
using P = pair<int, int>;
//----***Like a Pythonista***----
#define REP(ii, jj, nn) for (ll ii = jj; ii < (nn); ii++)
#define RREP(ii, nn, jj) for (ll ii = nn; jj < ii; ii--)
#define ea... | #include <bits/stdc++.h>
//----***やべーやつら***----
using namespace std;
#define int long long
//----***型定義***----
using ll = long long;
using P = pair<int, int>;
//----***Like a Pythonista***----
#define REP(ii, jj, nn) for (ll ii = jj; ii < (nn); ii++)
#define RREP(ii, nn, jj) for (ll ii = nn; jj < ii; ii--)
#define ea... | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 990,864 | 990,865 | u526459074 | cpp |
p03196 | /*
PAIN demands to be felt
so do RE, TLE, MLE, SIGSEV & WA
*/
#include <bits/stdc++.h>
using namespace std;
// -----------------<fast IO>------------------
#define CIN \
ios::sync_with_stdio(0); ... | /*
PAIN demands to be felt
so do RE, TLE, MLE, SIGSEV & WA
*/
#include <bits/stdc++.h>
using namespace std;
// -----------------<fast IO>------------------
#define CIN \
ios::sync_with_stdio(0); ... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 990,868 | 990,869 | u342003594 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
typedef long long ll;
int main() {
ll n, p;
cin >> n >> p;
ll p1 = pow(p, 1.0 / n);
// cout<<p1<<endl;
for (ll i = p1; i >= 1; --i) {
ll tmp = pow(i, n);
if (p % tmp == 0) {
cout << i <... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
typedef long long ll;
int main() {
ll n, p;
cin >> n >> p;
ll p1 = pow(p, 1.0 / n);
// cout<<p1<<endl;
for (ll i = p1 + 100; i >= 1; --i) {
ll tmp = pow(i, n);
if (p % tmp == 0) {
cout ... | [
"control_flow.loop.for.initializer.change"
] | 990,870 | 990,871 | u933962236 | cpp |
p03196 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
int main() {
ll n, p, i, ans = 1, ... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
int main() {
ll n, p, i, ans = 1, ... | [
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.add"
] | 990,905 | 990,906 | u265187423 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int>>;
vector<pair<long long, long long>> prime_foctorize(long long N) {
vector<pair<long long, long long>> res;
for (long long i = 2; i * i < N; i++) {
if (N % i != 0)
continue;
long long ex = 0;
while (N % i == 0) {
... | #include <bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int>>;
vector<pair<long long, long long>> prime_foctorize(long long N) {
vector<pair<long long, long long>> res;
for (long long i = 2; i * i <= N; i++) {
if (N % i != 0)
continue;
long long ex = 0;
while (N % i == 0) {
... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 990,907 | 990,908 | u533566373 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define ll long long
void prime_factorize(ll N, map<ll, ll> &res) {
for (ll a = 2; a * a <= N; ++a) {
if (N % a != 0)
continue;
ll ex = 0; // 指数
// 割れる限り割り続ける
while (N % a == 0) {
++ex;
N /=... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define ll long long
void prime_factorize(ll N, map<ll, ll> &res) {
for (ll a = 2; a * a <= N; ++a) {
if (N % a != 0)
continue;
ll ex = 0; // 指数
// 割れる限り割り続ける
while (N % a == 0) {
++ex;
N /=... | [
"assignment.variable.change",
"call.arguments.add",
"expression.operation.binary.remove"
] | 990,909 | 990,910 | u702686470 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define PI acos(-1)
#define fast_io \
ios_base::sync_with_stdio(false); ... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define PI acos(-1)
#define fast_io \
ios_base::sync_with_stdio(false); ... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 990,913 | 990,914 | u679159704 | cpp |
p03196 | #include <bits/stdc++.h>
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
constexpr int MOD = 1000000007;
constexpr int INF = numeric_limits<int>::max() / 2;
typedef pair<int, int> P;
using Graph = vector<vector<int>>;
template <class T> inline bool chmax(T &a, T b) {
if... | #include <bits/stdc++.h>
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
constexpr int MOD = 1000000007;
constexpr int INF = numeric_limits<int>::max() / 2;
typedef pair<int, int> P;
using Graph = vector<vector<int>>;
template <class T> inline bool chmax(T &a, T b) {
if... | [
"assignment.variable.change",
"assignment.change"
] | 990,917 | 990,918 | u415916075 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
const double PI = acos(-1);
int main() {
ll n, p;
cin >> n >> p;
ll ans = 0;
for (ll i = pow(p, 1.0 / n); 1 <= i; i--) {
ll tmp = pow(i, n);
if (p % tmp != 0)
continue;
ans = i;
break;
}
cou... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
const double PI = acos(-1);
int main() {
ll n, p;
cin >> n >> p;
ll ans = 0;
for (ll i = pow(p, 1.0 / n) + 1; 1 <= i; i--) {
ll tmp = pow(i, n);
if (p % tmp != 0)
continue;
ans = i;
break;
}
... | [
"control_flow.loop.for.initializer.change"
] | 990,921 | 990,922 | u050087249 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
const double PI = acos(-1);
int main() {
ll n, p;
cin >> n >> p;
ll ans = 0;
for (ll i = pow(p, 1.0 / n); 0 <= i; i--) {
ll tmp = pow(i, n);
if (p % tmp != 0)
continue;
ans = i;
break;
}
cou... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
const double PI = acos(-1);
int main() {
ll n, p;
cin >> n >> p;
ll ans = 0;
for (ll i = pow(p, 1.0 / n) + 1; 1 <= i; i--) {
ll tmp = pow(i, n);
if (p % tmp != 0)
continue;
ans = i;
break;
}
... | [
"control_flow.loop.for.initializer.change",
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 990,923 | 990,922 | u050087249 | cpp |
p03196 | #include "bits/stdc++.h"
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII> VPII;
typedef long long LL;
typedef vector<LL> VL;
typedef vector<VL> VVL;
typedef pair<LL, LL> PLL;
typedef vector<PLL> VPLL;
typedef priority_queue... | #include "bits/stdc++.h"
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII> VPII;
typedef long long LL;
typedef vector<LL> VL;
typedef vector<VL> VVL;
typedef pair<LL, LL> PLL;
typedef vector<PLL> VPLL;
typedef priority_queue... | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change"
] | 990,928 | 990,929 | u987591601 | cpp |
p03196 | // int a = stoi(c); 文字列をintへ
//小文字から大文字
// transform(a.begin(), a.end(), a.begin(), ::toupper);
//途中の出力をそのまま残さない
//数値計算 個数以外はdouble
// map<キー,値> p は辞書。p[キー] = 値
// map 全探索
// auto begin = p.begin(), end = p.end();
// for (auto it = begin; it != end; it++) {}
// mapのキー：it->first mapのバリュー：it->second
//絶対値 abs()
//入力は空白で切... | // int a = stoi(c); 文字列をintへ
//小文字から大文字
// transform(a.begin(), a.end(), a.begin(), ::toupper);
//途中の出力をそのまま残さない
//数値計算 個数以外はdouble
// map<キー,値> p は辞書。p[キー] = 値
// map 全探索
// auto begin = p.begin(), end = p.end();
// for (auto it = begin; it != end; it++) {}
// mapのキー：it->first mapのバリュー：it->second
//絶対値 abs()
//入力は空白で切... | [
"variable_declaration.value.change",
"identifier.change",
"control_flow.loop.for.initializer.change"
] | 990,941 | 990,942 | u565692645 | cpp |
p03196 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
// Optimisations
#pragma GCC target("avx2")
#pragma GCC optimization("unroll-loops")
#pragma GCC optimize("O2")
// shortcuts for functions
#define pb emplace_back
#define mp make_pair
#define ff first
#def... | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
// Optimisations
#pragma GCC target("avx2")
#pragma GCC optimization("unroll-loops")
#pragma GCC optimize("O2")
// shortcuts for functions
#define pb emplace_back
#define mp make_pair
#define ff first
#def... | [
"call.remove"
] | 990,945 | 990,946 | u996003680 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define MOD 1000000007
#define MOD2 998244353
#define INF ((1 << 30) - 1)
#define LINF (1LL << 60)
#define EPS (1e-10)
typedef long long Int;
typedef pair<Int, Int> P;
vector<pair<int64_t, int64_t>> prime_factorize(int64_t n) {... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define MOD 1000000007
#define MOD2 998244353
#define INF ((1 << 30) - 1)
#define LINF (1LL << 60)
#define EPS (1e-10)
typedef long long Int;
typedef pair<Int, Int> P;
vector<pair<int64_t, int64_t>> prime_factorize(int64_t n) {... | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 990,955 | 990,956 | u868237899 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
long long N, P;
cin >> N >> P;
long long pp;
pp = int(pow(P, 0.5));
vector<long long> prime(pp + 1, 0);
for (long long i = 2; i <= P && i <= pp; i++) {
while (P % i == 0) {
P = P / i;
prime.at(i)++;
}
}
long long ans = 1;... | #include <bits/stdc++.h>
using namespace std;
int main(void) {
long long N, P;
cin >> N >> P;
long long pp;
pp = int(pow(P, 0.5));
vector<long long> prime(pp + 1, 0);
for (long long i = 2; i <= P && i <= pp; i++) {
while (P % i == 0) {
P = P / i;
prime.at(i)++;
}
}
long long ans = 1;... | [
"expression.operation.binary.remove"
] | 990,964 | 990,965 | u478462004 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define FOR(i, l, r) for (i = l; i < r; i++)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
#define P pair<ll, ll>
#define F first
#define S second
#define VEC vector
#define V VEC<ll>
signed main() {
ll N, Q, ans;
cin >> N >>... | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define FOR(i, l, r) for (i = l; i < r; i++)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
#define P pair<ll, ll>
#define F first
#define S second
#define VEC vector
#define V VEC<ll>
signed main() {
ll N, Q, ans;
cin >> N >>... | [
"assignment.change"
] | 990,966 | 990,967 | u820224016 | cpp |
p03196 | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define ALL(v) (v.begin(), v.end(... | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define ALL(v) (v.begin(), v.end(... | [
"expression.operation.binary.remove",
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 990,968 | 990,969 | u459105164 | cpp |
p03196 | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define ALL(v) (v.begin(), v.end(... | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define ALL(v) (v.begin(), v.end(... | [
"expression.operator.compare.change",
"control_flow.loop.condition.change",
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 990,970 | 990,969 | u459105164 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
// memo fixed setprecision(20);
using vvll = vector<vector<ll>>;
ll mod = 1000000007;
/*"itob" int to "N"base */ template <typename TypeInt>
string itob(const TypeInt v, int base) {
static const char table[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
// memo fixed setprecision(20);
using vvll = vector<vector<ll>>;
ll mod = 1000000007;
/*"itob" int to "N"base */ template <typename TypeInt>
string itob(const TypeInt v, int base) {
static const char table[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";... | [
"call.arguments.add"
] | 990,971 | 990,972 | u157433024 | cpp |
p03196 | #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <cmath>
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <deque> // deque
#include <iostream> // cou... | #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <cmath>
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <deque> // deque
#include <iostream> // cou... | [
"assignment.add"
] | 990,979 | 990,980 | u668785999 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define erep(i, n) for (int i = 0; i <= n; i++)
#define rep1(i, n) for (int i = 1; i < n; i++)
#define erep1(i, n) for (int i = 1; i <= n; i++)
typedef long long ll;
#define vint vector<int>
#define vvint vector<vector<int>>
#de... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define erep(i, n) for (int i = 0; i <= n; i++)
#define rep1(i, n) for (int i = 1; i < n; i++)
#define erep1(i, n) for (int i = 1; i <= n; i++)
typedef long long ll;
#define vint vector<int>
#define vvint vector<vector<int>>
#de... | [
"identifier.change",
"call.arguments.change"
] | 990,983 | 990,984 | u613960672 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, l, r) for (int i = (int)(l); i < (int)(r); i++)
#define all(x) (x).begin(), (x).end()
#define sz(x) ((int)x.size())
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> ... | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, l, r) for (int i = (int)(l); i < (int)(r); i++)
#define all(x) (x).begin(), (x).end()
#define sz(x) ((int)x.size())
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> ... | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 990,993 | 990,994 | u057866967 | cpp |
p03196 | #include <algorithm>
#include <array>
#include <cmath>
#include <complex>
#include <cstdio>
#include <deque>
#include <float.h>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <... | #include <algorithm>
#include <array>
#include <cmath>
#include <complex>
#include <cstdio>
#include <deque>
#include <float.h>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <... | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 991,007 | 991,008 | u221285045 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mod 1000000007
#define MAX 100000
void inarray(int a[], int n) {
for (int i = 0; i < n; i++)
cin >> a[i];
}
void max_div(ll n);
bool isPrime(ll n);
ll ans, N;
int main() {
ll p;
cin >> N >> p;
ans = 1;
if (N == 1) {
cout << ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mod 1000000007
#define MAX 100000
void inarray(int a[], int n) {
for (int i = 0; i < n; i++)
cin >> a[i];
}
void max_div(ll n);
bool isPrime(ll n);
ll ans, N;
int main() {
ll p;
cin >> N >> p;
ans = 1;
if (N == 1) {
cout << ... | [
"assignment.add"
] | 991,015 | 991,016 | u423656246 | cpp |
p03196 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <stack>
#include <string>
#include <vector>
using namespace std;
void jj(int64_t &p, int prime, int n, int64_t &ans) {
int count = 0;
while (1) {
if (p % prime == 0) {
p /= prime;
count++;
if (count == n) {
... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <stack>
#include <string>
#include <vector>
using namespace std;
void jj(int64_t &p, int prime, int n, int64_t &ans) {
int count = 0;
while (1) {
if (p % prime == 0) {
p /= prime;
count++;
if (count == n) {
... | [
"control_flow.loop.for.condition.change"
] | 991,030 | 991,031 | u229148215 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const static ll INF = 1e9;
const static ll MAXN = 301;
int main() {
ll N, P, P_;
cin >> N >> P;
P_ = P;
vector<ll> V(sqrt(P) + 1);
if (P == 1) {
cout << 1 << endl;
return 0;
}
if (N == 1) {
cout << P << endl;
return 0;
... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const static ll INF = 1e9;
const static ll MAXN = 301;
int main() {
ll N, P, P_;
cin >> N >> P;
P_ = P;
vector<ll> V(sqrt(P) + 1);
if (P == 1) {
cout << 1 << endl;
return 0;
}
if (N == 1) {
cout << P << endl;
return 0;
... | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 991,034 | 991,035 | u521973174 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const static ll INF = 1e9;
const static ll MAXN = 301;
int main() {
ll N, P, P_;
cin >> N >> P;
P_ = P;
vector<ll> V(sqrt(P) + 1);
if (P == 1) {
cout << 1 << endl;
return 0;
}
if (N == 1) {
cout << P << endl;
return 0;
... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const static ll INF = 1e9;
const static ll MAXN = 301;
int main() {
ll N, P, P_;
cin >> N >> P;
P_ = P;
vector<ll> V(sqrt(P) + 1);
if (P == 1) {
cout << 1 << endl;
return 0;
}
if (N == 1) {
cout << P << endl;
return 0;
... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"call.add",
"assignment.value.change",
"call.arguments.change"
] | 991,036 | 991,035 | u521973174 | cpp |
p03196 | #define _LIBCPP_DEBUG 0
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = int(a); i < int(b); i++)
typedef vector<int> vi;
typedef long long ll;
int main() {
ll N, P, an = 1;
cin >> N >> P;
map<ll, ll> m;
rep(i, 2, floor(sqrt(P))) {
while (P % i == 0) {
P /= i;
m[i... | #define _LIBCPP_DEBUG 0
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = int(a); i < int(b); i++)
typedef vector<int> vi;
typedef long long ll;
int main() {
ll N, P, an = 1;
cin >> N >> P;
map<ll, ll> m;
rep(i, 2, floor(sqrt(P)) + 1) {
while (P % i == 0) {
P /= i;
... | [
"expression.operation.binary.add"
] | 991,045 | 991,046 | u293156359 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define F first
#define S second
#define pii pair<int, int>
#define eb emplace_back
#define all(v) v.begin(), v.end()
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep3(i, l, n) for (int i = l; i < (n); ++i)
#define sz(v) (int)v.size()
#defin... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define F first
#define S second
#define pii pair<int, int>
#define eb emplace_back
#define all(v) v.begin(), v.end()
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep3(i, l, n) for (int i = l; i < (n); ++i)
#define sz(v) (int)v.size()
#defin... | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change"
] | 991,049 | 991,050 | u277556971 | cpp |
p03196 | #include <bits/stdc++.h>
#include <math.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
const ll mod = 1000000007;
const int INF = 1001001001;
const ll LINF = 1001001001001001001;
int main() {
ll n, p;
cin >> n >> p;
const ll mx = 1000001;
vector<ll> a(mx, 0);... | #include <bits/stdc++.h>
#include <math.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
const ll mod = 1000000007;
const int INF = 1001001001;
const ll LINF = 1001001001001001001;
int main() {
ll n, p;
cin >> n >> p;
ll x = p;
const ll mx = 1000001;
vector<l... | [
"variable_declaration.add",
"identifier.change",
"io.output.change"
] | 991,051 | 991,052 | u628597699 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG //これつけるとA[N]でもいいらしい
// for文のマクロ
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define big 1000000007
#define all(a) sort((a).begin(), (a).end()) //ソートのマクロ
int main() {
double n, p;
cin >> n >> p;
int64_t ans = pow(p, 1 / n);
while ((int... | #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG //これつけるとA[N]でもいいらしい
// for文のマクロ
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define big 1000000007
#define all(a) sort((a).begin(), (a).end()) //ソートのマクロ
int main() {
double n, p;
cin >> n >> p;
int64_t ans = round(pow(p, 1 / n));
// c... | [
"call.add",
"call.arguments.change",
"control_flow.loop.condition.change"
] | 991,063 | 991,064 | u348231925 | cpp |
p03196 | #include "bits/stdc++.h"
using namespace std;
using LL = long long;
using ULL = unsigned long long;
const double PI = acos(-1);
template <class T> constexpr T INF() { return ::std::numeric_limits<T>::max(); }
template <class T> constexpr T HINF() { return INF<T>() / 2; }
template <typename T_char> T_char TL(T_char cX) ... | #include "bits/stdc++.h"
using namespace std;
using LL = long long;
using ULL = unsigned long long;
const double PI = acos(-1);
template <class T> constexpr T INF() { return ::std::numeric_limits<T>::max(); }
template <class T> constexpr T HINF() { return INF<T>() / 2; }
template <typename T_char> T_char TL(T_char cX) ... | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 991,083 | 991,084 | u093922224 | cpp |
p03196 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repr(i, n) for (int i = (n); i >= 0; i--)
#define repf(i,... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repr(i, n) for (int i = (n); i >= 0; i--)
#define repf(i,... | [
"expression.operator.change"
] | 991,085 | 991,086 | u374929478 | cpp |
p03196 | #include <algorithm>
#include <bitset>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repr(i, n) for (int i = (n); i >= 0; i--)
#define repf(i, m, n) for (int i = (m); i < (n); i++)
usi... | #include <algorithm>
#include <bitset>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repr(i, n) for (int i = (n); i >= 0; i--)
#define repf(i, m, n) for (int i = (m); i < (n); i++)
usi... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 991,087 | 991,088 | u374929478 | cpp |
p03196 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
#define FAL... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
#define FAL... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 991,089 | 991,090 | u184572586 | cpp |
p03196 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
#define FAL... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
#define FAL... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 991,091 | 991,092 | u184572586 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, p;
cin >> n >> p;
vector<long long int> divisor(0);
for (int i = 1; i <= sqrt(p); i++) {
if (p % i == 0) {
divisor.push_back(i);
divisor.push_back(p / i);
}
}
sort(divisor.begin(), divisor.end());
double n... | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, p;
cin >> n >> p;
vector<long long int> divisor(0);
for (int i = 1; i <= sqrt(p); i++) {
if (p % i == 0) {
divisor.push_back(i);
divisor.push_back(p / i);
}
}
sort(divisor.begin(), divisor.end());
long lon... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"call.add",
"call.arguments.change"
] | 991,095 | 991,096 | u045368371 | cpp |
p03196 | #define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (n); i++)
#define FOR(i, a, n) for (int i = (a); i < (n); i++)
#define ALL(v) v.begin(), v.end()
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
vector<bool> isp;
void sieve(int N) {
isp.assign(N + 1, true);
isp[0] = false;
isp[1] =... | #define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (n); i++)
#define FOR(i, a, n) for (int i = (a); i < (n); i++)
#define ALL(v) v.begin(), v.end()
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
vector<bool> isp;
void sieve(int N) {
isp.assign(N + 1, true);
isp[0] = false;
isp[1] =... | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 991,102 | 991,103 | u846634344 | cpp |
p03196 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <string>
#include <tuple>
#include <vector>
template <typename T> bool chmax(T &a, const T &b) {
if (a <= b) {
a = b;
... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <string>
#include <tuple>
#include <vector>
template <typename T> bool chmax(T &a, const T &b) {
if (a <= b) {
a = b;
... | [
"assignment.value.change",
"expression.operation.binary.change"
] | 991,110 | 991,111 | u408910484 | cpp |
p03196 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdint>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#d... | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdint>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#d... | [
"expression.operation.binary.remove"
] | 991,118 | 991,119 | u834415466 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vl = vector<ll>;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define all(i) i.begin(), i.end()
template <class T, class U> bool cmax(T &a, U b) {
if (a < b) {
a = b;
return true;
} ... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vl = vector<ll>;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define all(i) i.begin(), i.end()
template <class T, class U> bool cmax(T &a, U b) {
if (a < b) {
a = b;
return true;
} ... | [
"control_flow.loop.for.initializer.change",
"variable_declaration.type.change",
"identifier.change",
"call.arguments.change"
] | 991,128 | 991,127 | u366644013 | cpp |
p03196 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <limits>
#include <map>
#include <vector>
#define ll long long int
#define rep(i, n) for (int i = 0; i < n; i++)
#define pb push_back
#define mp make_pair
using namespace std;
int main() {
ll n, p;
cin >> n >> p;
map<ll, ll> m;
ll i = 2;
ll... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <limits>
#include <map>
#include <vector>
#define ll long long int
#define rep(i, n) for (int i = 0; i < n; i++)
#define pb push_back
#define mp make_pair
using namespace std;
int main() {
ll n, p;
cin >> n >> p;
map<ll, ll> m;
ll i = 2;
ll... | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change"
] | 991,131 | 991,132 | u468862268 | cpp |
p03196 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long int;
ll keta(ll a) {
ll ans = 1;
while (1) {
if (a / 10 > 0) {
... | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long int;
ll keta(ll a) {
ll ans = 1;
while (1) {
if (a / 10 > 0) {
... | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 991,133 | 991,134 | u939401127 | cpp |
p03196 | #include <bits/stdc++.h>
#define REP(i, n) for (ll i = 0; i < (ll)n; i++)
#define FOR(i, a, b) for (ll i = (a); i < (ll)b; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define INF (1ll << 60)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
using vl = vector<ll>;
using vvl = vector<vl>;
typede... | #include <bits/stdc++.h>
#define REP(i, n) for (ll i = 0; i < (ll)n; i++)
#define FOR(i, a, b) for (ll i = (a); i < (ll)b; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define INF (1ll << 60)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
using vl = vector<ll>;
using vvl = vector<vl>;
typede... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 991,150 | 991,151 | u824337972 | cpp |
p03196 | #include <bits/stdc++.h>
#define REP(i, n) for (ll i = 0; i < (ll)n; i++)
#define FOR(i, a, b) for (ll i = (a); i < (ll)b; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define INF (1ll << 60)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
using vl = vector<ll>;
using vvl = vector<vl>;
typede... | #include <bits/stdc++.h>
#define REP(i, n) for (ll i = 0; i < (ll)n; i++)
#define FOR(i, a, b) for (ll i = (a); i < (ll)b; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define INF (1ll << 60)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
using vl = vector<ll>;
using vvl = vector<vl>;
typede... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 991,152 | 991,151 | u824337972 | cpp |
p03196 | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using datas = pair<ll, ll>;
using ddatas = pair<double, double>;
using tdata = pair<ll, datas>;
using vec = vector<ll>;
using mat = vector<vec>;
using pvec = vector<datas>;
using pmat = vector<pvec>;
#define For(i, a, b) f... | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using datas = pair<ll, ll>;
using ddatas = pair<double, double>;
using tdata = pair<ll, datas>;
using vec = vector<ll>;
using mat = vector<vec>;
using pvec = vector<datas>;
using pmat = vector<pvec>;
#define For(i, a, b) f... | [
"control_flow.branch.if.condition.change"
] | 991,157 | 991,158 | u251847465 | cpp |
p03196 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
const int mod = 1e9 + 7;
const int inf = 1 << 20;
const long long INF = 1LL << 60;
using namespace std;
typedef long long ll;
typedef pair<in... | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
const int mod = 1e9 + 7;
const int inf = 1 << 20;
const long long INF = 1LL << 60;
using namespace std;
typedef long long ll;
typedef pair<in... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 991,171 | 991,172 | u883323885 | cpp |
p03196 | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tu... | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tu... | [
"variable_declaration.type.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 991,173 | 991,174 | u155416173 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
using lint = long long int;
int main() {
lint n, p;
cin >> n >> p;
map<lint, lint> pf;
for (lint i = 2; i * i <= p; i++) {
while (p % i == 0)
pf[i]++, p /= i;
}
if (p != 1)
pf[p] = 1;
lint ans = 1;
for (auto e : pf) {
lint c = e.second /... | #include <bits/stdc++.h>
using namespace std;
using lint = long long int;
int main() {
lint n, p;
cin >> n >> p;
map<lint, lint> pf;
for (lint i = 2; i * i <= p; i++) {
while (p % i == 0)
pf[i]++, p /= i;
}
if (p != 1)
pf[p] = 1;
lint ans = 1;
for (auto e : pf) {
lint c = e.second /... | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 991,175 | 991,176 | u194268736 | cpp |
p03196 | #include <bits/stdc++.h>
#include <iostream>
#include <string>
#include <vector>
#define MOD 1000000007
#define INT long long int
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
using namespace std;
const long long INF = numeric_limits<long long>::max();
vector<int64_t> divisor(int64_t n) {
vector<int64_t> ret;... | #include <bits/stdc++.h>
#include <iostream>
#include <string>
#include <vector>
#define MOD 1000000007
#define INT long long int
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
using namespace std;
const long long INF = numeric_limits<long long>::max();
vector<int64_t> divisor(int64_t n) {
vector<int64_t> ret;... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 991,181 | 991,182 | u698176039 | cpp |
p03196 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using... | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change"
] | 991,185 | 991,186 | u608258653 | cpp |
p03196 | // IOI 2021
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define ff first
#define ss second
typedef long long ll;
typedef pair<int, int> pii;
ll n, p, ans = 1;
map<ll, ll> mp;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> p;
for (ll i = 2; i * i <= ... | // IOI 2021
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define ff first
#define ss second
typedef long long ll;
typedef pair<int, int> pii;
ll n, p, ans = 1;
map<ll, ll> mp;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> p;
for (ll i = 2; i * i <= ... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 991,189 | 991,190 | u535425458 | cpp |
p03196 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
cons... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
cons... | [
"assignment.change"
] | 991,197 | 991,198 | u412550879 | cpp |
p03196 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
cons... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
cons... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 991,199 | 991,198 | u412550879 | cpp |
p03196 | #include <iostream>
using namespace std;
int main() {
long long n, p;
cin >> n >> p;
if (n == 1) {
cout << p << endl;
return 0;
}
long long nw = 0;
long long ans = 1;
bool lock = false;
for (long long i = 2; p >= i * i; i++) {
if (p % i == 0) {
nw++;
if (i * i == p)
nw++;... | #include <iostream>
using namespace std;
int main() {
long long n, p;
cin >> n >> p;
if (n == 1) {
cout << p << endl;
return 0;
}
long long nw = 0;
long long ans = 1;
bool lock = false;
for (long long i = 2; p >= i * i; i++) {
if (p % i == 0) {
nw++;
if (i * i == p)
nw++;... | [
"assignment.variable.change",
"identifier.change",
"assignment.value.change",
"assignment.change"
] | 991,202 | 991,203 | u466161487 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
using Int = long long;
typedef pair<int, int> P;
typedef pair<Int, Int> Pl;
const int mod = 1e9 + 7;
#define END \
{ \
cout <<... | #include <bits/stdc++.h>
using namespace std;
using Int = long long;
typedef pair<int, int> P;
typedef pair<Int, Int> Pl;
const int mod = 1e9 + 7;
#define END \
{ \
cout <<... | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change"
] | 991,206 | 991,207 | u735089337 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
v.push_back(a);
}
for (int i = 1; i <= n; i++) {
if (v[i] % 2) {
cout << "first" << endl;
return 0;
}
}
cout <<... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
v.push_back(a);
}
for (int i = 0; i < n; i++) {
if (v[i] % 2) {
cout << "first" << endl;
return 0;
}
}
cout << ... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 991,220 | 991,221 | u645322855 | cpp |
p03197 | /////////////////////////////////////////////////
///// Give me AC!!!! /////
/////////////////////////////////////////////////
//↑これじゃ気合いが足りない！
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////
///お願いしますACをくださいそうじゃないと僕泣きますお願いしま... | /////////////////////////////////////////////////
///// Give me AC!!!! /////
/////////////////////////////////////////////////
//↑これじゃ気合いが足りない！
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////
///お願いしますACをくださいそうじゃないと僕泣きますお願いしま... | [
"literal.string.change",
"io.output.change"
] | 991,222 | 991,223 | u620626180 | cpp |
p03197 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
// Acknowledgement: Special thanks to kyomukyomupurin, who developed this
// template.
template <class T, class U>
std::os... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
// Acknowledgement: Special thanks to kyomukyomupurin, who developed this
// template.
template <class T, class U>
std::os... | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"literal.string.change",
"io.output.change"
] | 991,226 | 991,227 | u721166818 | cpp |
p03197 | #include <bits/stdc++.h>
#define ll long long int
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
static const ll MAX = 1000000000000000;
static const int NIL = -1;
using namespace std;
const long double EPS = 0.0000000001;
const long double PI = (acos(-1));
const ll MOD = 1e9 + 7;
#pragma GCC target("avx2")
#pra... | #include <bits/stdc++.h>
#define ll long long int
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
static const ll MAX = 1000000000000000;
static const int NIL = -1;
using namespace std;
const long double EPS = 0.0000000001;
const long double PI = (acos(-1));
const ll MOD = 1e9 + 7;
#pragma GCC target("avx2")
#pra... | [
"literal.string.change",
"variable_declaration.value.change",
"assignment.value.change"
] | 991,230 | 991,231 | u236585484 | cpp |
p03197 | #include <bits/stdc++.h>
using ll = long long;
using namespace std;
#define rep(i, n) for (int i = 0, i##_len = (int)(n); i < i##_len; i++)
#define reps(i, n) for (int i = 1, i##_len = (int)(n); i <= i##_len; i++)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rreps(i, n) for (int i = ((int)(n)); i ... | #include <bits/stdc++.h>
using ll = long long;
using namespace std;
#define rep(i, n) for (int i = 0, i##_len = (int)(n); i < i##_len; i++)
#define reps(i, n) for (int i = 1, i##_len = (int)(n); i <= i##_len; i++)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rreps(i, n) for (int i = ((int)(n)); i ... | [
"expression.operator.change"
] | 991,245 | 991,246 | u179778090 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = (0); i < (n); ++i)
#define ALL(obj) (obj).begin(), (obj).end()
#define DEBUG(val) cout << #val << " : " << val << endl
#define MOD 1000000007
int main() {
int n;
ci... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = (0); i < (n); ++i)
#define ALL(obj) (obj).begin(), (obj).end()
#define DEBUG(val) cout << #val << " : " << val << endl
#define MOD 1000000007
int main() {
int n;
ci... | [
"assignment.value.change",
"assignment.change"
] | 991,247 | 991,248 | u947517859 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a) for (int i = 0; i < (a); i++)
typedef long long ll;
#ifdef _DEBUG
inline void dump() { cerr << endl; }
template <typename Head> void dump(Head &&head) {
cerr << head;
dump();
}
template <typename Head, typename... Tail>
void dump(Head &&head, Tail &&.... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a) for (int i = 0; i < (a); i++)
typedef long long ll;
#ifdef _DEBUG
inline void dump() { cerr << endl; }
template <typename Head> void dump(Head &&head) {
cerr << head;
dump();
}
template <typename Head, typename... Tail>
void dump(Head &&head, Tail &&.... | [
"control_flow.branch.else.remove",
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add"
] | 991,249 | 991,250 | u305824645 | cpp |
p03197 | #include <bits/stdc++.h>
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)n; ++i)
#define repr(i, n) for (ll i = n - 1; i >= 0; --i)
#define INF 10e7
#define MOD 1000000000 + 7
#define MAX 51000
#define all(x) (x).begin(), (x).end()
#define MX(x) *max_element(all(x))
#define MN(x) *min_element(all(x))
u... | #include <bits/stdc++.h>
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)n; ++i)
#define repr(i, n) for (ll i = n - 1; i >= 0; --i)
#define INF 10e7
#define MOD 1000000000 + 7
#define MAX 51000
#define all(x) (x).begin(), (x).end()
#define MX(x) *max_element(all(x))
#define MN(x) *min_element(all(x))
u... | [
"expression.operation.binary.remove"
] | 991,251 | 991,252 | u110044127 | cpp |
p03197 | #include <bits/stdc++.h>
#define rep(i, N) for (ll(i) = 0; (i) < (N); (i)++)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int mod = 1000000007;
int main() {
int n;
cin >> n;
rep(i, n) {
int a;
cin >> a;
... | #include <bits/stdc++.h>
#define rep(i, N) for (ll(i) = 0; (i) < (N); (i)++)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int mod = 1000000007;
int main() {
int n;
cin >> n;
rep(i, n) {
int a;
cin >> a;
... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 991,253 | 991,254 | u239409893 | cpp |
p03197 | #include <bits/stdc++.h>
#define rep(i, N) for (ll(i) = 0; (i) < (N); (i)++)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int mod = 1000000007;
int main() {
int n;
cin >> n;
ll s;
bool ans = false;
rep(i, n) {
... | #include <bits/stdc++.h>
#define rep(i, N) for (ll(i) = 0; (i) < (N); (i)++)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int mod = 1000000007;
int main() {
int n;
cin >> n;
ll s;
bool ans = false;
rep(i, n) {
... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 991,255 | 991,256 | u239409893 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long N;
cin >> N;
bool K = false;
vector<long long> v(N);
for (int X = 0; X < N; X++) {
cin >> v[X];
if (v[X] % 2 == 1) {
K = true;
cout << "first" << endl;
break;
}
}
if (K == true) {
cout << "second" << end... | #include <bits/stdc++.h>
using namespace std;
int main() {
long long N;
cin >> N;
bool K = false;
vector<long long> v(N);
for (int X = 0; X < N; X++) {
cin >> v[X];
if (v[X] % 2 == 1) {
K = true;
cout << "first" << endl;
break;
}
}
if (K == false) {
cout << "second" << en... | [
"misc.opposites",
"control_flow.branch.if.condition.change"
] | 991,257 | 991,258 | u740002394 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
bool f = true;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
f &= f % 2 == 0;
}
cout << (f ? "second" : "first") << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
bool f = true;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
f &= x % 2 == 0;
}
cout << (f ? "second" : "first") << endl;
} | [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 991,267 | 991,268 | u691380397 | cpp |
p03197 | #include <iostream>
using namespace std;
int main() {
int n;
bool second = true;
for (int i = 0; i < n; i++) {
int num;
cin >> num;
if (num % 2 != 0)
second = false;
}
if (second)
cout << "second" << endl;
else
cout << "first" << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
bool second = true;
for (int i = 0; i < n; i++) {
int num;
cin >> num;
if (num % 2 != 0)
second = false;
}
if (second)
cout << "second" << endl;
else
cout << "first" << endl;
return 0;
}
| [] | 991,269 | 991,270 | u509420256 | cpp |
p03197 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using P = pair<int, int>;
typedef long long ll;
int main() {
int n;
cin >> n;
rep(i, n) {
int a;
cin >> a;
if (a % 2 != 1) {
cout << "first" << endl;
return 0;
}
}
cout << "second" << end... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using P = pair<int, int>;
typedef long long ll;
int main() {
int n;
cin >> n;
rep(i, n) {
int a;
cin >> a;
if (a % 2 == 1) {
cout << "first" << endl;
return 0;
}
}
cout << "second" << end... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 991,273 | 991,274 | u233586402 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int A[N];
int flag = 1;
for (int i = 0; i < N; i++) {
cin >> A[i];
if (A[i] % 2 == 1) {
flag = 0;
}
}
if (flag == 1) {
cout << "second" << endl;
} else {
cout << "fitst" << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int A[N];
int flag = 1;
for (int i = 0; i < N; i++) {
cin >> A[i];
if (A[i] % 2 == 1) {
flag = 0;
}
}
if (flag == 1) {
cout << "second" << endl;
} else {
cout << "first" << endl;
}
return 0;
}
| [
"literal.string.change",
"io.output.change"
] | 991,282 | 991,283 | u469315559 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using st = string;
using ch = char;
typedef pair<ll, ll> P;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<P> vP;
typedef vector<ch> vc;
typedef vector<vc> vvc;
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#def... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using st = string;
using ch = char;
typedef pair<ll, ll> P;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<P> vP;
typedef vector<ch> vc;
typedef vector<vc> vvc;
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#def... | [
"literal.string.change",
"io.output.change"
] | 991,288 | 991,289 | u328811800 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
#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()
#define VI vector<int>
#define MOD 1000000007
using ll = long long int;
using P = pair<int, int>;
template <class T> bool chmax(T &a, const T &b) {
... | #include <bits/stdc++.h>
using namespace std;
#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()
#define VI vector<int>
#define MOD 1000000007
using ll = long long int;
using P = pair<int, int>;
template <class T> bool chmax(T &a, const T &b) {
... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 991,299 | 991,300 | u868089307 | cpp |
p03197 | #include <bits/stdc++.h>
#include <numeric>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rep1(i, n) for (int i = 1; i <= n; ++i)
template <typename T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
... | #include <bits/stdc++.h>
#include <numeric>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rep1(i, n) for (int i = 1; i <= n; ++i)
template <typename T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
... | [] | 991,305 | 991,306 | u223160139 | cpp |
p03197 | #include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define int long long
#define REP(i, m, n) for (int i = (m); i < (n); i++)
#define rep(i, n) REP(i, 0, n)
#define pb push_back
#define all(a) a.begin(), a.end()
#define rall(c) (c).rbegin(), (c).rend()
#define mp make_pair
#... | #include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define int long long
#define REP(i, m, n) for (int i = (m); i < (n); i++)
#define rep(i, n) REP(i, 0, n)
#define pb push_back
#define all(a) a.begin(), a.end()
#define rall(c) (c).rbegin(), (c).rend()
#define mp make_pair
#... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 991,309 | 991,310 | u339937125 | cpp |
p03197 |
/*
@・ω・@
*/
/*****/
#include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip> //cout << fixed << setprecision(桁数);
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <string>
#include <vector>
//#define int long long
us... |
/*
@・ω・@
*/
/*****/
#include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip> //cout << fixed << setprecision(桁数);
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <string>
#include <vector>
//#define int long long
us... | [
"literal.string.change",
"io.output.change"
] | 991,314 | 991,315 | u588369531 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.