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 9
values |
|---|---|---|---|---|---|---|---|
p03197 | #include <iostream>
using namespace std;
int n;
int a;
int gg;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
if (a % 2 != 0)
gg++;
}
if (gg % 2 == 0) {
cout << "second" << endl;
} else {
cout << "first" << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int n;
int a;
int gg;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
if (a % 2 != 0)
gg++;
}
if (gg != 0) {
cout << "first" << endl;
} else {
cout << "second" << endl;
}
return 0;
} | [
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove",
"literal.string.change",
"io.output.change"
] | 991,320 | 991,321 | u816631826 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
typedef long long ll;
typedef pair<ll, ll> P;
const ll INF = 1LL << 60;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
ll modpow(ll a, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<ll> a(N);
rep(i, N) cin >> a[i];
int cnt = 0;
rep(i, N) {
if (a[i] % 2 == 0) {
cnt++;
}
}
if (cnt % 2 == 0) {
cout << "second" << endl;
} else {
cout << "first" << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
typedef long long ll;
typedef pair<ll, ll> P;
const ll INF = 1LL << 60;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
ll modpow(ll a, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<ll> a(N);
rep(i, N) cin >> a[i];
int cnt = 0;
rep(i, N) {
if (a[i] % 2 == 0) {
cnt++;
}
}
if (cnt == N) {
cout << "second" << endl;
} else {
cout << "first" << endl;
}
return 0;
}
| [
"expression.operation.binary.remove",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.branch.if.condition.change"
] | 991,322 | 991,323 | u187878098 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
typedef long long ll;
typedef pair<ll, ll> P;
const ll INF = 1LL << 60;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
ll modpow(ll a, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<ll> a(N);
rep(i, N) cin >> a[i];
int cnt = 0;
rep(i, N) {
if (a[i] % 2 == 0) {
cnt++;
}
}
if (cnt % 2 == 0) {
cout << "Second" << endl;
} else {
cout << "First" << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
typedef long long ll;
typedef pair<ll, ll> P;
const ll INF = 1LL << 60;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
ll modpow(ll a, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<ll> a(N);
rep(i, N) cin >> a[i];
int cnt = 0;
rep(i, N) {
if (a[i] % 2 == 0) {
cnt++;
}
}
if (cnt == N) {
cout << "second" << endl;
} else {
cout << "first" << endl;
}
return 0;
}
| [
"expression.operation.binary.remove",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.branch.if.condition.change",
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 991,324 | 991,323 | u187878098 | cpp |
p03197 | #define LOCAL
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep2(i, s, n) for (int i = s; i < (n); ++i)
#define ALL(v) (v).begin(), (v).end()
using namespace std;
typedef long long ll;
static const int INTINF = (INT_MAX >> 1); // 10^9 + 10^7
static const ll LLINF = (LLONG_MAX >> 1);
static const int MAX = 1e5 + 1;
static const ll MOD = 1e9 + 7;
string to_string(string s) { return '"' + s + '"'; }
string to_string(bool b) { return b ? "true" : "false"; }
template <size_t N> string to_string(bitset<N> bs) {
string res;
for (size_t i = 0; i < N; ++i)
res += '0' + bs[i];
return res;
}
string to_string(vector<bool> v) {
string res = "{";
for (bool e : v)
res += to_string(e) + ", ";
return res += "}";
}
template <class T, class U> string to_string(pair<T, U> p);
template <class C> string to_string(C c) {
string res = "{";
for (auto e : c)
res += to_string(e) + ", ";
return res += "}";
}
template <class T, class U> string to_string(pair<T, U> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
void debug() { cerr << '\n'; }
template <class Head, class... Tail> void debug(Head head, Tail... tail) {
cerr << '\t' << to_string(head), debug(tail...);
}
#ifdef LOCAL
#define DEBUG(...) cerr << "[" << #__VA_ARGS__ << "]:", debug(__VA_ARGS__)
#else
#define DEBUG(...)
#endif
int main(int argc, const char *argv[]) {
std::cout << std::fixed << std::setprecision(15);
int N;
cin >> N;
vector<ll> A(N);
rep(i, N) cin >> A[i];
bool ans = false;
int cnt = 0;
rep(i, N) {
if (A[i] % 2 == 1)
cnt++;
}
if (cnt % 2 == 1) {
cout << "first" << endl;
} else {
cout << "second" << endl;
}
}
| #define LOCAL
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep2(i, s, n) for (int i = s; i < (n); ++i)
#define ALL(v) (v).begin(), (v).end()
using namespace std;
typedef long long ll;
static const int INTINF = (INT_MAX >> 1); // 10^9 + 10^7
static const ll LLINF = (LLONG_MAX >> 1);
static const int MAX = 1e5 + 1;
static const ll MOD = 1e9 + 7;
string to_string(string s) { return '"' + s + '"'; }
string to_string(bool b) { return b ? "true" : "false"; }
template <size_t N> string to_string(bitset<N> bs) {
string res;
for (size_t i = 0; i < N; ++i)
res += '0' + bs[i];
return res;
}
string to_string(vector<bool> v) {
string res = "{";
for (bool e : v)
res += to_string(e) + ", ";
return res += "}";
}
template <class T, class U> string to_string(pair<T, U> p);
template <class C> string to_string(C c) {
string res = "{";
for (auto e : c)
res += to_string(e) + ", ";
return res += "}";
}
template <class T, class U> string to_string(pair<T, U> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
void debug() { cerr << '\n'; }
template <class Head, class... Tail> void debug(Head head, Tail... tail) {
cerr << '\t' << to_string(head), debug(tail...);
}
#ifdef LOCAL
#define DEBUG(...) cerr << "[" << #__VA_ARGS__ << "]:", debug(__VA_ARGS__)
#else
#define DEBUG(...)
#endif
int main(int argc, const char *argv[]) {
std::cout << std::fixed << std::setprecision(15);
int N;
cin >> N;
vector<ll> A(N);
rep(i, N) cin >> A[i];
bool ans = false;
int cnt = 0;
rep(i, N) {
if (A[i] % 2 == 1)
cnt++;
}
if (cnt > 0) {
cout << "first" << endl;
} else {
cout << "second" << endl;
}
}
| [
"expression.operation.binary.remove"
] | 991,326 | 991,327 | u895382169 | cpp |
p03197 | #include <algorithm>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
using vl = vector<ll>;
using vll = vector<vl>;
using vpll = vector<pll>;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define pb push_back
#define eb emplace_back
struct Edge {
int to;
int weight;
Edge(int t, int w) : to(t), weight(w) {}
};
using Graph = vector<vector<Edge>>;
using graph = vector<vector<int>>;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> T gcd(T a, T b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
template <class T> T lcm(T a, T b) { return (a * b) / gcd(a, b); }
template <class T> void dcomb(T n, T m, string s) {
if (n == 0)
cout << s << endl;
else {
for (T i = 0; i < m; ++i) {
dcomb(n - 1, m, s + to_string(i));
}
}
}
int INF = 1e9 + 7;
vector<int> dx = {-1, 0, 1, 0};
vector<int> dy = {0, -1, 0, 1};
int main() {
int n;
cin >> n;
int ans = 0;
vector<int> a(n);
rep(i, n) {
a[i];
if (a[i] % 2 == 0) {
continue;
} else {
ans = 1;
}
}
if (ans)
cout << "first" << endl;
else
cout << "second" << endl;
} | #include <algorithm>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
using vl = vector<ll>;
using vll = vector<vl>;
using vpll = vector<pll>;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define pb push_back
#define eb emplace_back
struct Edge {
int to;
int weight;
Edge(int t, int w) : to(t), weight(w) {}
};
using Graph = vector<vector<Edge>>;
using graph = vector<vector<int>>;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> T gcd(T a, T b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
template <class T> T lcm(T a, T b) { return (a * b) / gcd(a, b); }
template <class T> void dcomb(T n, T m, string s) {
if (n == 0)
cout << s << endl;
else {
for (T i = 0; i < m; ++i) {
dcomb(n - 1, m, s + to_string(i));
}
}
}
int INF = 1e9 + 7;
vector<int> dx = {-1, 0, 1, 0};
vector<int> dy = {0, -1, 0, 1};
int main() {
int n;
cin >> n;
int ans = 0;
vector<int> a(n);
rep(i, n) {
cin >> a[i];
if (a[i] % 2 == 0) {
continue;
} else {
ans = 1;
}
}
if (ans)
cout << "first" << endl;
else
cout << "second" << endl;
} | [
"expression.operation.binary.add"
] | 991,330 | 991,331 | u117348081 | cpp |
p03197 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
int main() {
int N, a;
cin >> N;
string ans = "Second\n";
rep(i, N) {
cin >> a;
if (a % 2)
ans = "First\n";
}
cout << ans;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
int main() {
int N, a;
cin >> N;
string ans = "second\n";
rep(i, N) {
cin >> a;
if (a % 2)
ans = "first\n";
}
cout << ans;
} | [
"literal.string.change",
"literal.string.case.change",
"variable_declaration.value.change",
"assignment.value.change"
] | 991,332 | 991,333 | u555962250 | cpp |
p03197 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
int main() {
int N, a;
cin >> N;
string ans = "second\n";
rep(i, N) {
cin >> a;
if (a % 2)
ans = "First\n";
}
cout << ans;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
int main() {
int N, a;
cin >> N;
string ans = "second\n";
rep(i, N) {
cin >> a;
if (a % 2)
ans = "first\n";
}
cout << ans;
} | [
"literal.string.change",
"literal.string.case.change",
"assignment.value.change"
] | 991,334 | 991,333 | u555962250 | cpp |
p03197 | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
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;
}
return 0;
}
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(vec) vec.begin(), vec.end()
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
const ll mod = 1e9 + 7;
const int inf = 1 << 30;
int main() {
int n;
cin >> n;
vector<int> a(n);
rep(i, n) cin >> a[i];
bool f = 1;
rep(i, n) {
if (a[i] % 2 == 1)
f = 0;
}
if (f)
cout << "Second" << endl;
else
cout << "First" << endl;
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
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;
}
return 0;
}
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(vec) vec.begin(), vec.end()
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
const ll mod = 1e9 + 7;
const int inf = 1 << 30;
int main() {
int n;
cin >> n;
vector<int> a(n);
rep(i, n) cin >> a[i];
bool f = 1;
rep(i, n) {
if (a[i] % 2 == 1)
f = 0;
}
if (f)
cout << "second" << endl;
else
cout << "first" << endl;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 991,339 | 991,340 | u136342563 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, x, n) for (int i = x; i < (n); i++)
#define all(n) begin(n), end(n)
struct cww {
cww() {
ios::sync_with_stdio(false);
cin.tie(0);
}
} star;
const long long INF = numeric_limits<long long>::max();
typedef long long ll;
typedef vector<int> vint;
typedef vector<char> vchar;
typedef vector<vector<int>> vvint;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef unsigned long long ull;
#define vcin(a) \
for (int i = 0; i < (a).size(); i++) \
cin >> (a)[i];
int main() {
int N;
cin >> N;
vint a(N);
int cnt = 0;
rep(i, N) {
cin >> a[i];
if (a[i] % 2 == 1) {
cnt++;
}
}
if (cnt % 2 == 1)
cout << "first";
else
cout << "second";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, x, n) for (int i = x; i < (n); i++)
#define all(n) begin(n), end(n)
struct cww {
cww() {
ios::sync_with_stdio(false);
cin.tie(0);
}
} star;
const long long INF = numeric_limits<long long>::max();
typedef long long ll;
typedef vector<int> vint;
typedef vector<char> vchar;
typedef vector<vector<int>> vvint;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef unsigned long long ull;
#define vcin(a) \
for (int i = 0; i < (a).size(); i++) \
cin >> (a)[i];
int main() {
int N;
cin >> N;
vint a(N);
int cnt = 0;
rep(i, N) {
cin >> a[i];
if (a[i] % 2 == 0) {
cnt++;
}
}
if (cnt != N)
cout << "first";
else
cout << "second";
return 0;
} | [
"literal.number.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 991,345 | 991,346 | u987913144 | cpp |
p03197 | #include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
using namespace std;
int main() {
int N;
cin >> N;
vector<int> a(N);
int cnt = 0;
for (int i = 0; i < N; i++) {
cin >> a[i];
if (a[i] % 2 == 0) {
cnt++;
}
}
if (cnt % 2 == N) {
cout << "second" << endl;
} else {
cout << "first" << endl;
}
}
| #include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
using namespace std;
int main() {
int N;
cin >> N;
vector<int> a(N);
int cnt = 0;
for (int i = 0; i < N; i++) {
cin >> a[i];
if (a[i] % 2 == 0) {
cnt++;
}
}
if (cnt == N) {
cout << "second" << endl;
} else {
cout << "first" << endl;
}
}
| [
"expression.operation.binary.remove"
] | 991,349 | 991,350 | u119098168 | cpp |
p03197 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long double ld;
typedef long long int ll;
typedef unsigned long long int ull;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef vector<string> vs;
typedef vector<ll> vll;
typedef vector<pair<int, int>> vpii;
typedef vector<vector<int>> vvi;
typedef vector<vector<char>> vvc;
typedef vector<vector<string>> vvs;
typedef vector<vector<ll>> vvll;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define fin(ans) cout << (ans) << endl
#define STI(s) atoi(s.c_str())
#define mp(p, q) make_pair(p, q)
#define pb(n) push_back(n)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define Sort(a) sort(a.begin(), a.end())
#define Rort(a) sort(a.rbegin(), a.rend())
#define MATHPI acos(-1)
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;
}
return 0;
}
struct io {
io() {
ios::sync_with_stdio(false);
cin.tie(0);
};
};
const int MOD = 1000000007;
const int INF = INT_MAX;
const ll LLINF = 1LL << 62;
int main(void) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int c;
cin >> c;
if (c % 2 == 1) {
fin("secind");
return 0;
}
}
fin("first");
}
| #include <algorithm>
#include <bitset>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long double ld;
typedef long long int ll;
typedef unsigned long long int ull;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef vector<string> vs;
typedef vector<ll> vll;
typedef vector<pair<int, int>> vpii;
typedef vector<vector<int>> vvi;
typedef vector<vector<char>> vvc;
typedef vector<vector<string>> vvs;
typedef vector<vector<ll>> vvll;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define fin(ans) cout << (ans) << endl
#define STI(s) atoi(s.c_str())
#define mp(p, q) make_pair(p, q)
#define pb(n) push_back(n)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define Sort(a) sort(a.begin(), a.end())
#define Rort(a) sort(a.rbegin(), a.rend())
#define MATHPI acos(-1)
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;
}
return 0;
}
struct io {
io() {
ios::sync_with_stdio(false);
cin.tie(0);
};
};
const int MOD = 1000000007;
const int INF = INT_MAX;
const ll LLINF = 1LL << 62;
int main(void) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int c;
cin >> c;
if (c % 2 == 1) {
fin("first");
return 0;
}
}
fin("second");
}
| [
"literal.string.change",
"call.arguments.change"
] | 991,351 | 991,352 | u903311413 | cpp |
p03197 | // include
//------------------------------------------
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <locale>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
// typedef
//------------------------------------------
typedef long long LL;
typedef vector<int> VI;
typedef vector<bool> VB;
typedef vector<char> VC;
typedef vector<double> VD;
typedef vector<string> VS;
typedef vector<LL> VLL;
typedef vector<VI> VVI;
typedef vector<VB> VVB;
typedef vector<VS> VVS;
typedef vector<VLL> VVLL;
typedef vector<VVI> VVVI;
typedef vector<VVLL> VVVLL;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef pair<int, string> PIS;
typedef pair<string, int> PSI;
typedef pair<string, string> PSS;
typedef vector<PII> VPII;
typedef vector<PLL> VPLL;
typedef vector<VPII> VVPII;
typedef vector<VPLL> VVPLL;
typedef vector<VS> VVS;
typedef map<int, int> MII;
typedef map<LL, LL> MLL;
typedef map<string, int> MSI;
typedef map<int, string> MIS;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define SZ(a) int((a).size())
#define EACH(i, arr) \
for (typeof((arr).begin()) i = (arr).begin(); i != (arr).end(); ++i)
#define EXIST(str, e) ((str).find(e) != (str).end())
#define COUNT(arr, v) count((arr).begin(), (arr).end(), v)
#define SEARCH(v, w) search((v).begin(), (v).end(), (w).begin(), (w).end())
#define SORT(c) sort((c).begin(), (c).end())
#define RSORT(c) sort((c).rbegin(), (c).rend())
#define REVERSE(c) reverse((c).begin(), (c).end())
#define ROTATE_LEFT(arr, c) \
rotate((arr).begin(), (arr).begin() + (c), (arr).end())
#define ROTATE_RIGHT(arr, c) \
rotate((arr).rbegin(), (arr).rbegin() + (c), (arr).rend())
#define SUMI(arr) accumulate((arr).begin(), (arr).end(), 0)
#define SUMD(arr) accumulate((arr).begin(), (arr).end(), 0.)
#define SUMLL(arr) accumulate((arr).begin(), (arr).end(), 0LL)
#define MULD(arr) \
accumulate((arr).begin(), (arr).end(), 1., multiplies<double>())
#define UB(arr, n) upper_bound((arr).begin(), (arr).end(), n)
#define LB(arr, n) lower_bound((arr).begin(), (arr).end(), n)
#define PB push_back
#define MP make_pair
#define ft first
#define sd second
// input output
//------------------------------------------
#define GL(s) getline(cin, (s))
#define INIT() \
std::ios::sync_with_stdio(false); \
std::cin.tie(0)
#define OUT(d) std::cout << (d)
#define OUT_L(d) std::cout << (d) << endl
#define FOUT(n, data) std::cout << std::fixed << std::setprecision(n) << (data)
#define FOUT_L(n, data) \
std::cout << std::fixed << std::setprecision(n) << (data) << "\n"
#define EL() printf("\n")
#define SHOW_VECTOR(v) \
{ \
std::cerr << #v << "\t:"; \
for (const auto &xxx : v) { \
std::cerr << xxx << " "; \
} \
std::cerr << "\n"; \
}
#define SHOW_MAP(v) \
{ \
std::cerr << #v << endl; \
for (const auto &xxx : v) { \
std::cerr << xxx.first << " " << xxx.second << "\n"; \
} \
}
#define Yes() printf("Yes\n")
#define No() printf("No\n")
#define YES() printf("YES\n")
#define NO() printf("NO\n")
#define Yay() printf("Yay!\n")
#define Nnn() printf(":(\n")
#define CE(x, y) ((x + y - 1) / (y))
template <typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &p) {
in >> p.first >> p.second;
return in;
}
template <typename T> istream &operator>>(istream &in, vector<T> &v) {
for (auto &x : v)
in >> x;
return in;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, const std::pair<T1, T2> &p) {
out << "[" << p.first << ", " << p.second << "]"
<< "\n";
return out;
}
template <class T1, class T2> inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T1, class T2> inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) for (int i = n - 1; i >= 0; i--)
#define FORLL(i, a, b) for (LL i = LL(a); i < LL(b); ++i)
#define RFORLL(i, a, b) for (LL i = LL(b) - 1; i >= LL(a); --i)
#define REPLL(i, n) for (LL i = 0; i < LL(n); ++i)
#define RREPLL(i, n) for (LL i = LL(n) - 1; i >= 0; --i)
#define FOREACH(x, arr) for (auto &(x) : (arr))
//------------------------------------------
//------------------------------------------
int main() {
LL N;
cin >> N;
VLL a(N);
cin >> a;
REP(i, N) a[i] %= 2;
int cnt = count(a.begin(), a.end(), a[0]);
if (cnt == N)
cout << "second" << endl;
else
cout << "first" << endl;
return 0;
}
| // include
//------------------------------------------
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <locale>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
// typedef
//------------------------------------------
typedef long long LL;
typedef vector<int> VI;
typedef vector<bool> VB;
typedef vector<char> VC;
typedef vector<double> VD;
typedef vector<string> VS;
typedef vector<LL> VLL;
typedef vector<VI> VVI;
typedef vector<VB> VVB;
typedef vector<VS> VVS;
typedef vector<VLL> VVLL;
typedef vector<VVI> VVVI;
typedef vector<VVLL> VVVLL;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef pair<int, string> PIS;
typedef pair<string, int> PSI;
typedef pair<string, string> PSS;
typedef vector<PII> VPII;
typedef vector<PLL> VPLL;
typedef vector<VPII> VVPII;
typedef vector<VPLL> VVPLL;
typedef vector<VS> VVS;
typedef map<int, int> MII;
typedef map<LL, LL> MLL;
typedef map<string, int> MSI;
typedef map<int, string> MIS;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define SZ(a) int((a).size())
#define EACH(i, arr) \
for (typeof((arr).begin()) i = (arr).begin(); i != (arr).end(); ++i)
#define EXIST(str, e) ((str).find(e) != (str).end())
#define COUNT(arr, v) count((arr).begin(), (arr).end(), v)
#define SEARCH(v, w) search((v).begin(), (v).end(), (w).begin(), (w).end())
#define SORT(c) sort((c).begin(), (c).end())
#define RSORT(c) sort((c).rbegin(), (c).rend())
#define REVERSE(c) reverse((c).begin(), (c).end())
#define ROTATE_LEFT(arr, c) \
rotate((arr).begin(), (arr).begin() + (c), (arr).end())
#define ROTATE_RIGHT(arr, c) \
rotate((arr).rbegin(), (arr).rbegin() + (c), (arr).rend())
#define SUMI(arr) accumulate((arr).begin(), (arr).end(), 0)
#define SUMD(arr) accumulate((arr).begin(), (arr).end(), 0.)
#define SUMLL(arr) accumulate((arr).begin(), (arr).end(), 0LL)
#define MULD(arr) \
accumulate((arr).begin(), (arr).end(), 1., multiplies<double>())
#define UB(arr, n) upper_bound((arr).begin(), (arr).end(), n)
#define LB(arr, n) lower_bound((arr).begin(), (arr).end(), n)
#define PB push_back
#define MP make_pair
#define ft first
#define sd second
// input output
//------------------------------------------
#define GL(s) getline(cin, (s))
#define INIT() \
std::ios::sync_with_stdio(false); \
std::cin.tie(0)
#define OUT(d) std::cout << (d)
#define OUT_L(d) std::cout << (d) << endl
#define FOUT(n, data) std::cout << std::fixed << std::setprecision(n) << (data)
#define FOUT_L(n, data) \
std::cout << std::fixed << std::setprecision(n) << (data) << "\n"
#define EL() printf("\n")
#define SHOW_VECTOR(v) \
{ \
std::cerr << #v << "\t:"; \
for (const auto &xxx : v) { \
std::cerr << xxx << " "; \
} \
std::cerr << "\n"; \
}
#define SHOW_MAP(v) \
{ \
std::cerr << #v << endl; \
for (const auto &xxx : v) { \
std::cerr << xxx.first << " " << xxx.second << "\n"; \
} \
}
#define Yes() printf("Yes\n")
#define No() printf("No\n")
#define YES() printf("YES\n")
#define NO() printf("NO\n")
#define Yay() printf("Yay!\n")
#define Nnn() printf(":(\n")
#define CE(x, y) ((x + y - 1) / (y))
template <typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &p) {
in >> p.first >> p.second;
return in;
}
template <typename T> istream &operator>>(istream &in, vector<T> &v) {
for (auto &x : v)
in >> x;
return in;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, const std::pair<T1, T2> &p) {
out << "[" << p.first << ", " << p.second << "]"
<< "\n";
return out;
}
template <class T1, class T2> inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T1, class T2> inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) for (int i = n - 1; i >= 0; i--)
#define FORLL(i, a, b) for (LL i = LL(a); i < LL(b); ++i)
#define RFORLL(i, a, b) for (LL i = LL(b) - 1; i >= LL(a); --i)
#define REPLL(i, n) for (LL i = 0; i < LL(n); ++i)
#define RREPLL(i, n) for (LL i = LL(n) - 1; i >= 0; --i)
#define FOREACH(x, arr) for (auto &(x) : (arr))
//------------------------------------------
//------------------------------------------
int main() {
LL N;
cin >> N;
VLL a(N);
cin >> a;
REP(i, N) a[i] %= 2;
int cnt = count(a.begin(), a.end(), 0);
if (cnt == N)
cout << "second" << endl;
else
cout << "first" << endl;
return 0;
}
| [
"call.arguments.change"
] | 991,353 | 991,354 | u259053514 | cpp |
p03197 | #include <algorithm>
#include <bits/stdc++.h>
#include <vector>
using namespace std;
int main() {
int a;
cin >> a;
vector<int> apple(a);
for (int i = 0; i < a; i++) {
int ap;
cin >> ap;
apple.at(i) = ap % 2;
}
if (count(apple.begin(), apple.end(), 0) == a)
cout << "Second" << endl;
else
cout << "First" << endl;
return 0;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <vector>
using namespace std;
int main() {
int a;
cin >> a;
vector<int> apple(a);
for (int i = 0; i < a; i++) {
int ap;
cin >> ap;
apple.at(i) = ap % 2;
}
if (count(apple.begin(), apple.end(), 0) == a)
cout << "second" << endl;
else
cout << "first" << endl;
return 0;
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 991,357 | 991,358 | u623687794 | cpp |
p03197 | #include <bits/stdc++.h>
#define watch(x) cout << (#x) << " is " << (x) << endl
typedef long long ll;
using namespace std;
int static fast = []() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
return 0;
}();
// freopen("input.txt", "r", stdin);
int main() {
int n, val;
vector<int> parity = {0, 0};
cin >> n;
for (int i = 0; i < n; i++) {
cin >> val;
parity[val % 2] += 1;
}
if (parity[1] == 1) {
cout << "first" << endl;
} else {
cout << "second" << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define watch(x) cout << (#x) << " is " << (x) << endl
typedef long long ll;
using namespace std;
int static fast = []() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
return 0;
}();
// freopen("input.txt", "r", stdin);
int main() {
int n, val;
vector<int> parity = {0, 0};
cin >> n;
for (int i = 0; i < n; i++) {
cin >> val;
parity[val % 2] += 1;
}
if (parity[1] >= 1) {
cout << "first" << endl;
} else {
cout << "second" << endl;
}
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 991,360 | 991,361 | u067694854 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
int main() {
int N;
cin >> N;
// bool f = false; // 奇数のものがあり，先手必勝か
int a;
rep(i, N) {
cin >> a;
if (a % 2 == 1) {
cout << "first" << endl;
return 0;
}
cout << "second" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
int main() {
int N;
cin >> N;
// bool f = false; // 奇数のものがあり，先手必勝か
int a;
rep(i, N) {
cin >> a;
if (a % 2 == 1) {
cout << "first" << endl;
return 0;
}
}
cout << "second" << endl;
} | [] | 991,366 | 991,367 | u042802884 | cpp |
p03197 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
// sort(a.begin(),a.end());
int ans = 0;
for (int i = 0; i < n; i++) {
if (a[i] % 2 != 1)
ans++;
}
if (ans > 0)
cout << "first" << endl;
if (ans == 0)
cout << "second" << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
// sort(a.begin(),a.end());
int ans = 0;
for (int i = 0; i < n; i++) {
if (a[i] % 2 == 1)
ans++;
}
if (ans > 0)
cout << "first" << endl;
if (ans == 0)
cout << "second" << endl;
return 0;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 991,374 | 991,375 | u313043608 | cpp |
p03197 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <iostream>
#include <limits>
#include <queue>
#include <set>
#include <tuple>
#include <vector>
using namespace std;
#define INF 11000000000
#define MAX 5100
#define MOD 1000000007
typedef long long ll;
typedef pair<int, int> P;
typedef pair<pair<int, int>, int> p;
typedef pair<pair<int, int>, int> p;
#define bit(n, k) ((n >> k) & 1) /*nのk bit目*/
#define rad_to_deg(rad) (((rad) / 2 / M_PI) * 360)
const double PI = acos(-1);
int main() {
int N;
for (int i = 0; i < N; i++) {
ll a;
cin >> a;
if (a % 2 != 0) {
cout << "first" << endl;
return 0;
}
}
cout << "second" << endl;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <iostream>
#include <limits>
#include <queue>
#include <set>
#include <tuple>
#include <vector>
using namespace std;
#define INF 11000000000
#define MAX 5100
#define MOD 1000000007
typedef long long ll;
typedef pair<int, int> P;
typedef pair<pair<int, int>, int> p;
typedef pair<pair<int, int>, int> p;
#define bit(n, k) ((n >> k) & 1) /*nのk bit目*/
#define rad_to_deg(rad) (((rad) / 2 / M_PI) * 360)
const double PI = acos(-1);
int main() {
int N;
cin >> N;
for (int i = 0; i < N; i++) {
ll a;
cin >> a;
if (a % 2 != 0) {
cout << "first" << endl;
return 0;
}
}
cout << "second" << endl;
}
| [] | 991,378 | 991,379 | u591914971 | cpp |
p03197 | #include <cstdio>
int N;
int a;
int main() {
scanf("%d", &N);
int cnt = 0;
bool ans = true;
for (int i; i < N; i++) {
scanf("%d", &a);
if (a % 2 == 1) {
ans = false;
break;
}
}
if (ans)
printf("first");
else
printf("second");
}
| #include <cstdio>
int N;
int a;
int main() {
scanf("%d", &N);
int cnt = 0;
bool ans = false;
for (int i; i < N; i++) {
scanf("%d", &a);
if (a % 2 == 1) {
ans = true;
break;
}
}
if (ans)
printf("first");
else
printf("second");
}
| [
"misc.opposites",
"variable_declaration.value.change",
"assignment.value.change"
] | 991,382 | 991,383 | u118642796 | cpp |
p03197 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <iostream>
#include <map>
#include <set>
#include <stdlib.h>
#include <string>
#include <vector>
#define ll long long
#define repp(i, a, b) for (int i = (int)a; i < (int)b; ++i)
using namespace std;
int main() {
int N;
cin >> N;
vector<long long> A(N);
repp(i, 0, N) cin >> A[i];
bool allEven = true;
repp(i, 0, N) allEven &= !A[i] % 2;
if (allEven)
cout << "second" << endl;
else
cout << "first" << endl;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <iostream>
#include <map>
#include <set>
#include <stdlib.h>
#include <string>
#include <vector>
#define ll long long
#define repp(i, a, b) for (int i = (int)a; i < (int)b; ++i)
using namespace std;
int main() {
int N;
cin >> N;
vector<long long> A(N);
repp(i, 0, N) cin >> A[i];
bool allEven = true;
repp(i, 0, N) allEven &= A[i] % 2 == 0;
if (allEven)
cout << "second" << endl;
else
cout << "first" << endl;
}
| [
"expression.operation.unary.logical.remove",
"assignment.change"
] | 991,384 | 991,385 | u600896094 | cpp |
p03197 | #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
#define FOR(i, a, b) for (long long int i = (a); i <= (b); i++)
#define RFOR(i, a, b) for (long long int i = (a); i >= (b); i--)
#define MOD 1000000007
#define LLONG_MAXs 9223372036854775800
#define ALL(a) (a).begin(), (a).end()
#include <cmath>
#include <iostream>
using namespace std;
bool isPrimeNum(ll x) { // 素数である場合 true を返す
if (x <= 1) { // 1以下である場合は素数でないことがすぐにわかる
return false;
}
// sqrt( double型 ) は引数の平方根を double型で返すので、int型でキャスト
int n = (int)sqrt((double)x);
for (int i = 2; i <= n; i++) {
if (x % i == 0) { // 割り切る整数がある場合、即判定終了
return false;
}
}
return true; // 割り切る整数がない場合、素数である
}
ll myPow(ll x, ll n, ll m) {
if (n == 0)
return 1;
if (n % 2 == 0)
return myPow(x * x % m, n / 2, m);
else
return x * myPow(x, n - 1, m) % m;
}
constexpr ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
constexpr ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
constexpr ll abs(ll a, ll b) {
if (a >= b)
return a - b;
if (a < b)
return b - a;
}
constexpr double dabs(double a, double b) {
if (a >= b)
return a - b;
if (a < b)
return b - a;
}
constexpr ll min(ll a, ll b) {
if (a >= b)
return b;
if (a < b)
return a;
}
constexpr ll max(ll a, ll b) {
if (a >= b)
return a;
if (a < b)
return b;
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
class UnionFind {
public:
//親の番号を格納する。親だった場合は-(その集合のサイズ)
vector<int> Parent;
//作るときはParentの値を全て-1にする
//こうすると全てバラバラになる
UnionFind(int N) { Parent = vector<int>(N, -1); }
// Aがどのグループに属しているか調べる
int root(int A) {
if (Parent[A] < 0)
return A;
return Parent[A] = root(Parent[A]);
}
//自分のいるグループの頂点数を調べる
int size(int A) {
return -Parent[root(A)]; //親をとってきたい]
}
// AとBをくっ付ける
bool connect(int A, int B) {
// AとBを直接つなぐのではなく、root(A)にroot(B)をくっつける
A = root(A);
B = root(B);
if (A == B) {
//すでにくっついてるからくっ付けない
return false;
}
//大きい方(A)に小さいほう(B)をくっ付けたい
//大小が逆だったらひっくり返しちゃう。
if (size(A) < size(B))
swap(A, B);
// Aのサイズを更新する
Parent[A] += Parent[B];
// Bの親をAに変更する
Parent[B] = A;
return true;
}
};
long long fac[510000], finv[510000], inv[510000];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < 510000; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
string replaceAll(string &replacedStr, string from, string to) {
unsigned int pos = replacedStr.find(from);
int toLen = to.length();
if (from.empty()) {
return replacedStr;
}
while ((pos = replacedStr.find(from, pos)) != std::string::npos) {
replacedStr.replace(pos, from.length(), to);
pos += toLen;
}
return replacedStr;
}
void yn(bool flag) {
if (flag) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return;
}
void YN(bool flag) {
if (flag) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return;
}
std::vector<int> enum_div(int n) // nの約数を列挙
{
std::vector<int> ret;
for (int i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i != 1 && i * i != n) {
ret.push_back(n / i);
}
}
}
ret.push_back(n);
return ret;
}
void Ssort(int no, char *month[]) {
int i, j;
char *temp;
for (i = 0; i < no; i++) {
for (j = i + 1; j < no; j++) {
if (strcmp((month[i]), (month[j])) > 0) {
temp = *(month + i);
*(month + i) = *(month + j);
*(month + j) = temp;
}
}
}
}
using namespace std;
using Graph = vector<vector<ll>>;
// 二部グラフ判定
vector<ll> color;
bool dfs(const Graph &G, int v, int cur = 0) {
color[v] = cur;
for (auto next_v : G[v]) {
// 隣接頂点がすでに色確定していた場合
if (color[next_v] != -1) {
if (color[next_v] == cur)
return false; // 同じ色が隣接したらダメ
continue;
}
// 隣接頂点の色を変えて、再帰的に探索 (一回でも false が返ってきたら false)
if (!dfs(G, next_v, 1 - cur))
return false;
}
return true;
}
int main() {
ll N, T;
string S;
ll ans = 0;
cin >> N;
ll A[N];
FOR(i, 0, N - 1) {
cin >> A[i];
if (A[i] % 2 == 1) {
ans++;
}
}
if (ans != 0) {
cout << "second" << endl;
} else {
cout << "first" << endl;
}
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
#define FOR(i, a, b) for (long long int i = (a); i <= (b); i++)
#define RFOR(i, a, b) for (long long int i = (a); i >= (b); i--)
#define MOD 1000000007
#define LLONG_MAXs 9223372036854775800
#define ALL(a) (a).begin(), (a).end()
#include <cmath>
#include <iostream>
using namespace std;
bool isPrimeNum(ll x) { // 素数である場合 true を返す
if (x <= 1) { // 1以下である場合は素数でないことがすぐにわかる
return false;
}
// sqrt( double型 ) は引数の平方根を double型で返すので、int型でキャスト
int n = (int)sqrt((double)x);
for (int i = 2; i <= n; i++) {
if (x % i == 0) { // 割り切る整数がある場合、即判定終了
return false;
}
}
return true; // 割り切る整数がない場合、素数である
}
ll myPow(ll x, ll n, ll m) {
if (n == 0)
return 1;
if (n % 2 == 0)
return myPow(x * x % m, n / 2, m);
else
return x * myPow(x, n - 1, m) % m;
}
constexpr ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
constexpr ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
constexpr ll abs(ll a, ll b) {
if (a >= b)
return a - b;
if (a < b)
return b - a;
}
constexpr double dabs(double a, double b) {
if (a >= b)
return a - b;
if (a < b)
return b - a;
}
constexpr ll min(ll a, ll b) {
if (a >= b)
return b;
if (a < b)
return a;
}
constexpr ll max(ll a, ll b) {
if (a >= b)
return a;
if (a < b)
return b;
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
class UnionFind {
public:
//親の番号を格納する。親だった場合は-(その集合のサイズ)
vector<int> Parent;
//作るときはParentの値を全て-1にする
//こうすると全てバラバラになる
UnionFind(int N) { Parent = vector<int>(N, -1); }
// Aがどのグループに属しているか調べる
int root(int A) {
if (Parent[A] < 0)
return A;
return Parent[A] = root(Parent[A]);
}
//自分のいるグループの頂点数を調べる
int size(int A) {
return -Parent[root(A)]; //親をとってきたい]
}
// AとBをくっ付ける
bool connect(int A, int B) {
// AとBを直接つなぐのではなく、root(A)にroot(B)をくっつける
A = root(A);
B = root(B);
if (A == B) {
//すでにくっついてるからくっ付けない
return false;
}
//大きい方(A)に小さいほう(B)をくっ付けたい
//大小が逆だったらひっくり返しちゃう。
if (size(A) < size(B))
swap(A, B);
// Aのサイズを更新する
Parent[A] += Parent[B];
// Bの親をAに変更する
Parent[B] = A;
return true;
}
};
long long fac[510000], finv[510000], inv[510000];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < 510000; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
string replaceAll(string &replacedStr, string from, string to) {
unsigned int pos = replacedStr.find(from);
int toLen = to.length();
if (from.empty()) {
return replacedStr;
}
while ((pos = replacedStr.find(from, pos)) != std::string::npos) {
replacedStr.replace(pos, from.length(), to);
pos += toLen;
}
return replacedStr;
}
void yn(bool flag) {
if (flag) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return;
}
void YN(bool flag) {
if (flag) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return;
}
std::vector<int> enum_div(int n) // nの約数を列挙
{
std::vector<int> ret;
for (int i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i != 1 && i * i != n) {
ret.push_back(n / i);
}
}
}
ret.push_back(n);
return ret;
}
void Ssort(int no, char *month[]) {
int i, j;
char *temp;
for (i = 0; i < no; i++) {
for (j = i + 1; j < no; j++) {
if (strcmp((month[i]), (month[j])) > 0) {
temp = *(month + i);
*(month + i) = *(month + j);
*(month + j) = temp;
}
}
}
}
using namespace std;
using Graph = vector<vector<ll>>;
// 二部グラフ判定
vector<ll> color;
bool dfs(const Graph &G, int v, int cur = 0) {
color[v] = cur;
for (auto next_v : G[v]) {
// 隣接頂点がすでに色確定していた場合
if (color[next_v] != -1) {
if (color[next_v] == cur)
return false; // 同じ色が隣接したらダメ
continue;
}
// 隣接頂点の色を変えて、再帰的に探索 (一回でも false が返ってきたら false)
if (!dfs(G, next_v, 1 - cur))
return false;
}
return true;
}
int main() {
ll N, T;
string S;
ll ans = 0;
cin >> N;
ll A[N];
FOR(i, 0, N - 1) {
cin >> A[i];
if (A[i] % 2 == 1) {
ans++;
}
}
if (ans == 0) {
cout << "second" << endl;
} else {
cout << "first" << endl;
}
return 0;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 991,392 | 991,393 | u043443359 | cpp |
p03197 | #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
#define FOR(i, a, b) for (long long int i = (a); i <= (b); i++)
#define RFOR(i, a, b) for (long long int i = (a); i >= (b); i--)
#define MOD 1000000007
#define LLONG_MAXs 9223372036854775800
#define ALL(a) (a).begin(), (a).end()
#include <cmath>
#include <iostream>
using namespace std;
bool isPrimeNum(ll x) { // 素数である場合 true を返す
if (x <= 1) { // 1以下である場合は素数でないことがすぐにわかる
return false;
}
// sqrt( double型 ) は引数の平方根を double型で返すので、int型でキャスト
int n = (int)sqrt((double)x);
for (int i = 2; i <= n; i++) {
if (x % i == 0) { // 割り切る整数がある場合、即判定終了
return false;
}
}
return true; // 割り切る整数がない場合、素数である
}
ll myPow(ll x, ll n, ll m) {
if (n == 0)
return 1;
if (n % 2 == 0)
return myPow(x * x % m, n / 2, m);
else
return x * myPow(x, n - 1, m) % m;
}
constexpr ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
constexpr ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
constexpr ll abs(ll a, ll b) {
if (a >= b)
return a - b;
if (a < b)
return b - a;
}
constexpr double dabs(double a, double b) {
if (a >= b)
return a - b;
if (a < b)
return b - a;
}
constexpr ll min(ll a, ll b) {
if (a >= b)
return b;
if (a < b)
return a;
}
constexpr ll max(ll a, ll b) {
if (a >= b)
return a;
if (a < b)
return b;
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
class UnionFind {
public:
//親の番号を格納する。親だった場合は-(その集合のサイズ)
vector<int> Parent;
//作るときはParentの値を全て-1にする
//こうすると全てバラバラになる
UnionFind(int N) { Parent = vector<int>(N, -1); }
// Aがどのグループに属しているか調べる
int root(int A) {
if (Parent[A] < 0)
return A;
return Parent[A] = root(Parent[A]);
}
//自分のいるグループの頂点数を調べる
int size(int A) {
return -Parent[root(A)]; //親をとってきたい]
}
// AとBをくっ付ける
bool connect(int A, int B) {
// AとBを直接つなぐのではなく、root(A)にroot(B)をくっつける
A = root(A);
B = root(B);
if (A == B) {
//すでにくっついてるからくっ付けない
return false;
}
//大きい方(A)に小さいほう(B)をくっ付けたい
//大小が逆だったらひっくり返しちゃう。
if (size(A) < size(B))
swap(A, B);
// Aのサイズを更新する
Parent[A] += Parent[B];
// Bの親をAに変更する
Parent[B] = A;
return true;
}
};
long long fac[510000], finv[510000], inv[510000];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < 510000; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
string replaceAll(string &replacedStr, string from, string to) {
unsigned int pos = replacedStr.find(from);
int toLen = to.length();
if (from.empty()) {
return replacedStr;
}
while ((pos = replacedStr.find(from, pos)) != std::string::npos) {
replacedStr.replace(pos, from.length(), to);
pos += toLen;
}
return replacedStr;
}
void yn(bool flag) {
if (flag) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return;
}
void YN(bool flag) {
if (flag) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return;
}
std::vector<int> enum_div(int n) // nの約数を列挙
{
std::vector<int> ret;
for (int i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i != 1 && i * i != n) {
ret.push_back(n / i);
}
}
}
ret.push_back(n);
return ret;
}
void Ssort(int no, char *month[]) {
int i, j;
char *temp;
for (i = 0; i < no; i++) {
for (j = i + 1; j < no; j++) {
if (strcmp((month[i]), (month[j])) > 0) {
temp = *(month + i);
*(month + i) = *(month + j);
*(month + j) = temp;
}
}
}
}
using namespace std;
using Graph = vector<vector<ll>>;
// 二部グラフ判定
vector<ll> color;
bool dfs(const Graph &G, int v, int cur = 0) {
color[v] = cur;
for (auto next_v : G[v]) {
// 隣接頂点がすでに色確定していた場合
if (color[next_v] != -1) {
if (color[next_v] == cur)
return false; // 同じ色が隣接したらダメ
continue;
}
// 隣接頂点の色を変えて、再帰的に探索 (一回でも false が返ってきたら false)
if (!dfs(G, next_v, 1 - cur))
return false;
}
return true;
}
int main() {
ll N, T;
string S;
ll ans = 0;
cin >> N;
ll A[N];
FOR(i, 0, N - 1) {
cin >> A[i];
if (A[i] % 2 == 1) {
ans++;
}
}
if (ans != 0) {
cout << "Second" << endl;
} else {
cout << "First" << endl;
}
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
#define FOR(i, a, b) for (long long int i = (a); i <= (b); i++)
#define RFOR(i, a, b) for (long long int i = (a); i >= (b); i--)
#define MOD 1000000007
#define LLONG_MAXs 9223372036854775800
#define ALL(a) (a).begin(), (a).end()
#include <cmath>
#include <iostream>
using namespace std;
bool isPrimeNum(ll x) { // 素数である場合 true を返す
if (x <= 1) { // 1以下である場合は素数でないことがすぐにわかる
return false;
}
// sqrt( double型 ) は引数の平方根を double型で返すので、int型でキャスト
int n = (int)sqrt((double)x);
for (int i = 2; i <= n; i++) {
if (x % i == 0) { // 割り切る整数がある場合、即判定終了
return false;
}
}
return true; // 割り切る整数がない場合、素数である
}
ll myPow(ll x, ll n, ll m) {
if (n == 0)
return 1;
if (n % 2 == 0)
return myPow(x * x % m, n / 2, m);
else
return x * myPow(x, n - 1, m) % m;
}
constexpr ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
constexpr ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
constexpr ll abs(ll a, ll b) {
if (a >= b)
return a - b;
if (a < b)
return b - a;
}
constexpr double dabs(double a, double b) {
if (a >= b)
return a - b;
if (a < b)
return b - a;
}
constexpr ll min(ll a, ll b) {
if (a >= b)
return b;
if (a < b)
return a;
}
constexpr ll max(ll a, ll b) {
if (a >= b)
return a;
if (a < b)
return b;
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
class UnionFind {
public:
//親の番号を格納する。親だった場合は-(その集合のサイズ)
vector<int> Parent;
//作るときはParentの値を全て-1にする
//こうすると全てバラバラになる
UnionFind(int N) { Parent = vector<int>(N, -1); }
// Aがどのグループに属しているか調べる
int root(int A) {
if (Parent[A] < 0)
return A;
return Parent[A] = root(Parent[A]);
}
//自分のいるグループの頂点数を調べる
int size(int A) {
return -Parent[root(A)]; //親をとってきたい]
}
// AとBをくっ付ける
bool connect(int A, int B) {
// AとBを直接つなぐのではなく、root(A)にroot(B)をくっつける
A = root(A);
B = root(B);
if (A == B) {
//すでにくっついてるからくっ付けない
return false;
}
//大きい方(A)に小さいほう(B)をくっ付けたい
//大小が逆だったらひっくり返しちゃう。
if (size(A) < size(B))
swap(A, B);
// Aのサイズを更新する
Parent[A] += Parent[B];
// Bの親をAに変更する
Parent[B] = A;
return true;
}
};
long long fac[510000], finv[510000], inv[510000];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < 510000; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
string replaceAll(string &replacedStr, string from, string to) {
unsigned int pos = replacedStr.find(from);
int toLen = to.length();
if (from.empty()) {
return replacedStr;
}
while ((pos = replacedStr.find(from, pos)) != std::string::npos) {
replacedStr.replace(pos, from.length(), to);
pos += toLen;
}
return replacedStr;
}
void yn(bool flag) {
if (flag) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return;
}
void YN(bool flag) {
if (flag) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return;
}
std::vector<int> enum_div(int n) // nの約数を列挙
{
std::vector<int> ret;
for (int i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i != 1 && i * i != n) {
ret.push_back(n / i);
}
}
}
ret.push_back(n);
return ret;
}
void Ssort(int no, char *month[]) {
int i, j;
char *temp;
for (i = 0; i < no; i++) {
for (j = i + 1; j < no; j++) {
if (strcmp((month[i]), (month[j])) > 0) {
temp = *(month + i);
*(month + i) = *(month + j);
*(month + j) = temp;
}
}
}
}
using namespace std;
using Graph = vector<vector<ll>>;
// 二部グラフ判定
vector<ll> color;
bool dfs(const Graph &G, int v, int cur = 0) {
color[v] = cur;
for (auto next_v : G[v]) {
// 隣接頂点がすでに色確定していた場合
if (color[next_v] != -1) {
if (color[next_v] == cur)
return false; // 同じ色が隣接したらダメ
continue;
}
// 隣接頂点の色を変えて、再帰的に探索 (一回でも false が返ってきたら false)
if (!dfs(G, next_v, 1 - cur))
return false;
}
return true;
}
int main() {
ll N, T;
string S;
ll ans = 0;
cin >> N;
ll A[N];
FOR(i, 0, N - 1) {
cin >> A[i];
if (A[i] % 2 == 1) {
ans++;
}
}
if (ans == 0) {
cout << "second" << endl;
} else {
cout << "first" << endl;
}
return 0;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 991,394 | 991,393 | u043443359 | cpp |
p03197 | #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
#define FOR(i, a, b) for (long long int i = (a); i <= (b); i++)
#define RFOR(i, a, b) for (long long int i = (a); i >= (b); i--)
#define MOD 1000000007
#define LLONG_MAXs 9223372036854775800
#define ALL(a) (a).begin(), (a).end()
#include <cmath>
#include <iostream>
using namespace std;
bool isPrimeNum(ll x) { // 素数である場合 true を返す
if (x <= 1) { // 1以下である場合は素数でないことがすぐにわかる
return false;
}
// sqrt( double型 ) は引数の平方根を double型で返すので、int型でキャスト
int n = (int)sqrt((double)x);
for (int i = 2; i <= n; i++) {
if (x % i == 0) { // 割り切る整数がある場合、即判定終了
return false;
}
}
return true; // 割り切る整数がない場合、素数である
}
ll myPow(ll x, ll n, ll m) {
if (n == 0)
return 1;
if (n % 2 == 0)
return myPow(x * x % m, n / 2, m);
else
return x * myPow(x, n - 1, m) % m;
}
constexpr ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
constexpr ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
constexpr ll abs(ll a, ll b) {
if (a >= b)
return a - b;
if (a < b)
return b - a;
}
constexpr double dabs(double a, double b) {
if (a >= b)
return a - b;
if (a < b)
return b - a;
}
constexpr ll min(ll a, ll b) {
if (a >= b)
return b;
if (a < b)
return a;
}
constexpr ll max(ll a, ll b) {
if (a >= b)
return a;
if (a < b)
return b;
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
class UnionFind {
public:
//親の番号を格納する。親だった場合は-(その集合のサイズ)
vector<int> Parent;
//作るときはParentの値を全て-1にする
//こうすると全てバラバラになる
UnionFind(int N) { Parent = vector<int>(N, -1); }
// Aがどのグループに属しているか調べる
int root(int A) {
if (Parent[A] < 0)
return A;
return Parent[A] = root(Parent[A]);
}
//自分のいるグループの頂点数を調べる
int size(int A) {
return -Parent[root(A)]; //親をとってきたい]
}
// AとBをくっ付ける
bool connect(int A, int B) {
// AとBを直接つなぐのではなく、root(A)にroot(B)をくっつける
A = root(A);
B = root(B);
if (A == B) {
//すでにくっついてるからくっ付けない
return false;
}
//大きい方(A)に小さいほう(B)をくっ付けたい
//大小が逆だったらひっくり返しちゃう。
if (size(A) < size(B))
swap(A, B);
// Aのサイズを更新する
Parent[A] += Parent[B];
// Bの親をAに変更する
Parent[B] = A;
return true;
}
};
long long fac[510000], finv[510000], inv[510000];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < 510000; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
string replaceAll(string &replacedStr, string from, string to) {
unsigned int pos = replacedStr.find(from);
int toLen = to.length();
if (from.empty()) {
return replacedStr;
}
while ((pos = replacedStr.find(from, pos)) != std::string::npos) {
replacedStr.replace(pos, from.length(), to);
pos += toLen;
}
return replacedStr;
}
void yn(bool flag) {
if (flag) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return;
}
void YN(bool flag) {
if (flag) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return;
}
std::vector<int> enum_div(int n) // nの約数を列挙
{
std::vector<int> ret;
for (int i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i != 1 && i * i != n) {
ret.push_back(n / i);
}
}
}
ret.push_back(n);
return ret;
}
void Ssort(int no, char *month[]) {
int i, j;
char *temp;
for (i = 0; i < no; i++) {
for (j = i + 1; j < no; j++) {
if (strcmp((month[i]), (month[j])) > 0) {
temp = *(month + i);
*(month + i) = *(month + j);
*(month + j) = temp;
}
}
}
}
using namespace std;
using Graph = vector<vector<ll>>;
// 二部グラフ判定
vector<ll> color;
bool dfs(const Graph &G, int v, int cur = 0) {
color[v] = cur;
for (auto next_v : G[v]) {
// 隣接頂点がすでに色確定していた場合
if (color[next_v] != -1) {
if (color[next_v] == cur)
return false; // 同じ色が隣接したらダメ
continue;
}
// 隣接頂点の色を変えて、再帰的に探索 (一回でも false が返ってきたら false)
if (!dfs(G, next_v, 1 - cur))
return false;
}
return true;
}
int main() {
ll N, T;
string S;
ll ans = 0;
cin >> N;
ll A[N];
FOR(i, 0, N - 1) {
cin >> A[i];
if (A[i] % 2 == 1) {
ans++;
}
}
if (ans == 0) {
cout << "Second" << endl;
} else {
cout << "First" << endl;
}
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
#define FOR(i, a, b) for (long long int i = (a); i <= (b); i++)
#define RFOR(i, a, b) for (long long int i = (a); i >= (b); i--)
#define MOD 1000000007
#define LLONG_MAXs 9223372036854775800
#define ALL(a) (a).begin(), (a).end()
#include <cmath>
#include <iostream>
using namespace std;
bool isPrimeNum(ll x) { // 素数である場合 true を返す
if (x <= 1) { // 1以下である場合は素数でないことがすぐにわかる
return false;
}
// sqrt( double型 ) は引数の平方根を double型で返すので、int型でキャスト
int n = (int)sqrt((double)x);
for (int i = 2; i <= n; i++) {
if (x % i == 0) { // 割り切る整数がある場合、即判定終了
return false;
}
}
return true; // 割り切る整数がない場合、素数である
}
ll myPow(ll x, ll n, ll m) {
if (n == 0)
return 1;
if (n % 2 == 0)
return myPow(x * x % m, n / 2, m);
else
return x * myPow(x, n - 1, m) % m;
}
constexpr ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
constexpr ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
constexpr ll abs(ll a, ll b) {
if (a >= b)
return a - b;
if (a < b)
return b - a;
}
constexpr double dabs(double a, double b) {
if (a >= b)
return a - b;
if (a < b)
return b - a;
}
constexpr ll min(ll a, ll b) {
if (a >= b)
return b;
if (a < b)
return a;
}
constexpr ll max(ll a, ll b) {
if (a >= b)
return a;
if (a < b)
return b;
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
class UnionFind {
public:
//親の番号を格納する。親だった場合は-(その集合のサイズ)
vector<int> Parent;
//作るときはParentの値を全て-1にする
//こうすると全てバラバラになる
UnionFind(int N) { Parent = vector<int>(N, -1); }
// Aがどのグループに属しているか調べる
int root(int A) {
if (Parent[A] < 0)
return A;
return Parent[A] = root(Parent[A]);
}
//自分のいるグループの頂点数を調べる
int size(int A) {
return -Parent[root(A)]; //親をとってきたい]
}
// AとBをくっ付ける
bool connect(int A, int B) {
// AとBを直接つなぐのではなく、root(A)にroot(B)をくっつける
A = root(A);
B = root(B);
if (A == B) {
//すでにくっついてるからくっ付けない
return false;
}
//大きい方(A)に小さいほう(B)をくっ付けたい
//大小が逆だったらひっくり返しちゃう。
if (size(A) < size(B))
swap(A, B);
// Aのサイズを更新する
Parent[A] += Parent[B];
// Bの親をAに変更する
Parent[B] = A;
return true;
}
};
long long fac[510000], finv[510000], inv[510000];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < 510000; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
string replaceAll(string &replacedStr, string from, string to) {
unsigned int pos = replacedStr.find(from);
int toLen = to.length();
if (from.empty()) {
return replacedStr;
}
while ((pos = replacedStr.find(from, pos)) != std::string::npos) {
replacedStr.replace(pos, from.length(), to);
pos += toLen;
}
return replacedStr;
}
void yn(bool flag) {
if (flag) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return;
}
void YN(bool flag) {
if (flag) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return;
}
std::vector<int> enum_div(int n) // nの約数を列挙
{
std::vector<int> ret;
for (int i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i != 1 && i * i != n) {
ret.push_back(n / i);
}
}
}
ret.push_back(n);
return ret;
}
void Ssort(int no, char *month[]) {
int i, j;
char *temp;
for (i = 0; i < no; i++) {
for (j = i + 1; j < no; j++) {
if (strcmp((month[i]), (month[j])) > 0) {
temp = *(month + i);
*(month + i) = *(month + j);
*(month + j) = temp;
}
}
}
}
using namespace std;
using Graph = vector<vector<ll>>;
// 二部グラフ判定
vector<ll> color;
bool dfs(const Graph &G, int v, int cur = 0) {
color[v] = cur;
for (auto next_v : G[v]) {
// 隣接頂点がすでに色確定していた場合
if (color[next_v] != -1) {
if (color[next_v] == cur)
return false; // 同じ色が隣接したらダメ
continue;
}
// 隣接頂点の色を変えて、再帰的に探索 (一回でも false が返ってきたら false)
if (!dfs(G, next_v, 1 - cur))
return false;
}
return true;
}
int main() {
ll N, T;
string S;
ll ans = 0;
cin >> N;
ll A[N];
FOR(i, 0, N - 1) {
cin >> A[i];
if (A[i] % 2 == 1) {
ans++;
}
}
if (ans == 0) {
cout << "second" << endl;
} else {
cout << "first" << endl;
}
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 991,395 | 991,393 | u043443359 | cpp |
p03197 | // https://atcoder.jp/contests/caddi2018/tasks/caddi2018_b
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); ++i)
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, t;
cin >> n;
bool ans = false;
REP(i, n) {
cin >> t;
if (ans % 2 != 0) {
ans = true;
}
}
if (ans) {
cout << "first\n";
} else {
cout << "second\n";
}
return 0;
}
| // https://atcoder.jp/contests/caddi2018/tasks/caddi2018_b
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); ++i)
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, t;
cin >> n;
// 全てが偶数だったら負ける
bool ans = false;
REP(i, n) {
cin >> t;
if (t % 2 != 0) {
ans = true;
}
}
if (ans) {
cout << "first\n";
} else {
cout << "second\n";
}
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 991,404 | 991,405 | u858107870 | cpp |
p03197 | #include <algorithm>
#include <iostream>
#include <list>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
int gcd(int a, int b) {
int c = a % b;
while (c != 0) {
a = b;
b = c;
c = a % b;
}
return b;
}
struct UnionFind {
vector<int> par; // par[i]:iの親の番号 (例) par[3] = 2 : 3の親が2
UnionFind(int N) : par(N) { //最初は全てが根であるとして初期化
for (int i = 0; i < N; i++)
par[i] = i;
}
int root(int x) { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) { // xとyの木を併合
int rx = root(x); // xの根をrx
int ry = root(y); // yの根をry
if (rx == ry)
return; // xとyの根が同じ(=同じ木にある)時はそのまま
par[rx] =
ry; // xとyの根が同じでない(=同じ木にない)時：xの根rxをyの根ryにつける
}
bool same(int x, int y) { // 2つのデータx, yが属する木が同じならtrueを返す
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
typedef long long ll;
ll M = 1000000007;
vector<ll> fac(300001); // n!(mod M)
vector<ll> ifac(300001); // k!^{M-2} (mod M)
ll mpow(ll x, ll n) {
ll ans = 1;
while (n != 0) {
if (n & 1)
ans = ans * x % M;
x = x * x % M;
n = n >> 1;
}
return ans;
}
ll comb(ll a, ll b) {
if (a == 0 && b == 0)
return 1;
if (a < b || a < 0)
return 0;
ll tmp = ifac[a - b] * ifac[b] % M;
return tmp * fac[a] % M;
}
// mod. m での a の逆元 a^{-1} を計算する
long long modinv(long long a) {
long long b = M, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= M;
if (u < 0)
u += M;
return u;
}
vector<vector<ll>> mul(vector<vector<ll>> a, vector<vector<ll>> b, int n) {
int i, j, k, t;
vector<vector<ll>> c(n);
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
t = 0;
for (k = 0; k < n; k++)
t = (t + a[i][k] * b[k][j] % M) % M;
c[i].push_back(t);
}
}
return c;
}
int main() {
int n, i, flag = 0, a;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a;
if (n % 2 == 1)
flag++;
}
if (flag > 0)
cout << "first" << endl;
else
cout << "second" << endl;
} | #include <algorithm>
#include <iostream>
#include <list>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
int gcd(int a, int b) {
int c = a % b;
while (c != 0) {
a = b;
b = c;
c = a % b;
}
return b;
}
struct UnionFind {
vector<int> par; // par[i]:iの親の番号 (例) par[3] = 2 : 3の親が2
UnionFind(int N) : par(N) { //最初は全てが根であるとして初期化
for (int i = 0; i < N; i++)
par[i] = i;
}
int root(int x) { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) { // xとyの木を併合
int rx = root(x); // xの根をrx
int ry = root(y); // yの根をry
if (rx == ry)
return; // xとyの根が同じ(=同じ木にある)時はそのまま
par[rx] =
ry; // xとyの根が同じでない(=同じ木にない)時：xの根rxをyの根ryにつける
}
bool same(int x, int y) { // 2つのデータx, yが属する木が同じならtrueを返す
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
typedef long long ll;
ll M = 1000000007;
vector<ll> fac(300001); // n!(mod M)
vector<ll> ifac(300001); // k!^{M-2} (mod M)
ll mpow(ll x, ll n) {
ll ans = 1;
while (n != 0) {
if (n & 1)
ans = ans * x % M;
x = x * x % M;
n = n >> 1;
}
return ans;
}
ll comb(ll a, ll b) {
if (a == 0 && b == 0)
return 1;
if (a < b || a < 0)
return 0;
ll tmp = ifac[a - b] * ifac[b] % M;
return tmp * fac[a] % M;
}
// mod. m での a の逆元 a^{-1} を計算する
long long modinv(long long a) {
long long b = M, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= M;
if (u < 0)
u += M;
return u;
}
vector<vector<ll>> mul(vector<vector<ll>> a, vector<vector<ll>> b, int n) {
int i, j, k, t;
vector<vector<ll>> c(n);
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
t = 0;
for (k = 0; k < n; k++)
t = (t + a[i][k] * b[k][j] % M) % M;
c[i].push_back(t);
}
}
return c;
}
int main() {
int n, i, flag = 0, a;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a;
if (a % 2 == 1)
flag++;
}
if (flag > 0)
cout << "first" << endl;
else
cout << "second" << endl;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 991,410 | 991,411 | u933068010 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
using LL = long long;
int main() {
int N;
cin >> N;
vector<int> a(N);
for (int i = 0; i < N; i++)
cin >> a[i];
bool f = true;
for (int i = 0; i < N; i++)
if (a[i] & 1)
f = false;
if (!f)
cout << "first" << endl;
else
cout << "seconde" << endl;
} | #include <bits/stdc++.h>
using namespace std;
using LL = long long;
int main() {
int N;
cin >> N;
vector<int> a(N);
for (int i = 0; i < N; i++)
cin >> a[i];
bool f = true;
for (int i = 0; i < N; i++)
if (a[i] & 1)
f = false;
if (!f)
cout << "first" << endl;
else
cout << "second" << endl;
} | [
"literal.string.change",
"io.output.change"
] | 991,417 | 991,418 | u510175787 | cpp |
p03197 | #include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
#define int long long
using namespace std;
typedef pair<int, int> P;
const int mod = 1000000007;
const int INF = 1e18;
signed main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> a(n);
int cnt = 0;
rep(i, 0, n) {
cin >> a[i];
if (a[i] % 2)
cnt++;
}
if (cnt % 2)
cout << "first" << endl;
else
cout << "second" << endl;
} | #include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
#define int long long
using namespace std;
typedef pair<int, int> P;
const int mod = 1000000007;
const int INF = 1e18;
signed main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> a(n);
int cnt = 0;
rep(i, 0, n) {
cin >> a[i];
if (a[i] % 2)
cnt++;
}
if (cnt > 0)
cout << "first" << endl;
else
cout << "second" << endl;
} | [] | 991,421 | 991,422 | u984730891 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const double eps = 1e-10;
const int MOD = 1000000007;
const int INF = 1000000000;
const ll LINF = 1ll << 50;
template <typename T> void printv(const vector<T> &s) {
for (int i = 0; i < (int)(s.size()); ++i) {
cout << s[i];
if (i == (int)(s.size()) - 1)
cout << endl;
else
cout << " ";
}
}
int main() {
cin.tie(0);
cout << fixed << setprecision(10);
int n;
cin >> n;
vector<int> a(n);
int ans = 0;
for (int i = 0; i < n; ++i) {
cin >> a[i];
a[i] %= 2;
ans ^= a[i];
}
cout << (ans ? "first" : "second") << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const double eps = 1e-10;
const int MOD = 1000000007;
const int INF = 1000000000;
const ll LINF = 1ll << 50;
template <typename T> void printv(const vector<T> &s) {
for (int i = 0; i < (int)(s.size()); ++i) {
cout << s[i];
if (i == (int)(s.size()) - 1)
cout << endl;
else
cout << " ";
}
}
int main() {
cin.tie(0);
cout << fixed << setprecision(10);
int n;
cin >> n;
vector<int> a(n);
int ans = 0;
for (int i = 0; i < n; ++i) {
cin >> a[i];
a[i] %= 2;
ans |= a[i];
}
cout << (ans ? "first" : "second") << endl;
}
| [
"expression.operator.change"
] | 991,423 | 991,424 | u334351654 | cpp |
p03197 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#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 long lint;
using namespace std;
int main() {
int N;
cin >> N;
lint a[N];
REP(i, N) cin >> a[i];
bool f = true;
REP(i, N) if (a[i] == 1) f = false;
if (!f)
cout << "first" << endl;
else
cout << "second" << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#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 long lint;
using namespace std;
int main() {
int N;
cin >> N;
lint a[N];
REP(i, N) cin >> a[i];
bool f = true;
REP(i, N) if (a[i] % 2 == 1) f = false;
if (!f)
cout << "first" << endl;
else
cout << "second" << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 991,425 | 991,426 | u484460274 | cpp |
p03197 | // g++ -std=c++11 a.cpp
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <utility>
#include <vector>
#define loop(i, a, b) for (int i = a; i < b; i++)
#define rep(i, a) loop(i, 0, a)
#define FOR(i, a) for (auto i : a)
#define pb push_back
#define all(in) in.begin(), in.end()
#define shosu(x) fixed << setprecision(x)
#define show1d(v) \
{ \
rep(_, v.size()) cout << " " << v[_]; \
puts(""); \
}
#define show2d(v) \
{ rep(__, v.size()) show1d(v[__]); }
using namespace std;
// kaewasuretyuui
typedef long long ll;
#define int ll
typedef int Def;
typedef pair<Def, Def> pii;
typedef vector<Def> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef vector<string> vs;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef pair<Def, pii> pip;
typedef vector<pip> vip;
#define mt make_tuple
typedef tuple<int, int, int, int> tp;
typedef vector<tp> vt;
template <typename A, typename B> bool cmin(A &a, const B &b) {
return a > b ? (a = b, true) : false;
}
template <typename A, typename B> bool cmax(A &a, const B &b) {
return a < b ? (a = b, true) : false;
}
// template<class C>constexpr int size(const C &c){return (int)c.size();}
// template<class T,size_t N> constexpr int size(const T
// (&xs)[N])noexcept{return (int)N;}
const double PI = acos(-1);
const double EPS = 1e-9;
Def inf = sizeof(Def) == sizeof(long long) ? 2e18 : 1e9 + 10;
// int dx[]={0,1,0,-1};
// int dy[]={1,0,-1,0};//RDLU
#define yes puts("YES")
#define no puts("NO")
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
bool h = true;
rep(i, n) {
int a;
cin >> a;
if (a % 2)
h = false;
}
if (h)
cout << "Second" << endl;
else
cout << "First" << endl;
}
| // g++ -std=c++11 a.cpp
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <utility>
#include <vector>
#define loop(i, a, b) for (int i = a; i < b; i++)
#define rep(i, a) loop(i, 0, a)
#define FOR(i, a) for (auto i : a)
#define pb push_back
#define all(in) in.begin(), in.end()
#define shosu(x) fixed << setprecision(x)
#define show1d(v) \
{ \
rep(_, v.size()) cout << " " << v[_]; \
puts(""); \
}
#define show2d(v) \
{ rep(__, v.size()) show1d(v[__]); }
using namespace std;
// kaewasuretyuui
typedef long long ll;
#define int ll
typedef int Def;
typedef pair<Def, Def> pii;
typedef vector<Def> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef vector<string> vs;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef pair<Def, pii> pip;
typedef vector<pip> vip;
#define mt make_tuple
typedef tuple<int, int, int, int> tp;
typedef vector<tp> vt;
template <typename A, typename B> bool cmin(A &a, const B &b) {
return a > b ? (a = b, true) : false;
}
template <typename A, typename B> bool cmax(A &a, const B &b) {
return a < b ? (a = b, true) : false;
}
// template<class C>constexpr int size(const C &c){return (int)c.size();}
// template<class T,size_t N> constexpr int size(const T
// (&xs)[N])noexcept{return (int)N;}
const double PI = acos(-1);
const double EPS = 1e-9;
Def inf = sizeof(Def) == sizeof(long long) ? 2e18 : 1e9 + 10;
// int dx[]={0,1,0,-1};
// int dy[]={1,0,-1,0};//RDLU
#define yes puts("YES")
#define no puts("NO")
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
bool h = true;
rep(i, n) {
int a;
cin >> a;
if (a % 2)
h = false;
}
if (h)
cout << "second" << endl;
else
cout << "first" << endl;
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 991,429 | 991,430 | u010004797 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
#define LL long long
#define pa pair<int, int>
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-')
f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + (ch ^ 48), ch = getchar();
return x * f;
}
int main() {
int n = read(), t = 0;
for (int i = 1; i <= n; i++)
t ^= (read() & 1);
if (t)
puts("first");
else
puts("second");
}
| #include <bits/stdc++.h>
using namespace std;
#define LL long long
#define pa pair<int, int>
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-')
f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + (ch ^ 48), ch = getchar();
return x * f;
}
int main() {
int n = read(), t = 0;
for (int i = 1; i <= n; i++)
t += (read() & 1);
if (t)
puts("first");
else
puts("second");
}
| [
"expression.operator.change"
] | 991,433 | 991,434 | u760076816 | cpp |
p03197 | #include <iostream>
using namespace std;
int main() {
int n;
bool f = false;
cin >> n;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
if (t % 2 == 1)
f = true;
}
if (f)
cout << "second" << endl;
else
cout << "first" << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n;
bool f = false;
cin >> n;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
if (t % 2 == 1)
f = true;
}
if (f)
cout << "first" << endl;
else
cout << "second" << endl;
return 0;
} | [
"control_flow.branch.else.remove",
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add"
] | 991,439 | 991,440 | u107077805 | cpp |
p03197 | #include <iostream>
using namespace std;
int main() {
int N;
long long temp;
cin >> N;
for (int i = 0; i < N; ++i) {
cin >> temp;
if ((temp & 1) == 0) {
cout << "first" << endl;
return 0;
}
}
cout << "second" << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int N;
long long temp;
cin >> N;
for (int i = 0; i < N; ++i) {
cin >> temp;
if ((temp & 1) == 1) {
cout << "first" << endl;
return 0;
}
}
cout << "second" << endl;
return 0;
} | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 991,441 | 991,442 | u225528554 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define MM = 1000000000;
#define mod = MM + 7;
#define INF (ll)1e18
#define pi acos(-1.0)
#define MAX 10000000005
#define NIL -1
int main() {
ll n;
cin >> n;
ll a[n];
bool flag = true;
for (ll i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2 == 1)
flag = false;
}
if (flag)
cout << "first" << endl;
else
cout << "second" << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define MM = 1000000000;
#define mod = MM + 7;
#define INF (ll)1e18
#define pi acos(-1.0)
#define MAX 10000000005
#define NIL -1
int main() {
ll n;
cin >> n;
ll a[n];
bool flag = false;
for (ll i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2 == 1)
flag = true;
}
if (flag)
cout << "first" << endl;
else
cout << "second" << endl;
} | [
"misc.opposites",
"variable_declaration.value.change",
"assignment.value.change"
] | 991,443 | 991,444 | u342051078 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define MM = 1000000000;
#define mod = MM + 7;
#define INF (ll)1e18
#define pi acos(-1.0)
#define MAX 10000000005
#define NIL -1
int main() {
ll n;
cin >> n;
ll a[n];
bool flag = true;
for (ll i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2 == 1)
flag = flag;
}
if (flag)
cout << "first" << endl;
else
cout << "second" << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define MM = 1000000000;
#define mod = MM + 7;
#define INF (ll)1e18
#define pi acos(-1.0)
#define MAX 10000000005
#define NIL -1
int main() {
ll n;
cin >> n;
ll a[n];
bool flag = false;
for (ll i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2 == 1)
flag = true;
}
if (flag)
cout << "first" << endl;
else
cout << "second" << endl;
} | [
"misc.opposites",
"variable_declaration.value.change",
"assignment.value.change"
] | 991,445 | 991,444 | u342051078 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define MM = 1000000000;
#define mod = MM + 7;
#define INF (ll)1e18
#define pi acos(-1.0)
#define MAX 10000000005
#define NIL -1
int main() {
ll n;
cin >> n;
ll a[n];
bool flag = true;
for (ll i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2 != 1)
flag = flag;
}
if (flag)
cout << "first" << endl;
else
cout << "second" << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define MM = 1000000000;
#define mod = MM + 7;
#define INF (ll)1e18
#define pi acos(-1.0)
#define MAX 10000000005
#define NIL -1
int main() {
ll n;
cin >> n;
ll a[n];
bool flag = false;
for (ll i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2 == 1)
flag = true;
}
if (flag)
cout << "first" << endl;
else
cout << "second" << endl;
} | [
"misc.opposites",
"variable_declaration.value.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"assignment.value.change"
] | 991,446 | 991,444 | u342051078 | cpp |
p03197 | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <array>
#include <bitset>
#include <complex>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define full(c) c.begin(), c.end()
#define vector2d(name, type, h, w, init) \
vector<vector<type>> name(h, vector<type>(w, init))
const int PRIME = 1000000007;
const int INT_INF = 2147483647;
const long long int LL_INF = 9223372036854775807;
const double PI = acos(-1);
const double EPS = 0.0001;
typedef unsigned long long int ull;
typedef long long int ll;
using namespace std;
int main() {
// cin.tie(0);
// ios::sync_with_stdio(false);
int n, flag = false;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (a % 2)
flag = true;
}
if (flag)
cout << "first" << endl;
else
cout << "second" << endl;
return 0;
}
| #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <array>
#include <bitset>
#include <complex>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define full(c) c.begin(), c.end()
#define vector2d(name, type, h, w, init) \
vector<vector<type>> name(h, vector<type>(w, init))
const int PRIME = 1000000007;
const int INT_INF = 2147483647;
const long long int LL_INF = 9223372036854775807;
const double PI = acos(-1);
const double EPS = 0.0001;
typedef unsigned long long int ull;
typedef long long int ll;
using namespace std;
int main() {
// cin.tie(0);
// ios::sync_with_stdio(false);
int n, flag = false;
cin >> n;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (a % 2)
flag = true;
}
if (flag)
cout << "first" << endl;
else
cout << "second" << endl;
return 0;
}
| [] | 991,455 | 991,456 | u271349541 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
int N;
int main() {
scanf("%d", &N);
int Xor = 0;
for (int i = 0; i < N; i++) {
int t;
scanf("%d", &t);
Xor ^= (t & 1);
}
if (Xor)
printf("first");
else
printf("second");
}
| #include <bits/stdc++.h>
using namespace std;
int N;
int main() {
scanf("%d", &N);
int ans = 0;
for (int i = 0; i < N; i++) {
int t;
scanf("%d", &t);
ans |= (t & 1);
}
if (ans)
printf("first");
else
printf("second");
}
| [
"variable_declaration.name.change",
"identifier.change",
"assignment.change",
"control_flow.branch.if.condition.change"
] | 991,457 | 991,458 | u333877810 | cpp |
p03197 | #include <bits/stdc++.h>
#include <stdio.h>
#define _USE_MATH_DEFINES_
#define ll long long
#define ld long double
#define Accepted 0
#define pb push_back
#define mp make_pair
#define sz(x) (int)(x.size())
#define every(x) x.begin(), x.end()
#define F first
#define S second
#define For(i, x, y) for (int i = x; i <= y; i++)
#define FOr(i, x, y) for (int i = x; i >= y; i--)
#define SpeedForce ios_base::sync_with_stdio(0), cin.tie(0)
// ROAD to... Red
using namespace std;
inline bool isvowel(char c) {
c = tolower(c);
if (c == 'a' || c == 'e' || c == 'i' || c == 'y' || c == 'o' || c == 'u')
return 1;
return 0;
}
const double eps = 0.000001;
const ld pi = acos(-1);
const int maxn = 1e7 + 9;
const int mod = 1e9 + 7;
const ll MOD = 1e18 + 9;
const ll INF = 1e18 + 123;
const int inf = 2e9 + 11;
const int mxn = 1e6 + 9;
const int N = 6e5 + 123;
const int M = 22;
const int pri = 997;
const int Magic = 2101;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
int n, m, k;
int cnt[N];
string s;
int a[N];
vector<int> g[N];
int u[N];
int ans, res;
int cur;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] & 1) {
ans ^= 1;
}
}
if (ans)
cout << "first";
else
cout << "second";
return Accepted;
}
// Coded By OB | #include <bits/stdc++.h>
#include <stdio.h>
#define _USE_MATH_DEFINES_
#define ll long long
#define ld long double
#define Accepted 0
#define pb push_back
#define mp make_pair
#define sz(x) (int)(x.size())
#define every(x) x.begin(), x.end()
#define F first
#define S second
#define For(i, x, y) for (int i = x; i <= y; i++)
#define FOr(i, x, y) for (int i = x; i >= y; i--)
#define SpeedForce ios_base::sync_with_stdio(0), cin.tie(0)
// ROAD to... Red
using namespace std;
inline bool isvowel(char c) {
c = tolower(c);
if (c == 'a' || c == 'e' || c == 'i' || c == 'y' || c == 'o' || c == 'u')
return 1;
return 0;
}
const double eps = 0.000001;
const ld pi = acos(-1);
const int maxn = 1e7 + 9;
const int mod = 1e9 + 7;
const ll MOD = 1e18 + 9;
const ll INF = 1e18 + 123;
const int inf = 2e9 + 11;
const int mxn = 1e6 + 9;
const int N = 6e5 + 123;
const int M = 22;
const int pri = 997;
const int Magic = 2101;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
int n, m, k;
int cnt[N];
string s;
int a[N];
vector<int> g[N];
int u[N];
int ans, res;
int cur;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] & 1) {
ans = 1;
}
}
if (ans)
cout << "first";
else
cout << "second";
return Accepted;
}
// Coded By OB | [
"assignment.value.change"
] | 991,459 | 991,460 | u202370403 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
int n, a[110001];
int main() {
cin >> n;
int k = 0;
for (int i = 1; i <= n; i++)
cin >> a[i], k ^= a[i] & 1;
cout << (k ? "first\n" : "second\n");
}
| #include <bits/stdc++.h>
using namespace std;
int n, a[110001];
int main() {
cin >> n;
int k = 0;
for (int i = 1; i <= n; i++)
cin >> a[i], k += a[i] & 1;
cout << (k ? "first\n" : "second\n");
}
| [
"expression.operator.change"
] | 991,461 | 991,462 | u844771757 | cpp |
p03197 | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (a % 2) {
cout << "First" << endl;
return 0;
}
}
cout << "Second" << endl;
}
| #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (a % 2) {
cout << "first" << endl;
return 0;
}
}
cout << "second" << endl;
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 991,465 | 991,466 | u374416262 | cpp |
p03197 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string>
using namespace std;
int main() {
int N;
cin >> N;
int a[100000];
for (int i = 0; i < N; i = i + 1) {
cin >> a[i];
}
int judge = 0;
for (int i = 0; i < N; i = i + 1) {
if (a[i] % 2 == 0) {
judge = judge + 1;
}
}
if (judge == N) {
cout << 'second' << endl;
} else {
cout << 'first' << endl;
}
} | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string>
using namespace std;
int main() {
int N;
cin >> N;
int a[100000];
for (int i = 0; i < N; i = i + 1) {
cin >> a[i];
}
int judge = 0;
for (int i = 0; i < N; i = i + 1) {
if (a[i] % 2 == 0) {
judge = judge + 1;
}
}
if (judge == N) {
cout << "second" << endl;
} else {
cout << "first" << endl;
}
} | [
"io.output.change",
"literal.string.change"
] | 991,467 | 991,468 | u088111798 | cpp |
p03197 | #include <bits/stdc++.h>
#define lsb(x) (x & (-x))
#define ll long long
#define ull unsigned long long
#define ld long double
// 217
// 44
using namespace std;
int main() {
// ifstream cin("A.in");
// ofstream cout("A.out");
int n, i;
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n;
int ans = 0;
for (i = 1; i <= n; i++) {
int x;
cin >> x;
ans ^= (x & 1);
}
if (ans == 0) {
cout << "second";
} else {
cout << "first";
}
// cin.close();
// cout.close();
return 0;
}
| #include <bits/stdc++.h>
#define lsb(x) (x & (-x))
#define ll long long
#define ull unsigned long long
#define ld long double
// 217
// 44
using namespace std;
int main() {
// ifstream cin("A.in");
// ofstream cout("A.out");
int n, i;
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n;
int ans = 0;
for (i = 1; i <= n; i++) {
int x;
cin >> x;
ans += (x & 1);
}
if (ans == 0) {
cout << "second";
} else {
cout << "first";
}
// cin.close();
// cout.close();
return 0;
}
| [
"expression.operator.change"
] | 991,471 | 991,472 | u094322844 | cpp |
p03197 | #include <bits/stdc++.h>
#include <iterator>
#include <set>
using namespace std;
const int mod = 998244353;
#define ft first
#define sd second
#define pb push_back
#define all(x) x.begin(), x.end()
#define ll long long int
#define vi vector<int>
#define vii vector<pair<int, int>>
#define pii pair<int, int>
#define plii pair<pair<ll, int>, int>
#define piii pair<pii, int>
#define viii vector<pair<pii, int>>
#define vl vector<ll>
#define vll vector<pair<ll, ll>>
#define pll pair<ll, ll>
#define pli pair<ll, int>
#define mp make_pair
#define ms(x, v) memset(x, v, sizeof x)
#define pr_vec(v) \
for (int i = 0; i < v.size(); i++) \
cout << v[i] << " ";
#define f_in(st) freopen(st, "r", stdin)
#define f_out(st) freopen(st, "w", stdout)
#define fr(i, a, b) for (i = a; i <= b; i++)
#define fb(i, a, b) for (i = a; i >= b; i--)
#define ASST(x, l, r) assert(x <= r && x >= l)
int main() {
ios_base::sync_with_stdio(0);
ll n;
cin >> n;
while (n--) {
ll i;
cin >> i;
if (i & 1)
cout << "first";
return 0;
}
cout << "second";
return 0;
}
| #include <bits/stdc++.h>
#include <iterator>
#include <set>
using namespace std;
const int mod = 998244353;
#define ft first
#define sd second
#define pb push_back
#define all(x) x.begin(), x.end()
#define ll long long int
#define vi vector<int>
#define vii vector<pair<int, int>>
#define pii pair<int, int>
#define plii pair<pair<ll, int>, int>
#define piii pair<pii, int>
#define viii vector<pair<pii, int>>
#define vl vector<ll>
#define vll vector<pair<ll, ll>>
#define pll pair<ll, ll>
#define pli pair<ll, int>
#define mp make_pair
#define ms(x, v) memset(x, v, sizeof x)
#define pr_vec(v) \
for (int i = 0; i < v.size(); i++) \
cout << v[i] << " ";
#define f_in(st) freopen(st, "r", stdin)
#define f_out(st) freopen(st, "w", stdout)
#define fr(i, a, b) for (i = a; i <= b; i++)
#define fb(i, a, b) for (i = a; i >= b; i--)
#define ASST(x, l, r) assert(x <= r && x >= l)
int main() {
ios_base::sync_with_stdio(0);
ll n;
cin >> n;
while (n--) {
ll i;
cin >> i;
if (i & 1) {
cout << "first";
return 0;
}
}
cout << "second";
return 0;
}
| [] | 991,473 | 991,474 | u888735570 | cpp |
p03197 | #include <bits/stdc++.h>
#include <iterator>
#include <set>
using namespace std;
const int mod = 998244353;
#define ft first
#define sd second
#define pb push_back
#define all(x) x.begin(), x.end()
#define ll long long int
#define vi vector<int>
#define vii vector<pair<int, int>>
#define pii pair<int, int>
#define plii pair<pair<ll, int>, int>
#define piii pair<pii, int>
#define viii vector<pair<pii, int>>
#define vl vector<ll>
#define vll vector<pair<ll, ll>>
#define pll pair<ll, ll>
#define pli pair<ll, int>
#define mp make_pair
#define ms(x, v) memset(x, v, sizeof x)
#define pr_vec(v) \
for (int i = 0; i < v.size(); i++) \
cout << v[i] << " ";
#define f_in(st) freopen(st, "r", stdin)
#define f_out(st) freopen(st, "w", stdout)
#define fr(i, a, b) for (i = a; i <= b; i++)
#define fb(i, a, b) for (i = a; i >= b; i--)
#define ASST(x, l, r) assert(x <= r && x >= l)
int main() {
ios_base::sync_with_stdio(0);
ll n;
cin >> n;
while (n--) {
ll i;
cin >> i;
if (i & 1)
cout << "first";
return 0;
}
cout << "seconf";
return 0;
}
| #include <bits/stdc++.h>
#include <iterator>
#include <set>
using namespace std;
const int mod = 998244353;
#define ft first
#define sd second
#define pb push_back
#define all(x) x.begin(), x.end()
#define ll long long int
#define vi vector<int>
#define vii vector<pair<int, int>>
#define pii pair<int, int>
#define plii pair<pair<ll, int>, int>
#define piii pair<pii, int>
#define viii vector<pair<pii, int>>
#define vl vector<ll>
#define vll vector<pair<ll, ll>>
#define pll pair<ll, ll>
#define pli pair<ll, int>
#define mp make_pair
#define ms(x, v) memset(x, v, sizeof x)
#define pr_vec(v) \
for (int i = 0; i < v.size(); i++) \
cout << v[i] << " ";
#define f_in(st) freopen(st, "r", stdin)
#define f_out(st) freopen(st, "w", stdout)
#define fr(i, a, b) for (i = a; i <= b; i++)
#define fb(i, a, b) for (i = a; i >= b; i--)
#define ASST(x, l, r) assert(x <= r && x >= l)
int main() {
ios_base::sync_with_stdio(0);
ll n;
cin >> n;
while (n--) {
ll i;
cin >> i;
if (i & 1) {
cout << "first";
return 0;
}
}
cout << "second";
return 0;
}
| [
"literal.string.change",
"io.output.change"
] | 991,475 | 991,474 | u888735570 | cpp |
p03197 | #include "bits/stdc++.h"
using namespace std;
#define int long long
int mod = 1e9 + 7;
signed main() {
int n;
cin >> n;
bool f = true;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (a % 2 == 1)
f = false;
}
if (f)
cout << "first" << endl;
else
cout << "second" << endl;
}
| #include "bits/stdc++.h"
using namespace std;
#define int long long
int mod = 1e9 + 7;
signed main() {
int n;
cin >> n;
bool f = true;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (a % 2 == 1)
f = false;
}
if (!f)
cout << "first" << endl;
else
cout << "second" << endl;
}
| [
"expression.operation.unary.add",
"control_flow.branch.if.condition.change"
] | 991,476 | 991,477 | u890465662 | cpp |
p03197 | // todo idef DEBUGで、境界チェック付きのvectorを作りたい
// http://marycore.jp/prog/cpp/class-extension-methods/
//現状ifdef DEBUG が何故か動かないので出来ない
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
struct initon {
initon() {
cin.tie(0);
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(16);
};
} hoee;
namespace std {
template <> class hash<std::pair<signed, signed>> {
public:
size_t operator()(const std::pair<signed, signed> &x) const {
return hash<ll>()(((ll)x.first << 32) + x.second);
}
};
template <> class hash<std::pair<ll, ll>> {
public:
size_t operator()(const std::pair<ll, ll> &x) const {
return hash<ll>()(((ll)x.first << 32) + x.second);
}
};
} // namespace std
//別名
#define ull unsigned long long
#define vec vector
#define con continue
#define bre break
#define brk break
#define is ==
#define eq ==
#define no !=
#define ne !=
#define dif !=
#define df !=
#define rs resize
#define PQ priority_queue<ll, vector<ll>, greater<ll>>
using vi = vector<int>;
#define vvi(a, b, c) vec<vi> a(b, vi(c))
using vb = vector<bool>;
#define vvb(a, b, c) vec<vb> a(b, vb(c))
using vs = vector<string>;
#define vvs(a, b, c) vec<vs> a(b, vs(c))
using vl = vector<ll>;
#define vvl(a, b, c) vec<vl> a(b, vl(c))
using vc = vector<char>;
#define vvc(a, b, c) vec<vc> a(b, vc(c))
using P = pair<int, int>;
using T = tuple<int, int, int>;
using vp = vector<P>;
#define vvp(a, b, c) vec<vp> a(b, vp(c))
using dou = double;
using itn = int;
using str = string;
using bo = bool;
#define uset unordered_set
#define umap unordered_map
#define F first
#define S second
//定数
#define k4 10101
#define k5 101010
#define k6 1010101
#define k7 10101010
const int INF = (int)1e9 + 100;
const ll LINF = (ll)1e18 + 100;
const double EPS = 1e-9;
const int y4[] = {-1, 1, 0, 0};
const int x4[] = {0, 0, -1, 1};
const int y8[] = {0, 1, 0, -1, -1, 1, 1, -1};
const int x8[] = {1, 0, -1, 0, 1, -1, 1, -1};
//配列
#define sz(a) (sizeof(a) / sizeof(a[0]))
//コンテナ
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
template <class T> inline void sort(vector<T> &a) { sort(a.begin(), a.end()); };
template <class T> inline void rsort(vector<T> &a) {
sort(a.begin(), a.end(), greater<T>());
};
template <class T> inline void sort(vector<T> &a, int len) {
sort(a.begin(), a.begin() + len);
};
template <class T> inline void rsort(vector<T> &a, int len) {
sort(a.begin(), a.begin() + len, greater<T>());
};
//繰り返し
#define _overloadrep(_1, _2, _3, name, ...) name
#define _rep(i, n) for (int i = 0; i < n; i++)
#define repi(i, m, n) for (int i = m; i < n; i++)
#define rep(...) _overloadrep(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define _rer(i, n) for (int i = n; i >= 0; i--)
#define reri(i, m, n) for (int i = m; i >= n; i--)
#define rer(...) _overloadrep(__VA_ARGS__, reri, _rer, )(__VA_ARGS__)
#define fora(a, b) for (auto &&a : b)
#define forr(a, b) for_each(map.rbegin(),map.rend(),[](auto&& a)
#define rea(a, b) for (auto &&a : b)
#define repa(a, b) for (auto &&a : b)
template <typename A, size_t N, typename T> void fill(A (&a)[N], const T &v) {
rep(i, N) a[i] = v;
}
template <typename A, size_t N, size_t O, typename T>
void fill(A (&a)[N][O], const T &v) {
rep(i, N) rep(j, O) a[i][j] = v;
}
template <typename A, size_t N, size_t O, size_t P, typename T>
void fill(A (&a)[N][O][P], const T &v) {
rep(i, N) rep(j, O) rep(k, P) a[i][j][k] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, typename T>
void fill(A (&a)[N][O][P][Q], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) a[i][j][k][l] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
typename T>
void fill(A (&a)[N][O][P][Q][R], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) a[i][j][k][l][m] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S, typename T>
void fill(A (&a)[N][O][P][Q][R][S], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) rep(n, S)
a[i][j][k][l][m][n] = v;
}
template <class T, class U> void fill(vector<T> &a, U v) {
rep(i, a.size()) a[i] = v;
}
template <class T, class U> void fill(vector<vector<T>> &a, U v) {
rep(i, a.size()) rep(j, a[0].size()) a[i][j] = v;
}
template <class T, class U> void fill(vector<vector<vector<T>>> &a, U v) {
rep(i, a.size()) rep(j, a[0].size()) rep(k, a[0][0].size()) a[i][j][k] = v;
}
#define arcpy(a, b) memcpy(a, b, sizeof(b))
//入力
template <typename T = int> T in() {
T x;
cin >> x;
return (x);
}
string sin() { return in<string>(); }
double din() { return in<double>(); }
ll lin() { return in<ll>(); }
#define na(a, n) rep(i, n) cin >> a[i];
#define nad(a, n) rep(i, n) cin >> a[i], a[i]--;
#define na3(a, b, c, n) rep(i, n) cin >> a[i] >> b[i] >> c[i];
#define add3(a, b, c, n) rep(i, n) a.pb(in()), b.pb(in()), c.pb(in());
#define na2(a, b, n) rep(i, n) cin >> a[i] >> b[i];
#define nt(a, h, w) rep(hi, h) rep(wi, w) cin >> a[hi][wi];
#define ntd(a, h, w) rep(hi, h) rep(wi, w) cin >> a[hi][wi], a[hi][wi]--;
#define ntp(a, h, w) \
fill(a, '#'); \
rep(hi, 1, h + 1) rep(wi, 1, w + 1) cin >> a[hi][wi];
#define addAll(a, n) rep(i, n) a.pb(in());
#define addAlld(a, n) rep(i, n) a.pb(in() - 1);
//出力
template <class T> void out(T x) {
if (typeid(x) == typeid(double))
cout << fixed << setprecision(10) << x << endl;
else
cout << x << endl;
}
//デバッグ
#define debug(x) \
cerr << x << " " \
<< "(L:" << __LINE__ << ")" << '\n';
// 境界チェック付きvector
namespace std_vector_bounds_checking {
using namespace std;
template <class T, class A = std::allocator<T>>
struct vector : std::vector<T, A> {
using std::vector<T, A>::vector;
typename std::vector<T>::reference
operator[](typename std::vector<T>::size_type n) {
return this->at(n);
}
};
} // namespace std_vector_bounds_checking
//よく使うクラス、構造体
class UnionFind {
public:
vi par, rank, sizes;
int n, trees;
UnionFind(int n) : n(n), trees(n) {
par.resize(n), rank.resize(n), sizes.resize(n);
rep(i, n) par[i] = i, sizes[i] = 1;
}
int root(int x) {
if (par[x] == x)
return x;
else
return par[x] = root(par[x]);
}
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (rank[x] < rank[y])
swap(x, y);
trees--;
par[y] = x;
sizes[x] += sizes[y];
if (rank[x] == rank[y])
rank[x]++;
}
bool same(int x, int y) { return root(x) == root(y); }
int size(int x) { return sizes[root(x)]; }
//順不同 umapなので
vec<vi> sets() {
vec<vi> res(trees);
umap<int, vi> map;
rep(i, n) map[root(i)].push_back(i);
int i = 0;
for (auto &&p : map) {
int r = p.F;
res[i].push_back(r);
for (auto &&v : p.S) {
if (r == v)
continue;
res[i].push_back(v);
}
i++;
}
return res;
}
};
// MOD関連
ll MOD = (int)1e9 + 7;
int mpow(int v, ll a) {
ll x = v, n = a, res = 1;
while (n) {
if (n & 1)
res = (res * x) % MOD;
x = (x * x) % MOD;
n >>= 1;
}
return res;
}
class mint {
private:
ll v;
public:
static ll mod(ll a) { return (a % MOD + MOD) % MOD; }
mint(ll a = 0) { this->v = mod(a); };
mint(const mint &a) { v = a.v; }
mint operator+(const mint &a) { return mint(v + a.v); }
mint operator+(const ll a) { return mint(v + a % MOD); }
mint operator+(const signed a) { return mint(v + a % MOD); }
friend mint operator+(const ll a, const mint &b) {
return mint(a % MOD + b.v);
}
void operator+=(const mint &a) { v = (v + a.v) % MOD; }
void operator+=(const ll a) { v = mod(v + a % MOD); }
void operator+=(const signed a) { v = mod(v + a % MOD); }
friend void operator+=(ll &a, const mint &b) { a = mod(a % MOD + b.v); }
mint operator-(const mint &a) { return mint(v - a.v); }
mint operator-(const ll a) { return mint(v - a % MOD); }
mint operator-(const signed a) { return mint(v - a % MOD); }
friend mint operator-(const ll a, const mint &b) {
return mint(a % MOD - b.v);
}
void operator-=(const mint &a) { v = mod(v - a.v); }
void operator-=(const ll a) { v = mod(v - a % MOD); }
void operator-=(const signed a) { v = mod(v - a % MOD); }
friend void operator-=(ll &a, const mint &b) { a = mod(a % MOD - b.v); }
mint operator*(const mint &a) { return mint(v * a.v); }
mint operator*(const ll a) { return mint(v * (a % MOD)); }
mint operator*(const signed a) { return mint(v * (a % MOD)); }
friend mint operator*(const ll a, const mint &b) {
return mint(a % MOD * b.v);
}
void operator*=(const mint &a) { v = (v * a.v) % MOD; }
void operator*=(const ll a) { v = mod(v * (a % MOD)); }
void operator*=(const signed a) { v = mod(v * (a % MOD)); }
friend void operator*=(ll &a, const mint &b) { a = mod(a % MOD * b.v); }
mint operator/(const mint &a);
mint operator/(const ll a);
mint operator/(const signed a);
friend mint operator/(const ll a, const mint &b);
void operator/=(const mint &a);
void operator/=(const ll a);
void operator/=(const signed a);
friend void operator/=(ll &a, const mint &b);
mint operator^(const mint &a) { return mpow(v, a.v); };
mint operator^(const ll a) { return mpow(v, a); };
mint operator^(const signed a) { return mpow(v, a); };
friend mint operator^(const ll a, const mint &b) { return mpow(a, b.v); };
void operator^=(const mint &a) { v = mpow(v, a.v); }
void operator^=(const ll a) { v = mpow(v, a); }
void operator^=(const signed a) { v = mpow(v, a); }
//単項演算子
mint operator+() { return *this; }
mint operator++() {
v++;
return *this;
}
mint operator++(signed d) {
mint res = *this;
v++;
return res;
}
mint operator-() { return operator*(-1); }
mint operator--() {
v++;
return *this;
}
void operator--(signed d) {
mint res = *this;
v++;
}
bool operator==(mint &a) { return v == a.v; }
bool operator==(signed a) { return v == a; }
friend bool operator==(signed a, mint &b) { return a == b.v; }
bool operator!=(mint &a) { return v != a.v; }
bool operator!=(signed a) { return v != a; }
friend bool operator!=(signed a, mint &b) { return a != b.v; }
operator int() { return v; }
};
const int setModMax = 510000;
mint fac[setModMax], finv[setModMax], inv[setModMax];
void setMod() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < setModMax; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
mint minv(ll a) {
if (fac[0] == 0)
setMod();
if (a < setModMax)
return inv[a];
a %= MOD;
ll b = MOD, x = 1, y = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
x -= t * y;
swap(x, y);
}
return (x % MOD + MOD) % MOD;
}
mint mint::operator/(const mint &a) { return mint(v * minv(a.v)); }
mint mint::operator/(const ll a) { return mint(v * minv(a)); }
mint mint::operator/(const signed a) { return mint(v * minv(a)); }
mint operator/(const ll a, const mint &b) { return mint(a % MOD * minv(b.v)); }
void mint::operator/=(const mint &a) { v = (v * minv(a.v)) % MOD; }
void mint::operator/=(const ll a) { v = mod(v * minv(a)); }
void mint::operator/=(const signed a) { v = mod(v * minv(a)); }
void operator/=(ll &a, const mint &b) { a = mint::mod(a % MOD * minv(b.v)); }
using vm = vector<mint>;
#define vvm(a, b, c) vec<vm> a(b, vm(c))
bool isPrime[4010101];
vi primes;
void setPrime() {
fill(isPrime, true);
isPrime[0] = isPrime[1] = false;
for (int i = 2; i <= sqrt(sz(isPrime)) + 5; ++i) {
if (!isPrime[i])
continue;
for (int j = 2; i * j < sz(isPrime); ++j) {
isPrime[i * j] = false;
}
}
rep(i, sz(isPrime)) if (isPrime[i]) primes.pb(i);
}
mint com(ll n, ll r) {
if (n < r || n < 0 || r < 0)
return 0;
if (fac[0] == 0)
setMod();
return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD;
}
//便利関数
bool equal(double a, double b) { return fabs(a - b) < EPS; }
ll reverse(ll a) {
ll res = 0;
while (a) {
res *= 10;
res += a % 10;
a /= 10;
}
return res;
}
ll ceil(ll a, ll b) { return (a + b - 1) / b; }
ll sqrt(ll a) {
ll res = (ll)sqrt(a);
while (res * res < a)
res++;
return res;
}
ll sig(ll t) { return (1 + t) * t / 2; }
ll sig(ll s, ll t) { return (s + t) * (t - s + 1) / 2; }
vi divisors(int v) {
vi res;
for (int i = 1; i <= sqrt(v); ++i) {
if (v % i == 0) {
res.pb(i);
if (i != v / i)
res.pb(v / i);
}
}
return res;
}
vi factorization(int v) {
int tv = v;
vi res;
if (!isPrime[2])
setPrime();
for (auto &&p : primes) {
if (v % p == 0)
res.push_back(p);
while (v % p == 0) {
v /= p;
}
if (v == 1 || p * p > tv)
break;
}
if (v > 1)
res.pb(v);
return res;
}
unordered_map<int, int> factorizationMap(int v) {
int tv = v;
unordered_map<int, int> res;
if (!isPrime[2])
setPrime();
for (auto &&p : primes) {
while (v % p == 0) {
res[p]++;
v /= p;
}
if (v == 1 || p * p > tv)
break;
}
if (v > 1)
res[v]++;
return res;
}
int get(int a, int keta) {
a /= (int)pow(10, keta);
return a % 10;
}
//変換系
template <class T, class U> vector<U> keys(map<T, U> a) {
vector<U> res;
for (auto &&k : a)
res.pb(k.F);
return res;
}
template <class T, class U> vector<U> keys(umap<T, U> a) {
vector<U> res;
for (auto &&k : a)
res.pb(k.F);
return res;
}
template <class T, class U> vector<T> values(map<T, U> a) {
vector<T> res;
for (auto &&k : a)
res.pb(k.S);
return res;
}
template <class T, class U> vector<T> values(umap<T, U> a) {
vector<T> res;
for (auto &&k : a)
res.pb(k.S);
return res;
}
vi list(int a) {
vi res;
while (a) {
res.insert(res.begin(), a % 10);
a /= 10;
}
return res;
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <class T> T min(T a, signed b) { return a < b ? a : b; }
template <class T> T max(T a, signed b) { return a < b ? b : a; }
template <class T> T sum(vector<T> &v, int len = -1) {
if (len == -1)
len = v.size();
T res = 0;
rep(i, min((int)len, (int)v.size())) res += v[i];
return res;
}
///要素が0の時、返り値は0か1か
template <class T> T mul(vector<T> &v, int len = -1) {
if (len == -1)
len = v.size();
T res = 1;
rep(i, min((int)len, (int)v.size())) res *= v[i];
return res;
}
void clear(PQ &q) {
while (q.size())
q.pop();
}
template <class T> void clear(queue<T> &q) {
while (q.size())
q.pop();
}
template <class T> vector<T> ruiv(vector<T> &a) {
vector<T> res(a.size() + 1);
rep(i, a.size()) res[i + 1] = res[i] + a[i];
return res;
}
template <class T> void plus(vector<T> &a, T v = 1) {
for (auto &&u : a)
u += v;
}
template <class T> void minu(vector<T> &a, T v = 1) {
for (auto &&u : a)
u -= v;
}
template <class T> void minus(vector<T> &a, T v = 1) {
for (auto &&u : a)
u -= v;
}
inline bool inside(int y, int x, int H, int W) {
return y >= 0 && x >= 0 && y < H && x < W;
}
ll u(ll a) { return a < 0 ? 0 : a; }
#define inc(s, x, t) s <= x &&x < t
#define MIN(a) numeric_limits<a>::min()
#define MAX(a) numeric_limits<a>::max()
template <class T> T min(vector<vector<T>> &a) {
T res = MAX(T);
rep(i, a.size()) chmin(res, *min_element(all(a[i])));
return res;
}
template <class T> T max(vector<vector<T>> &a) {
T res = MIN(T);
rep(i, a.size()) chmax(res, *max_element(all(a[i])));
return res;
}
bool bget(ll m, int keta) { return (m >> keta) & 1; }
int bget(ll m, int keta, int sinsuu) {
m /= (ll)pow(sinsuu, keta);
return m % sinsuu;
}
inline ll bit(int n) { return (1LL << (n)); }
inline ll bit(int n, int sinsuu) { return (ll)pow(sinsuu, n); }
int bcou(ll m) {
return __builtin_popcount(m & 0xFFFFFFFF) + __builtin_popcount(m >> 32);
}
//初期化は0を渡す
ll nextComb(ll &mask, int n, int r) {
if (!mask)
return mask = (1LL << r) - 1;
ll x = mask & -mask; //最下位の1
ll y = mask + x; //連続した下の1を繰り上がらせる
ll res = ((mask & ~y) / x >> 1) | y;
if (bget(res, n))
return mask = 0;
else
return mask = res;
}
// n桁以下でビットがr個立っているもののvectorを返す
vl bitCombList(int n, int r) {
vl res;
int m = 0;
while (nextComb(m, n, r)) {
res.pb(m);
}
return res;
}
int ctoi(char c) {
if ('A' <= c && c <= 'Z')
return c - 'A';
return c - 'a' + 26;
}
char itoc(int i) {
if (i < 26)
return 'A' + i;
return 'a' + i - 26;
}
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
void compress(vi &a) {
vi b;
int len = a.size();
for (int i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
UNIQUE(b);
for (int i = 0; i < len; ++i) {
a[i] = lower_bound(all(b), a[i]) - b.begin();
}
}
void compress(int a[], int len) {
vi b;
for (int i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
UNIQUE(b);
for (int i = 0; i < len; ++i) {
a[i] = lower_bound(all(b), a[i]) - b.begin();
}
}
//要素が見つからなかったときに困る
#define lowerIndex(a, v) (lower_bound(a, v) - a.begin())
#define lowerBound(a, v) (*lower_bound(all(a), v))
#define upperIndex(a, v) (upper_bound(a, v) - a.begin())
#define upperBound(a, v) (*upper_bound(all(a), v))
#define ans(a) \
cout << a << endl; \
continue;
#define poll(a) \
q.front(); \
q.pop()
#define dpoll(a) \
q.front(); \
q.pop_front()
#define pollLast(a) \
q.back(); \
q.pop_back()
#define pollBack(a) \
q.back(); \
q.pop_back()
template <class T> inline void fin(T s) { cout << s << endl, exit(0); }
template <class T> struct edge {
int from, to;
T cost;
int id;
int type;
edge(int f, int t, T c = 1, int id = -1, int ty = -1)
: from(f), to(t), cost(c), id(id), type(ty) {}
bool operator<(const edge &b) const { return cost < b.cost; }
bool operator>(const edge &b) const { return cost > b.cost; }
};
template <typename T> class graph {
protected:
vector<bool> _used;
public:
vector<vector<edge<T>>> g;
vector<edge<T>> edges;
int n;
graph(int n) : n(n) {
g.resize(n);
_used.resize(n);
}
void clear() {
g.clear();
edges.clear();
}
void resize(int n) {
this->n = n;
g.resize(n);
_used.resize(n);
}
bool isleaf(int v, int r) { return g[v].size() == 1 && g[v][0].to == r; }
virtual void add(int from, int to, T cost, int ty) = 0;
virtual bool used(edge<T> &e) = 0;
virtual bool used(int id) = 0;
virtual void del(edge<T> &e) = 0;
virtual void del(int id) = 0;
};
template <class T = int> class undigraph : public graph<T> {
public:
using graph<T>::g;
using graph<T>::n;
using graph<T>::edges;
using graph<T>::_used;
undigraph(int n) : graph<T>(n) {}
void add(int f, int t, T cost = 1, int ty = -1) {
assert(0 <= f && f < n && 0 <= t && t < n);
int id = edges.size();
g[f].emplace_back(f, t, cost, id, ty);
g[t].emplace_back(t, f, cost, id + 1, ty);
edges.emplace_back(f, t, cost, id, ty);
edges.emplace_back(t, f, cost, id + 1, ty);
}
void add(edge<T> &e) {
int f = e.from, t = e.to, ty = e.type;
T cost = e.cost;
add(f, t, cost, ty);
}
bool used(edge<T> &e) { return _used[e.id]; }
bool used(int id) { return _used[id]; }
void del(edge<T> &e) { _used[e.id] = _used[e.id ^ 1] = 1; }
void del(int id) { _used[id] = _used[id ^ 1] = 1; }
};
template <typename T = ll> class digraph : public graph<T> {
public:
using graph<T>::g;
using graph<T>::n;
using graph<T>::edges;
using graph<T>::_used;
digraph(int n) : graph<T>(n) {}
void add(int f, int t, T cost = 1, int ty = -1) {
assert(0 <= f && f < n && 0 <= t && t < n);
int id = edges.size();
g[f].emplace_back(t, cost, ty, id);
edges.emplace_back(f, t, cost, ty, id);
}
bool used(edge<T> &e) { return _used[e.id]; }
bool used(int id) { return _used[id]; }
void del(edge<T> &e) { _used[e.id] = _used[e.id ^ 1] = 1; }
void del(int id) { _used[id] = _used[id ^ 1] = 1; }
};
template <class T> bool nibu(const graph<T> &g) {
UnionFind uf(g.n * 2);
for (auto &&e : g.edges)
uf.unite(e.f, e.t + g.n), uf.unite(e.f + g.n, e.t);
return !uf.same(0, g.n);
}
template <class T> vector<T> dijkstra(const graph<T> &g, int s) {
assert(inc(0, s, g.n));
T initValue = MAX(T);
vector<T> dis(g.n, initValue);
priority_queue<pair<T, int>, vector<pair<T, int>>, greater<pair<T, int>>> q;
dis[s] = 0;
q.emplace(0, s);
while (q.size()) {
T nowc = q.top().F;
int i = q.top().S;
q.pop();
if (dis[i] != nowc)
continue;
for (auto &&e : g.g[i]) {
int to = e.to;
T cost = nowc + e.cost;
if (dis[to] > cost) {
dis[to] = cost;
q.emplace(dis[to], to);
}
}
}
//たどり着かないなら-1
for (auto &&d : dis)
if (d == initValue)
d = -1;
return dis;
}
//機能拡張
template <typename T> void remove(vector<T> &v, unsigned int i) {
v.erase(v.begin() + i);
}
template <typename T>
void remove(vector<T> &v, unsigned int s, unsigned int e) {
v.erase(v.begin() + s, v.begin() + e);
}
template <typename T>
void removen(vector<T> &v, unsigned int s, unsigned int n) {
v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T> void erase(vector<T> &v, unsigned int i) {
v.erase(v.begin() + i);
}
template <typename T> void erase(vector<T> &v, unsigned int s, unsigned int e) {
v.erase(v.begin() + s, v.begin() + e);
}
template <typename T>
void erasen(vector<T> &v, unsigned int s, unsigned int n) {
v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T> void insert(vector<T> &v, unsigned int i, T t) {
v.insert(v.begin() + i, t);
}
template <typename T>
void insert(vector<T> &v, unsigned int i, vector<T> list) {
for (auto &&va : list)
v.insert(v.begin() + i++, va);
}
template <typename T>
void insert(vector<T> &v, unsigned int i, initializer_list<T> list) {
for (auto &&va : list)
v.insert(v.begin() + i++, va);
}
int mod(int a, int m) { return (a % m + m) % m; }
ll ma = numeric_limits<ll>::min();
ll mi = numeric_limits<ll>::max();
int N, K, M, H, W, q, Q, r, cou;
vi A, B, C;
signed main() {
cin >> N;
addAll(A, N);
rep(i, N) {
if (A[i] % 2)
cou++;
}
if (cou % 2)
cout << "first" << endl;
else
cout << "second" << endl;
return 0;
}
| // todo idef DEBUGで、境界チェック付きのvectorを作りたい
// http://marycore.jp/prog/cpp/class-extension-methods/
//現状ifdef DEBUG が何故か動かないので出来ない
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
struct initon {
initon() {
cin.tie(0);
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(16);
};
} hoee;
namespace std {
template <> class hash<std::pair<signed, signed>> {
public:
size_t operator()(const std::pair<signed, signed> &x) const {
return hash<ll>()(((ll)x.first << 32) + x.second);
}
};
template <> class hash<std::pair<ll, ll>> {
public:
size_t operator()(const std::pair<ll, ll> &x) const {
return hash<ll>()(((ll)x.first << 32) + x.second);
}
};
} // namespace std
//別名
#define ull unsigned long long
#define vec vector
#define con continue
#define bre break
#define brk break
#define is ==
#define eq ==
#define no !=
#define ne !=
#define dif !=
#define df !=
#define rs resize
#define PQ priority_queue<ll, vector<ll>, greater<ll>>
using vi = vector<int>;
#define vvi(a, b, c) vec<vi> a(b, vi(c))
using vb = vector<bool>;
#define vvb(a, b, c) vec<vb> a(b, vb(c))
using vs = vector<string>;
#define vvs(a, b, c) vec<vs> a(b, vs(c))
using vl = vector<ll>;
#define vvl(a, b, c) vec<vl> a(b, vl(c))
using vc = vector<char>;
#define vvc(a, b, c) vec<vc> a(b, vc(c))
using P = pair<int, int>;
using T = tuple<int, int, int>;
using vp = vector<P>;
#define vvp(a, b, c) vec<vp> a(b, vp(c))
using dou = double;
using itn = int;
using str = string;
using bo = bool;
#define uset unordered_set
#define umap unordered_map
#define F first
#define S second
//定数
#define k4 10101
#define k5 101010
#define k6 1010101
#define k7 10101010
const int INF = (int)1e9 + 100;
const ll LINF = (ll)1e18 + 100;
const double EPS = 1e-9;
const int y4[] = {-1, 1, 0, 0};
const int x4[] = {0, 0, -1, 1};
const int y8[] = {0, 1, 0, -1, -1, 1, 1, -1};
const int x8[] = {1, 0, -1, 0, 1, -1, 1, -1};
//配列
#define sz(a) (sizeof(a) / sizeof(a[0]))
//コンテナ
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
template <class T> inline void sort(vector<T> &a) { sort(a.begin(), a.end()); };
template <class T> inline void rsort(vector<T> &a) {
sort(a.begin(), a.end(), greater<T>());
};
template <class T> inline void sort(vector<T> &a, int len) {
sort(a.begin(), a.begin() + len);
};
template <class T> inline void rsort(vector<T> &a, int len) {
sort(a.begin(), a.begin() + len, greater<T>());
};
//繰り返し
#define _overloadrep(_1, _2, _3, name, ...) name
#define _rep(i, n) for (int i = 0; i < n; i++)
#define repi(i, m, n) for (int i = m; i < n; i++)
#define rep(...) _overloadrep(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define _rer(i, n) for (int i = n; i >= 0; i--)
#define reri(i, m, n) for (int i = m; i >= n; i--)
#define rer(...) _overloadrep(__VA_ARGS__, reri, _rer, )(__VA_ARGS__)
#define fora(a, b) for (auto &&a : b)
#define forr(a, b) for_each(map.rbegin(),map.rend(),[](auto&& a)
#define rea(a, b) for (auto &&a : b)
#define repa(a, b) for (auto &&a : b)
template <typename A, size_t N, typename T> void fill(A (&a)[N], const T &v) {
rep(i, N) a[i] = v;
}
template <typename A, size_t N, size_t O, typename T>
void fill(A (&a)[N][O], const T &v) {
rep(i, N) rep(j, O) a[i][j] = v;
}
template <typename A, size_t N, size_t O, size_t P, typename T>
void fill(A (&a)[N][O][P], const T &v) {
rep(i, N) rep(j, O) rep(k, P) a[i][j][k] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, typename T>
void fill(A (&a)[N][O][P][Q], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) a[i][j][k][l] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
typename T>
void fill(A (&a)[N][O][P][Q][R], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) a[i][j][k][l][m] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S, typename T>
void fill(A (&a)[N][O][P][Q][R][S], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) rep(n, S)
a[i][j][k][l][m][n] = v;
}
template <class T, class U> void fill(vector<T> &a, U v) {
rep(i, a.size()) a[i] = v;
}
template <class T, class U> void fill(vector<vector<T>> &a, U v) {
rep(i, a.size()) rep(j, a[0].size()) a[i][j] = v;
}
template <class T, class U> void fill(vector<vector<vector<T>>> &a, U v) {
rep(i, a.size()) rep(j, a[0].size()) rep(k, a[0][0].size()) a[i][j][k] = v;
}
#define arcpy(a, b) memcpy(a, b, sizeof(b))
//入力
template <typename T = int> T in() {
T x;
cin >> x;
return (x);
}
string sin() { return in<string>(); }
double din() { return in<double>(); }
ll lin() { return in<ll>(); }
#define na(a, n) rep(i, n) cin >> a[i];
#define nad(a, n) rep(i, n) cin >> a[i], a[i]--;
#define na3(a, b, c, n) rep(i, n) cin >> a[i] >> b[i] >> c[i];
#define add3(a, b, c, n) rep(i, n) a.pb(in()), b.pb(in()), c.pb(in());
#define na2(a, b, n) rep(i, n) cin >> a[i] >> b[i];
#define nt(a, h, w) rep(hi, h) rep(wi, w) cin >> a[hi][wi];
#define ntd(a, h, w) rep(hi, h) rep(wi, w) cin >> a[hi][wi], a[hi][wi]--;
#define ntp(a, h, w) \
fill(a, '#'); \
rep(hi, 1, h + 1) rep(wi, 1, w + 1) cin >> a[hi][wi];
#define addAll(a, n) rep(i, n) a.pb(in());
#define addAlld(a, n) rep(i, n) a.pb(in() - 1);
//出力
template <class T> void out(T x) {
if (typeid(x) == typeid(double))
cout << fixed << setprecision(10) << x << endl;
else
cout << x << endl;
}
//デバッグ
#define debug(x) \
cerr << x << " " \
<< "(L:" << __LINE__ << ")" << '\n';
// 境界チェック付きvector
namespace std_vector_bounds_checking {
using namespace std;
template <class T, class A = std::allocator<T>>
struct vector : std::vector<T, A> {
using std::vector<T, A>::vector;
typename std::vector<T>::reference
operator[](typename std::vector<T>::size_type n) {
return this->at(n);
}
};
} // namespace std_vector_bounds_checking
//よく使うクラス、構造体
class UnionFind {
public:
vi par, rank, sizes;
int n, trees;
UnionFind(int n) : n(n), trees(n) {
par.resize(n), rank.resize(n), sizes.resize(n);
rep(i, n) par[i] = i, sizes[i] = 1;
}
int root(int x) {
if (par[x] == x)
return x;
else
return par[x] = root(par[x]);
}
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (rank[x] < rank[y])
swap(x, y);
trees--;
par[y] = x;
sizes[x] += sizes[y];
if (rank[x] == rank[y])
rank[x]++;
}
bool same(int x, int y) { return root(x) == root(y); }
int size(int x) { return sizes[root(x)]; }
//順不同 umapなので
vec<vi> sets() {
vec<vi> res(trees);
umap<int, vi> map;
rep(i, n) map[root(i)].push_back(i);
int i = 0;
for (auto &&p : map) {
int r = p.F;
res[i].push_back(r);
for (auto &&v : p.S) {
if (r == v)
continue;
res[i].push_back(v);
}
i++;
}
return res;
}
};
// MOD関連
ll MOD = (int)1e9 + 7;
int mpow(int v, ll a) {
ll x = v, n = a, res = 1;
while (n) {
if (n & 1)
res = (res * x) % MOD;
x = (x * x) % MOD;
n >>= 1;
}
return res;
}
class mint {
private:
ll v;
public:
static ll mod(ll a) { return (a % MOD + MOD) % MOD; }
mint(ll a = 0) { this->v = mod(a); };
mint(const mint &a) { v = a.v; }
mint operator+(const mint &a) { return mint(v + a.v); }
mint operator+(const ll a) { return mint(v + a % MOD); }
mint operator+(const signed a) { return mint(v + a % MOD); }
friend mint operator+(const ll a, const mint &b) {
return mint(a % MOD + b.v);
}
void operator+=(const mint &a) { v = (v + a.v) % MOD; }
void operator+=(const ll a) { v = mod(v + a % MOD); }
void operator+=(const signed a) { v = mod(v + a % MOD); }
friend void operator+=(ll &a, const mint &b) { a = mod(a % MOD + b.v); }
mint operator-(const mint &a) { return mint(v - a.v); }
mint operator-(const ll a) { return mint(v - a % MOD); }
mint operator-(const signed a) { return mint(v - a % MOD); }
friend mint operator-(const ll a, const mint &b) {
return mint(a % MOD - b.v);
}
void operator-=(const mint &a) { v = mod(v - a.v); }
void operator-=(const ll a) { v = mod(v - a % MOD); }
void operator-=(const signed a) { v = mod(v - a % MOD); }
friend void operator-=(ll &a, const mint &b) { a = mod(a % MOD - b.v); }
mint operator*(const mint &a) { return mint(v * a.v); }
mint operator*(const ll a) { return mint(v * (a % MOD)); }
mint operator*(const signed a) { return mint(v * (a % MOD)); }
friend mint operator*(const ll a, const mint &b) {
return mint(a % MOD * b.v);
}
void operator*=(const mint &a) { v = (v * a.v) % MOD; }
void operator*=(const ll a) { v = mod(v * (a % MOD)); }
void operator*=(const signed a) { v = mod(v * (a % MOD)); }
friend void operator*=(ll &a, const mint &b) { a = mod(a % MOD * b.v); }
mint operator/(const mint &a);
mint operator/(const ll a);
mint operator/(const signed a);
friend mint operator/(const ll a, const mint &b);
void operator/=(const mint &a);
void operator/=(const ll a);
void operator/=(const signed a);
friend void operator/=(ll &a, const mint &b);
mint operator^(const mint &a) { return mpow(v, a.v); };
mint operator^(const ll a) { return mpow(v, a); };
mint operator^(const signed a) { return mpow(v, a); };
friend mint operator^(const ll a, const mint &b) { return mpow(a, b.v); };
void operator^=(const mint &a) { v = mpow(v, a.v); }
void operator^=(const ll a) { v = mpow(v, a); }
void operator^=(const signed a) { v = mpow(v, a); }
//単項演算子
mint operator+() { return *this; }
mint operator++() {
v++;
return *this;
}
mint operator++(signed d) {
mint res = *this;
v++;
return res;
}
mint operator-() { return operator*(-1); }
mint operator--() {
v++;
return *this;
}
void operator--(signed d) {
mint res = *this;
v++;
}
bool operator==(mint &a) { return v == a.v; }
bool operator==(signed a) { return v == a; }
friend bool operator==(signed a, mint &b) { return a == b.v; }
bool operator!=(mint &a) { return v != a.v; }
bool operator!=(signed a) { return v != a; }
friend bool operator!=(signed a, mint &b) { return a != b.v; }
operator int() { return v; }
};
const int setModMax = 510000;
mint fac[setModMax], finv[setModMax], inv[setModMax];
void setMod() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < setModMax; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
mint minv(ll a) {
if (fac[0] == 0)
setMod();
if (a < setModMax)
return inv[a];
a %= MOD;
ll b = MOD, x = 1, y = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
x -= t * y;
swap(x, y);
}
return (x % MOD + MOD) % MOD;
}
mint mint::operator/(const mint &a) { return mint(v * minv(a.v)); }
mint mint::operator/(const ll a) { return mint(v * minv(a)); }
mint mint::operator/(const signed a) { return mint(v * minv(a)); }
mint operator/(const ll a, const mint &b) { return mint(a % MOD * minv(b.v)); }
void mint::operator/=(const mint &a) { v = (v * minv(a.v)) % MOD; }
void mint::operator/=(const ll a) { v = mod(v * minv(a)); }
void mint::operator/=(const signed a) { v = mod(v * minv(a)); }
void operator/=(ll &a, const mint &b) { a = mint::mod(a % MOD * minv(b.v)); }
using vm = vector<mint>;
#define vvm(a, b, c) vec<vm> a(b, vm(c))
bool isPrime[4010101];
vi primes;
void setPrime() {
fill(isPrime, true);
isPrime[0] = isPrime[1] = false;
for (int i = 2; i <= sqrt(sz(isPrime)) + 5; ++i) {
if (!isPrime[i])
continue;
for (int j = 2; i * j < sz(isPrime); ++j) {
isPrime[i * j] = false;
}
}
rep(i, sz(isPrime)) if (isPrime[i]) primes.pb(i);
}
mint com(ll n, ll r) {
if (n < r || n < 0 || r < 0)
return 0;
if (fac[0] == 0)
setMod();
return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD;
}
//便利関数
bool equal(double a, double b) { return fabs(a - b) < EPS; }
ll reverse(ll a) {
ll res = 0;
while (a) {
res *= 10;
res += a % 10;
a /= 10;
}
return res;
}
ll ceil(ll a, ll b) { return (a + b - 1) / b; }
ll sqrt(ll a) {
ll res = (ll)sqrt(a);
while (res * res < a)
res++;
return res;
}
ll sig(ll t) { return (1 + t) * t / 2; }
ll sig(ll s, ll t) { return (s + t) * (t - s + 1) / 2; }
vi divisors(int v) {
vi res;
for (int i = 1; i <= sqrt(v); ++i) {
if (v % i == 0) {
res.pb(i);
if (i != v / i)
res.pb(v / i);
}
}
return res;
}
vi factorization(int v) {
int tv = v;
vi res;
if (!isPrime[2])
setPrime();
for (auto &&p : primes) {
if (v % p == 0)
res.push_back(p);
while (v % p == 0) {
v /= p;
}
if (v == 1 || p * p > tv)
break;
}
if (v > 1)
res.pb(v);
return res;
}
unordered_map<int, int> factorizationMap(int v) {
int tv = v;
unordered_map<int, int> res;
if (!isPrime[2])
setPrime();
for (auto &&p : primes) {
while (v % p == 0) {
res[p]++;
v /= p;
}
if (v == 1 || p * p > tv)
break;
}
if (v > 1)
res[v]++;
return res;
}
int get(int a, int keta) {
a /= (int)pow(10, keta);
return a % 10;
}
//変換系
template <class T, class U> vector<U> keys(map<T, U> a) {
vector<U> res;
for (auto &&k : a)
res.pb(k.F);
return res;
}
template <class T, class U> vector<U> keys(umap<T, U> a) {
vector<U> res;
for (auto &&k : a)
res.pb(k.F);
return res;
}
template <class T, class U> vector<T> values(map<T, U> a) {
vector<T> res;
for (auto &&k : a)
res.pb(k.S);
return res;
}
template <class T, class U> vector<T> values(umap<T, U> a) {
vector<T> res;
for (auto &&k : a)
res.pb(k.S);
return res;
}
vi list(int a) {
vi res;
while (a) {
res.insert(res.begin(), a % 10);
a /= 10;
}
return res;
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <class T> T min(T a, signed b) { return a < b ? a : b; }
template <class T> T max(T a, signed b) { return a < b ? b : a; }
template <class T> T sum(vector<T> &v, int len = -1) {
if (len == -1)
len = v.size();
T res = 0;
rep(i, min((int)len, (int)v.size())) res += v[i];
return res;
}
///要素が0の時、返り値は0か1か
template <class T> T mul(vector<T> &v, int len = -1) {
if (len == -1)
len = v.size();
T res = 1;
rep(i, min((int)len, (int)v.size())) res *= v[i];
return res;
}
void clear(PQ &q) {
while (q.size())
q.pop();
}
template <class T> void clear(queue<T> &q) {
while (q.size())
q.pop();
}
template <class T> vector<T> ruiv(vector<T> &a) {
vector<T> res(a.size() + 1);
rep(i, a.size()) res[i + 1] = res[i] + a[i];
return res;
}
template <class T> void plus(vector<T> &a, T v = 1) {
for (auto &&u : a)
u += v;
}
template <class T> void minu(vector<T> &a, T v = 1) {
for (auto &&u : a)
u -= v;
}
template <class T> void minus(vector<T> &a, T v = 1) {
for (auto &&u : a)
u -= v;
}
inline bool inside(int y, int x, int H, int W) {
return y >= 0 && x >= 0 && y < H && x < W;
}
ll u(ll a) { return a < 0 ? 0 : a; }
#define inc(s, x, t) s <= x &&x < t
#define MIN(a) numeric_limits<a>::min()
#define MAX(a) numeric_limits<a>::max()
template <class T> T min(vector<vector<T>> &a) {
T res = MAX(T);
rep(i, a.size()) chmin(res, *min_element(all(a[i])));
return res;
}
template <class T> T max(vector<vector<T>> &a) {
T res = MIN(T);
rep(i, a.size()) chmax(res, *max_element(all(a[i])));
return res;
}
bool bget(ll m, int keta) { return (m >> keta) & 1; }
int bget(ll m, int keta, int sinsuu) {
m /= (ll)pow(sinsuu, keta);
return m % sinsuu;
}
inline ll bit(int n) { return (1LL << (n)); }
inline ll bit(int n, int sinsuu) { return (ll)pow(sinsuu, n); }
int bcou(ll m) {
return __builtin_popcount(m & 0xFFFFFFFF) + __builtin_popcount(m >> 32);
}
//初期化は0を渡す
ll nextComb(ll &mask, int n, int r) {
if (!mask)
return mask = (1LL << r) - 1;
ll x = mask & -mask; //最下位の1
ll y = mask + x; //連続した下の1を繰り上がらせる
ll res = ((mask & ~y) / x >> 1) | y;
if (bget(res, n))
return mask = 0;
else
return mask = res;
}
// n桁以下でビットがr個立っているもののvectorを返す
vl bitCombList(int n, int r) {
vl res;
int m = 0;
while (nextComb(m, n, r)) {
res.pb(m);
}
return res;
}
int ctoi(char c) {
if ('A' <= c && c <= 'Z')
return c - 'A';
return c - 'a' + 26;
}
char itoc(int i) {
if (i < 26)
return 'A' + i;
return 'a' + i - 26;
}
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
void compress(vi &a) {
vi b;
int len = a.size();
for (int i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
UNIQUE(b);
for (int i = 0; i < len; ++i) {
a[i] = lower_bound(all(b), a[i]) - b.begin();
}
}
void compress(int a[], int len) {
vi b;
for (int i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
UNIQUE(b);
for (int i = 0; i < len; ++i) {
a[i] = lower_bound(all(b), a[i]) - b.begin();
}
}
//要素が見つからなかったときに困る
#define lowerIndex(a, v) (lower_bound(a, v) - a.begin())
#define lowerBound(a, v) (*lower_bound(all(a), v))
#define upperIndex(a, v) (upper_bound(a, v) - a.begin())
#define upperBound(a, v) (*upper_bound(all(a), v))
#define ans(a) \
cout << a << endl; \
continue;
#define poll(a) \
q.front(); \
q.pop()
#define dpoll(a) \
q.front(); \
q.pop_front()
#define pollLast(a) \
q.back(); \
q.pop_back()
#define pollBack(a) \
q.back(); \
q.pop_back()
template <class T> inline void fin(T s) { cout << s << endl, exit(0); }
template <class T> struct edge {
int from, to;
T cost;
int id;
int type;
edge(int f, int t, T c = 1, int id = -1, int ty = -1)
: from(f), to(t), cost(c), id(id), type(ty) {}
bool operator<(const edge &b) const { return cost < b.cost; }
bool operator>(const edge &b) const { return cost > b.cost; }
};
template <typename T> class graph {
protected:
vector<bool> _used;
public:
vector<vector<edge<T>>> g;
vector<edge<T>> edges;
int n;
graph(int n) : n(n) {
g.resize(n);
_used.resize(n);
}
void clear() {
g.clear();
edges.clear();
}
void resize(int n) {
this->n = n;
g.resize(n);
_used.resize(n);
}
bool isleaf(int v, int r) { return g[v].size() == 1 && g[v][0].to == r; }
virtual void add(int from, int to, T cost, int ty) = 0;
virtual bool used(edge<T> &e) = 0;
virtual bool used(int id) = 0;
virtual void del(edge<T> &e) = 0;
virtual void del(int id) = 0;
};
template <class T = int> class undigraph : public graph<T> {
public:
using graph<T>::g;
using graph<T>::n;
using graph<T>::edges;
using graph<T>::_used;
undigraph(int n) : graph<T>(n) {}
void add(int f, int t, T cost = 1, int ty = -1) {
assert(0 <= f && f < n && 0 <= t && t < n);
int id = edges.size();
g[f].emplace_back(f, t, cost, id, ty);
g[t].emplace_back(t, f, cost, id + 1, ty);
edges.emplace_back(f, t, cost, id, ty);
edges.emplace_back(t, f, cost, id + 1, ty);
}
void add(edge<T> &e) {
int f = e.from, t = e.to, ty = e.type;
T cost = e.cost;
add(f, t, cost, ty);
}
bool used(edge<T> &e) { return _used[e.id]; }
bool used(int id) { return _used[id]; }
void del(edge<T> &e) { _used[e.id] = _used[e.id ^ 1] = 1; }
void del(int id) { _used[id] = _used[id ^ 1] = 1; }
};
template <typename T = ll> class digraph : public graph<T> {
public:
using graph<T>::g;
using graph<T>::n;
using graph<T>::edges;
using graph<T>::_used;
digraph(int n) : graph<T>(n) {}
void add(int f, int t, T cost = 1, int ty = -1) {
assert(0 <= f && f < n && 0 <= t && t < n);
int id = edges.size();
g[f].emplace_back(t, cost, ty, id);
edges.emplace_back(f, t, cost, ty, id);
}
bool used(edge<T> &e) { return _used[e.id]; }
bool used(int id) { return _used[id]; }
void del(edge<T> &e) { _used[e.id] = _used[e.id ^ 1] = 1; }
void del(int id) { _used[id] = _used[id ^ 1] = 1; }
};
template <class T> bool nibu(const graph<T> &g) {
UnionFind uf(g.n * 2);
for (auto &&e : g.edges)
uf.unite(e.f, e.t + g.n), uf.unite(e.f + g.n, e.t);
return !uf.same(0, g.n);
}
template <class T> vector<T> dijkstra(const graph<T> &g, int s) {
assert(inc(0, s, g.n));
T initValue = MAX(T);
vector<T> dis(g.n, initValue);
priority_queue<pair<T, int>, vector<pair<T, int>>, greater<pair<T, int>>> q;
dis[s] = 0;
q.emplace(0, s);
while (q.size()) {
T nowc = q.top().F;
int i = q.top().S;
q.pop();
if (dis[i] != nowc)
continue;
for (auto &&e : g.g[i]) {
int to = e.to;
T cost = nowc + e.cost;
if (dis[to] > cost) {
dis[to] = cost;
q.emplace(dis[to], to);
}
}
}
//たどり着かないなら-1
for (auto &&d : dis)
if (d == initValue)
d = -1;
return dis;
}
//機能拡張
template <typename T> void remove(vector<T> &v, unsigned int i) {
v.erase(v.begin() + i);
}
template <typename T>
void remove(vector<T> &v, unsigned int s, unsigned int e) {
v.erase(v.begin() + s, v.begin() + e);
}
template <typename T>
void removen(vector<T> &v, unsigned int s, unsigned int n) {
v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T> void erase(vector<T> &v, unsigned int i) {
v.erase(v.begin() + i);
}
template <typename T> void erase(vector<T> &v, unsigned int s, unsigned int e) {
v.erase(v.begin() + s, v.begin() + e);
}
template <typename T>
void erasen(vector<T> &v, unsigned int s, unsigned int n) {
v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T> void insert(vector<T> &v, unsigned int i, T t) {
v.insert(v.begin() + i, t);
}
template <typename T>
void insert(vector<T> &v, unsigned int i, vector<T> list) {
for (auto &&va : list)
v.insert(v.begin() + i++, va);
}
template <typename T>
void insert(vector<T> &v, unsigned int i, initializer_list<T> list) {
for (auto &&va : list)
v.insert(v.begin() + i++, va);
}
int mod(int a, int m) { return (a % m + m) % m; }
ll ma = numeric_limits<ll>::min();
ll mi = numeric_limits<ll>::max();
int N, K, M, H, W, q, Q, r, cou;
vi A, B, C;
signed main() {
cin >> N;
addAll(A, N);
int cou1;
rep(i, N) {
if (A[i] % 2)
cou++;
// if (A[i] == 1)cou1++;
}
if (cou)
cout << "first" << endl;
else
cout << "second" << endl;
// if (cou1 >= 2)cout << "first" << endl;
// else if (cou % 2)cout << "first" << endl;
// else if ()cout << "first" << endl;;
// else cout << "second" << endl;
// firstなのにsecondとされてるものがある
return 0;
}
| [
"variable_declaration.add",
"expression.operation.binary.remove"
] | 991,480 | 991,481 | u986437843 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
bool f = false;
for (int i = 0; i < n; i++) {
int64_t a;
cin >> a;
f |= a % 2 == 0;
}
cout << (f ? "first" : "second") << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
bool f = false;
for (int i = 0; i < n; i++) {
int64_t a;
cin >> a;
f |= a % 2 == 1;
}
cout << (f ? "first" : "second") << endl;
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 991,484 | 991,485 | u017167684 | cpp |
p03197 | #include <bits/stdc++.h>
// g++ -std=c++11 -Wall -g -fsanitize=undefined -D_GLIBCXX_DEBUG caddi/d.cpp
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define SZ(x) ((int)(x).size())
#define scint(x) scanf("%d", &x)
#define scll(x) scanf("%lld", &x)
typedef long long ll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false); //おまじないでcin, cout早くする
int N;
vector<int> v(N);
int flag = 0;
rep(i, N) {
int k;
cin >> k;
if (k % 2 != 0) {
flag = 1;
break;
}
}
if (flag) {
cout << "first"
<< "\n";
} else {
cout << "second"
<< "\n";
}
return 0;
} | #include <bits/stdc++.h>
// g++ -std=c++11 -Wall -g -fsanitize=undefined -D_GLIBCXX_DEBUG caddi/d.cpp
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define SZ(x) ((int)(x).size())
#define scint(x) scanf("%d", &x)
#define scll(x) scanf("%lld", &x)
typedef long long ll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false); //おまじないでcin, cout早くする
int N;
// vector<int> v(N);
cin >> N;
int flag = 0;
rep(i, N) {
int k;
cin >> k;
if (k % 2 != 0) {
flag = 1;
break;
}
}
if (flag) {
cout << "first"
<< "\n";
} else {
cout << "second"
<< "\n";
}
return 0;
} | [
"variable_declaration.remove"
] | 991,486 | 991,487 | u811561461 | cpp |
p03197 |
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define fbo find_by_order
#define ook order_of_key
#define INF 1e18
#define ret return
typedef long long ll;
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<pair<int, int>> vii;
typedef long double ld;
typedef tree<pair<int, int>, null_type, less<pair<int, int>>, rb_tree_tag,
tree_order_statistics_node_update>
pbds;
typedef set<int>::iterator sit;
typedef map<int, int>::iterator mit;
typedef vector<int>::iterator vit;
int main() {
ll n;
cin >> n;
ll a = 0;
ll x;
for (int i = 0; i < n; i++) {
cin >> x;
x %= n;
a ^= x;
}
if (a % 2) {
cout << "first\n";
} else {
cout << "second\n";
}
return 0;
}
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define fbo find_by_order
#define ook order_of_key
#define INF 1e18
#define ret return
typedef long long ll;
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<pair<int, int>> vii;
typedef long double ld;
typedef tree<pair<int, int>, null_type, less<pair<int, int>>, rb_tree_tag,
tree_order_statistics_node_update>
pbds;
typedef set<int>::iterator sit;
typedef map<int, int>::iterator mit;
typedef vector<int>::iterator vit;
int main() {
ll n;
cin >> n;
ll a = 0;
ll x;
for (int i = 0; i < n; i++) {
cin >> x;
a |= x;
}
if (a % 2) {
cout << "first\n";
} else {
cout << "second\n";
}
return 0;
}
| [
"expression.operator.change"
] | 991,488 | 991,489 | u288466617 | cpp |
p03197 |
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define fbo find_by_order
#define ook order_of_key
#define INF 1e18
#define ret return
typedef long long ll;
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<pair<int, int>> vii;
typedef long double ld;
typedef tree<pair<int, int>, null_type, less<pair<int, int>>, rb_tree_tag,
tree_order_statistics_node_update>
pbds;
typedef set<int>::iterator sit;
typedef map<int, int>::iterator mit;
typedef vector<int>::iterator vit;
int main() {
int n;
cin >> n;
ll a = 0;
ll x;
for (int i = 0; i < n; i++) {
cin >> x;
a ^= x;
}
if (a % 2) {
cout << "first\n";
} else {
cout << "second\n";
}
return 0;
}
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define fbo find_by_order
#define ook order_of_key
#define INF 1e18
#define ret return
typedef long long ll;
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<pair<int, int>> vii;
typedef long double ld;
typedef tree<pair<int, int>, null_type, less<pair<int, int>>, rb_tree_tag,
tree_order_statistics_node_update>
pbds;
typedef set<int>::iterator sit;
typedef map<int, int>::iterator mit;
typedef vector<int>::iterator vit;
int main() {
ll n;
cin >> n;
ll a = 0;
ll x;
for (int i = 0; i < n; i++) {
cin >> x;
a |= x;
}
if (a % 2) {
cout << "first\n";
} else {
cout << "second\n";
}
return 0;
}
| [
"variable_declaration.type.change",
"expression.operator.change"
] | 991,490 | 991,489 | u288466617 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define ALL(A) A.begin(), A.end()
#define RALL(A) A.rbegin(), A.rend()
typedef long long LL;
typedef pair<int, int> P;
const LL mod = 1000000007;
const LL LINF = 1LL << 62;
const LL INF = 1 << 17;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (a % 2) {
puts("Second");
return 0;
}
}
puts("First");
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define ALL(A) A.begin(), A.end()
#define RALL(A) A.rbegin(), A.rend()
typedef long long LL;
typedef pair<int, int> P;
const LL mod = 1000000007;
const LL LINF = 1LL << 62;
const LL INF = 1 << 17;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (a % 2) {
puts("first");
return 0;
}
}
puts("second");
return 0;
}
| [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 991,493 | 991,494 | u640323045 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define ALL(A) A.begin(), A.end()
#define RALL(A) A.rbegin(), A.rend()
typedef long long LL;
typedef pair<int, int> P;
const LL mod = 1000000007;
const LL LINF = 1LL << 62;
const LL INF = 1 << 17;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (a % 2) {
puts("First");
return 0;
}
}
puts("Second");
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define ALL(A) A.begin(), A.end()
#define RALL(A) A.rbegin(), A.rend()
typedef long long LL;
typedef pair<int, int> P;
const LL mod = 1000000007;
const LL LINF = 1LL << 62;
const LL INF = 1 << 17;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (a % 2) {
puts("first");
return 0;
}
}
puts("second");
return 0;
}
| [
"literal.string.change",
"literal.string.case.change",
"call.arguments.change",
"io.output.change"
] | 991,495 | 991,494 | u640323045 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
using ll = long long;
#define REP(i, n) for (ll i = 0; i < n; i++)
#define REPR(i, n) for (ll i = n; i >= 0; i--)
#define FOR(i, m, n) for (ll i = m; i < n; i++)
#define pb push_back
#define fill(x, y) memset(x, y, sizeof(x))
#define even(x) x % 2 == 0
#define odd(x) x % 2 != 0
#define all(x) x.begin(), x.end()
#define pcnt __builtin_popcount
#define buli(x) __builtin_popcountll(x)
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define IN1(type, x) \
type x; \
cin >> x;
#define inll(x) \
ll x; \
cin >> x;
// these functions return the position of result of Binary Search.
#define LB(s, t, x) (int)(lower_bound(s, t, x) - s)
#define UB(s, t, x) (int)(upper_bound(s, t, x) - s)
ll qp(ll a, ll b, int mo) {
ll ans = 1;
do {
if (b & 1)
ans = 1ll * ans * a % mo;
a = 1ll * a * a % mo;
} while (b >>= 1);
return ans;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) {
ll temp = gcd(a, b);
return temp ? (a / temp * b) : 0;
}
int mDays[] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int dx8[] = {1, -1, 0, 0, 1, 1, -1, -1}, dy8[] = {0, 0, -1, 1, -1, 1, -1, 1};
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts>
auto make_v(size_t a, size_t b, Ts... ts) {
return vector<decltype(make_v<T>(b, ts...))>(a, make_v<T>(b, ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
// auto dp = make_v<int>(4, h, w);
// fill_v(dp, 0);
const ll INF_LL = (1ll << 60);
const int INF_INT = (int)1e9;
const ll MOD_CONST = (ll)(1e9 + 7);
template <typename T> vector<T> pows(int b, int n) {
vector<T> ret;
T x = 1;
while (ret.size() < n) {
ret.push_back(x);
x *= b;
}
return ret;
}
// find string "from" in "str", and replace them to "to"
void strReplace(std::string &str, const std::string &from,
const std::string &to) {
std::string::size_type pos = 0;
while (pos = str.find(from, pos), pos != std::string::npos) {
str.replace(pos, from.length(), to);
pos += to.length();
}
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
inline tuple<ll, ll> rotate45(tuple<ll, ll> point) {
ll x = get<0>(point), y = get<1>(point);
return tuple<ll, ll>(x + y, x - y);
}
inline bool rangeCheck2D(int nx, int ny, int Width, int Height) {
return nx >= 0 and nx < Width and ny >= 0 and ny < Height;
}
template <typename T> vector<T> INPA(ll n) {
vector<T> x;
REP(i, n) {
T tmp;
cin >> tmp;
x.push_back(tmp);
}
return move(x);
}
template <typename T> void out(T o) { cout << o << endl; }
template <typename T> void out(vector<T> &out) {
REP(i, (int)out.size()) {
cout << out[i];
if (i == (int)out.size() - 1)
cout << endl;
else
cout << " ";
}
}
template <typename T> void out(vector<vector<T>> o) {
REP(i, o.size()) out(o[i]);
}
void YesNo(bool f) { cout << (f ? "Yes" : "No") << endl; }
void YESNO(bool f) { cout << (f ? "YES" : "NO") << endl; }
// use " for (const auto& e : V)
string longestCommonPrefix(vector<string> &strs) {
int n = INT_MAX;
if (strs.size() <= 0) {
return "";
}
if (strs.size() == 1) {
return strs[0];
}
// get the min length
for (int i = 0; i < strs.size(); i++) {
n = strs[i].length() < n ? strs[i].length() : n;
}
for (int i = 0; i < n; i++) { // check each character
for (int j = 1; j < strs.size(); j++) {
if (strs[j][i] != strs[j - 1][i]) { // we find a mis-match
return strs[0].substr(0, i);
}
}
}
// prefix is n-length
return strs[0].substr(0, n);
}
ll p_base(ll base, ll x) {
ll ans = 1;
REP(i, x) {
ans *= base;
ans %= MOD_CONST;
}
return ans;
}
class ListG {
public:
// there's directed edge between A and B
// if to[A] has element B
vector<vector<int>> to;
map<pair<int, int>, ll> cost;
void setCost(int u, int v, ll c) { cost[{min(u, v), max(u, v)}] = c; }
ll getCost(int u, int v) { return cost[{min(u, v), max(u, v)}]; }
ListG(int s) : root(-1) {
size = s;
to = make_v<vector<int>>(size);
}
void setDirectedEdge(int f, int t) { to[f].push_back(t); }
void setIndirectedEdge(int v1, int v2) {
setDirectedEdge(v1, v2);
setDirectedEdge(v2, v1);
}
void dfs(int x) {
// do something
}
void makeTree(int r) {
root = r;
p = make_v<int>(size);
p[root] = -1;
depth = make_v<int>(size);
mtdfs(root, 0);
// count leaf node
auto idxs = make_v<int>(size);
iota(all(idxs), 0);
leaf_idx = set<int>(all(idxs));
FOR(i, 1, size)
leaf_idx.erase(p[i]);
}
void makeEulerTour() {
assert(root >= 0);
et_begin = make_v<int>(size);
et_end = make_v<int>(size);
tmp_k = 0;
etdfs(root, -1);
}
int size, root;
vector<int> p; // parent for each node. parent of root = -1
vector<int> depth; // for each node. depth of root node = 0
vector<int> euler_tour;
vector<int> et_begin, et_end;
set<int> leaf_idx;
int tmp_k;
private:
void mtdfs(int c, int d) {
depth[c] = d;
REP(i, to[c].size()) {
int next = to[c][i];
if (p[c] == next)
continue;
p[next] = c;
mtdfs(next, d + 1);
}
}
void etdfs(int vidx, int pidx) {
et_begin[vidx] = tmp_k;
euler_tour.push_back(vidx);
tmp_k++;
REP(i, to[vidx].size()) {
if (to[vidx][i] != pidx) {
etdfs(to[vidx][i], vidx);
euler_tour.push_back(vidx);
tmp_k++;
}
}
et_end[vidx] = tmp_k;
}
};
template <typename T> class BinaryIndexedTree {
public:
int size;
vector<T> data;
BinaryIndexedTree(int s, T initial_value = T(0)) {
size = s;
data = make_v<T>(size + 1);
fill_v(data, initial_value);
}
void add(int idx, T value) {
while (idx <= size) {
data[idx] += value;
idx += idx & -idx;
}
}
T sum(int idx) {
T s = 0;
while (idx > 0) {
s += data[idx];
idx -= idx & -idx;
}
return s;
}
};
// lambda auto f = [](int arg1, double arg2) { return ret; };
namespace PrimeLib {
//* 素数判定 is_prime<unsigned>(N)
template <typename T, std::enable_if_t<std::is_unsigned<T>::value,
std::nullptr_t> = nullptr>
bool is_prime(const T n) {
if (n < 4)
return n == 2 || n == 3;
if (n % 2 == 0 || n % 3 == 0 || (n % 6 != 1 && n % 6 != 5))
return false;
for (T i = 5; i * i <= n; i += 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
//* 素数テーブル生成 エラトステネスの篩 10^7 => 1s
//* 1e9を素因数分解したい時，sqrt(1e9)まで(31623程)を生成すればよい
vector<ll> primeTable(ll n) {
vector<bool> table(n - 1);
vector<ll> ret;
for (ll i = 0; i < n - 1; ++i) {
if (table[i] == false) {
ll num = i + 2;
ret.push_back(i + 2);
for (int j = i + num; j < n - 1; j += num)
table[j] = true;
}
}
return ret;
}
vector<ll> factorize(ll n, vector<ll> &pt) {
vector<ll> ret;
int pos = 0;
ll c = n;
while (c != 1) {
ll p = pt[pos];
ret.push_back(0);
while (c % p == 0) {
ret[pos]++;
c /= p;
}
pos++;
if (pos >= pt.size())
break;
}
// assert(c == 1);
// if c is still not 1,
// there's one prime num bigger than sqrt(N)
if (c != 1)
ret.push_back(1);
return ret;
}
} // namespace PrimeLib
int main(void) {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
inll(N);
auto a = INPA<ll>(N);
sort(a.rbegin(), a.rend());
ll sum = 0; // a[0];
REP(i, N) if (odd(a[i])) sum++;
if (odd(sum))
out("first");
else
out("second");
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
using ll = long long;
#define REP(i, n) for (ll i = 0; i < n; i++)
#define REPR(i, n) for (ll i = n; i >= 0; i--)
#define FOR(i, m, n) for (ll i = m; i < n; i++)
#define pb push_back
#define fill(x, y) memset(x, y, sizeof(x))
#define even(x) x % 2 == 0
#define odd(x) x % 2 != 0
#define all(x) x.begin(), x.end()
#define pcnt __builtin_popcount
#define buli(x) __builtin_popcountll(x)
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define IN1(type, x) \
type x; \
cin >> x;
#define inll(x) \
ll x; \
cin >> x;
// these functions return the position of result of Binary Search.
#define LB(s, t, x) (int)(lower_bound(s, t, x) - s)
#define UB(s, t, x) (int)(upper_bound(s, t, x) - s)
ll qp(ll a, ll b, int mo) {
ll ans = 1;
do {
if (b & 1)
ans = 1ll * ans * a % mo;
a = 1ll * a * a % mo;
} while (b >>= 1);
return ans;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) {
ll temp = gcd(a, b);
return temp ? (a / temp * b) : 0;
}
int mDays[] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int dx8[] = {1, -1, 0, 0, 1, 1, -1, -1}, dy8[] = {0, 0, -1, 1, -1, 1, -1, 1};
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts>
auto make_v(size_t a, size_t b, Ts... ts) {
return vector<decltype(make_v<T>(b, ts...))>(a, make_v<T>(b, ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
// auto dp = make_v<int>(4, h, w);
// fill_v(dp, 0);
const ll INF_LL = (1ll << 60);
const int INF_INT = (int)1e9;
const ll MOD_CONST = (ll)(1e9 + 7);
template <typename T> vector<T> pows(int b, int n) {
vector<T> ret;
T x = 1;
while (ret.size() < n) {
ret.push_back(x);
x *= b;
}
return ret;
}
// find string "from" in "str", and replace them to "to"
void strReplace(std::string &str, const std::string &from,
const std::string &to) {
std::string::size_type pos = 0;
while (pos = str.find(from, pos), pos != std::string::npos) {
str.replace(pos, from.length(), to);
pos += to.length();
}
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
inline tuple<ll, ll> rotate45(tuple<ll, ll> point) {
ll x = get<0>(point), y = get<1>(point);
return tuple<ll, ll>(x + y, x - y);
}
inline bool rangeCheck2D(int nx, int ny, int Width, int Height) {
return nx >= 0 and nx < Width and ny >= 0 and ny < Height;
}
template <typename T> vector<T> INPA(ll n) {
vector<T> x;
REP(i, n) {
T tmp;
cin >> tmp;
x.push_back(tmp);
}
return move(x);
}
template <typename T> void out(T o) { cout << o << endl; }
template <typename T> void out(vector<T> &out) {
REP(i, (int)out.size()) {
cout << out[i];
if (i == (int)out.size() - 1)
cout << endl;
else
cout << " ";
}
}
template <typename T> void out(vector<vector<T>> o) {
REP(i, o.size()) out(o[i]);
}
void YesNo(bool f) { cout << (f ? "Yes" : "No") << endl; }
void YESNO(bool f) { cout << (f ? "YES" : "NO") << endl; }
// use " for (const auto& e : V)
string longestCommonPrefix(vector<string> &strs) {
int n = INT_MAX;
if (strs.size() <= 0) {
return "";
}
if (strs.size() == 1) {
return strs[0];
}
// get the min length
for (int i = 0; i < strs.size(); i++) {
n = strs[i].length() < n ? strs[i].length() : n;
}
for (int i = 0; i < n; i++) { // check each character
for (int j = 1; j < strs.size(); j++) {
if (strs[j][i] != strs[j - 1][i]) { // we find a mis-match
return strs[0].substr(0, i);
}
}
}
// prefix is n-length
return strs[0].substr(0, n);
}
ll p_base(ll base, ll x) {
ll ans = 1;
REP(i, x) {
ans *= base;
ans %= MOD_CONST;
}
return ans;
}
class ListG {
public:
// there's directed edge between A and B
// if to[A] has element B
vector<vector<int>> to;
map<pair<int, int>, ll> cost;
void setCost(int u, int v, ll c) { cost[{min(u, v), max(u, v)}] = c; }
ll getCost(int u, int v) { return cost[{min(u, v), max(u, v)}]; }
ListG(int s) : root(-1) {
size = s;
to = make_v<vector<int>>(size);
}
void setDirectedEdge(int f, int t) { to[f].push_back(t); }
void setIndirectedEdge(int v1, int v2) {
setDirectedEdge(v1, v2);
setDirectedEdge(v2, v1);
}
void dfs(int x) {
// do something
}
void makeTree(int r) {
root = r;
p = make_v<int>(size);
p[root] = -1;
depth = make_v<int>(size);
mtdfs(root, 0);
// count leaf node
auto idxs = make_v<int>(size);
iota(all(idxs), 0);
leaf_idx = set<int>(all(idxs));
FOR(i, 1, size)
leaf_idx.erase(p[i]);
}
void makeEulerTour() {
assert(root >= 0);
et_begin = make_v<int>(size);
et_end = make_v<int>(size);
tmp_k = 0;
etdfs(root, -1);
}
int size, root;
vector<int> p; // parent for each node. parent of root = -1
vector<int> depth; // for each node. depth of root node = 0
vector<int> euler_tour;
vector<int> et_begin, et_end;
set<int> leaf_idx;
int tmp_k;
private:
void mtdfs(int c, int d) {
depth[c] = d;
REP(i, to[c].size()) {
int next = to[c][i];
if (p[c] == next)
continue;
p[next] = c;
mtdfs(next, d + 1);
}
}
void etdfs(int vidx, int pidx) {
et_begin[vidx] = tmp_k;
euler_tour.push_back(vidx);
tmp_k++;
REP(i, to[vidx].size()) {
if (to[vidx][i] != pidx) {
etdfs(to[vidx][i], vidx);
euler_tour.push_back(vidx);
tmp_k++;
}
}
et_end[vidx] = tmp_k;
}
};
template <typename T> class BinaryIndexedTree {
public:
int size;
vector<T> data;
BinaryIndexedTree(int s, T initial_value = T(0)) {
size = s;
data = make_v<T>(size + 1);
fill_v(data, initial_value);
}
void add(int idx, T value) {
while (idx <= size) {
data[idx] += value;
idx += idx & -idx;
}
}
T sum(int idx) {
T s = 0;
while (idx > 0) {
s += data[idx];
idx -= idx & -idx;
}
return s;
}
};
// lambda auto f = [](int arg1, double arg2) { return ret; };
namespace PrimeLib {
//* 素数判定 is_prime<unsigned>(N)
template <typename T, std::enable_if_t<std::is_unsigned<T>::value,
std::nullptr_t> = nullptr>
bool is_prime(const T n) {
if (n < 4)
return n == 2 || n == 3;
if (n % 2 == 0 || n % 3 == 0 || (n % 6 != 1 && n % 6 != 5))
return false;
for (T i = 5; i * i <= n; i += 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
//* 素数テーブル生成 エラトステネスの篩 10^7 => 1s
//* 1e9を素因数分解したい時，sqrt(1e9)まで(31623程)を生成すればよい
vector<ll> primeTable(ll n) {
vector<bool> table(n - 1);
vector<ll> ret;
for (ll i = 0; i < n - 1; ++i) {
if (table[i] == false) {
ll num = i + 2;
ret.push_back(i + 2);
for (int j = i + num; j < n - 1; j += num)
table[j] = true;
}
}
return ret;
}
vector<ll> factorize(ll n, vector<ll> &pt) {
vector<ll> ret;
int pos = 0;
ll c = n;
while (c != 1) {
ll p = pt[pos];
ret.push_back(0);
while (c % p == 0) {
ret[pos]++;
c /= p;
}
pos++;
if (pos >= pt.size())
break;
}
// assert(c == 1);
// if c is still not 1,
// there's one prime num bigger than sqrt(N)
if (c != 1)
ret.push_back(1);
return ret;
}
} // namespace PrimeLib
int main(void) {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
inll(N);
auto a = INPA<ll>(N);
sort(a.rbegin(), a.rend());
ll sum = 0; // a[0];
REP(i, N) if (odd(a[i])) sum++;
if (sum)
out("first");
else
out("second");
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 991,502 | 991,503 | u300752229 | cpp |
p03197 | /*************************************************
*************************************************
*************************************************
*** _________________ | | | /***
*** | | | | / ***
*** | | | | / ***
*** | | | | / ***
*** | | | | / ***
*** | |____________| |/ en ***
*** | | | |\ ***
*** | | | | \ ***
*** _____ | | | | \ ***
*** | | | | | \ ***
*** \ / | | | \ ***
*** \___/ | | | \***
*************************************************
*************Written by: JiangHaoKai*************
*************************************************/
#pragma GCC optimize(2)
#pragma G++ optimize(2)
#pragma comment(linker, "/STACK:102400000,102400000")
//#include <bits/stdc++.h>
#include <algorithm>
#include <array>
#include <atomic>
#include <bitset>
#include <cassert>
#include <ccomplex>
#include <cctype>
#include <cerrno>
#include <cfenv>
#include <cfloat>
#include <chrono>
#include <cinttypes>
#include <climits>
#include <clocale>
#include <cmath>
#include <complex>
#include <condition_variable>
#include <csetjmp>
#include <csignal>
#include <cstdalign>
#include <cstdarg>
#include <cstdbool>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctgmath>
#include <ctime>
#include <cwchar>
#include <cwctype>
#include <deque>
#include <forward_list>
#include <fstream>
#include <functional>
#include <future>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <mutex>
#include <numeric>
#include <queue>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <string>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <valarray>
#include <vector>
//#include <conio.h>
//#include <windows.h>
using namespace std;
typedef long long LL;
typedef unsigned int ui;
typedef unsigned long long ull;
typedef float fl;
typedef double ld;
typedef pair<int, int> pii;
#define ui(n) ((unsigned int)(n))
#define LL(n) ((long long)(n))
#define ull(n) ((unsigned long long)(n))
#define fl(n) ((float)(n))
#define ld(n) ((double)(n))
#define char(n) ((char)(n))
#define Bool(n) ((bool)(n))
#define fixpoint(n) fixed << setprecision(n)
const int INF = 1061109567;
const LL LINF = 4557430888798830399;
#define PI 3.1415926535897932384626433832795028841971
#define MP make_pair
#define MT make_tuple
#define All(a) (a).begin(), (a).end()
#define pall(a) (a).rbegin(), (a).rend()
#define MOD 1000000007
#define sz(a) ((int)(a).size())
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define repa(i, a, n) for (int i = a; i < n; i++)
#define repa1(i, a, n) for (int i = a; i <= n; i++)
#define repd(i, n) for (int i = n - 1; i >= 0; i--)
#define repd1(i, n) for (int i = n; i >= 1; i--)
#define repda(i, n, a) for (int i = n; i > a; i--)
#define repda1(i, n, a) for (int i = n; i >= a; i--)
#define FOR(i, a, n, step) for (int i = a; i < n; i += step)
#define repv(itr, v) \
for (__typeof((v).begin()) itr = (v).begin(); itr != (v).end(); itr++)
#define repV(i, v) for (auto i : v)
#define repE(i, v) for (auto &i : v)
#define MS(x, y) memset(x, y, sizeof(x))
#define MC(x) MS(x, 0)
#define MCP(x, y) memcpy(x, y, sizeof(y))
#define sqr(x) ((x) * (x))
#define UN(v) sort(All(v)), v.erase(unique(All(v)), v.end())
#define filein(x) freopen(x, "r", stdin)
#define fileout(x) freopen(x, "w", stdout)
#define fileio(x) \
freopen(x ".in", "r", stdin); \
freopen(x ".out", "w", stdout)
#define filein2(filename, name) ifstream name(filename, ios::in)
#define fileout2(filename, name) ofstream name(filename, ios::out)
#define file(filename, name) fstream name(filename, ios::in | ios::out)
#define Pause system("pause")
#define Cls system("cls")
#define fs first
#define sc second
#define PC(x) putchar(x)
#define GC(x) x = getchar()
#define Endl PC('\n')
#define SF scanf
#define PF printf
inline int Read() {
int X = 0, w = 0;
char ch = 0;
while (!isdigit(ch)) {
w |= ch == '-';
ch = getchar();
}
while (isdigit(ch))
X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
return w ? -X : X;
}
inline void Write(int x) {
if (x < 0)
putchar('-'), x = -x;
if (x > 9)
Write(x / 10);
putchar(x % 10 + '0');
}
inline LL powmod(LL a, LL b) {
LL res = 1;
a %= MOD;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1)
res = res * a % MOD;
a = a * a % MOD;
}
return res;
}
inline LL gcdll(LL a, LL b) { return b ? gcdll(b, a % b) : a; }
const int dx[] = {0, 1, 0, -1, 1, -1, -1, 1};
const int dy[] = {1, 0, -1, 0, -1, -1, 1, 1};
/**************************************************************Begin***************************************************************/
const int maxn = 100010;
int n, cnt0, cnt1;
int main() {
SF("%d", &n);
rep(i, n) {
int x;
SF("%d", &x);
if (x % 2)
cnt1++;
else
cnt0++;
}
PF("%s", cnt0 <= cnt1 ? "first" : "second");
return 0;
}
/***************************************************************End****************************************************************/
| /*************************************************
*************************************************
*************************************************
*** _________________ | | | /***
*** | | | | / ***
*** | | | | / ***
*** | | | | / ***
*** | | | | / ***
*** | |____________| |/ en ***
*** | | | |\ ***
*** | | | | \ ***
*** _____ | | | | \ ***
*** | | | | | \ ***
*** \ / | | | \ ***
*** \___/ | | | \***
*************************************************
*************Written by: JiangHaoKai*************
*************************************************/
#pragma GCC optimize(2)
#pragma G++ optimize(2)
#pragma comment(linker, "/STACK:102400000,102400000")
//#include <bits/stdc++.h>
#include <algorithm>
#include <array>
#include <atomic>
#include <bitset>
#include <cassert>
#include <ccomplex>
#include <cctype>
#include <cerrno>
#include <cfenv>
#include <cfloat>
#include <chrono>
#include <cinttypes>
#include <climits>
#include <clocale>
#include <cmath>
#include <complex>
#include <condition_variable>
#include <csetjmp>
#include <csignal>
#include <cstdalign>
#include <cstdarg>
#include <cstdbool>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctgmath>
#include <ctime>
#include <cwchar>
#include <cwctype>
#include <deque>
#include <forward_list>
#include <fstream>
#include <functional>
#include <future>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <mutex>
#include <numeric>
#include <queue>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <string>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <valarray>
#include <vector>
//#include <conio.h>
//#include <windows.h>
using namespace std;
typedef long long LL;
typedef unsigned int ui;
typedef unsigned long long ull;
typedef float fl;
typedef double ld;
typedef pair<int, int> pii;
#define ui(n) ((unsigned int)(n))
#define LL(n) ((long long)(n))
#define ull(n) ((unsigned long long)(n))
#define fl(n) ((float)(n))
#define ld(n) ((double)(n))
#define char(n) ((char)(n))
#define Bool(n) ((bool)(n))
#define fixpoint(n) fixed << setprecision(n)
const int INF = 1061109567;
const LL LINF = 4557430888798830399;
#define PI 3.1415926535897932384626433832795028841971
#define MP make_pair
#define MT make_tuple
#define All(a) (a).begin(), (a).end()
#define pall(a) (a).rbegin(), (a).rend()
#define MOD 1000000007
#define sz(a) ((int)(a).size())
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define repa(i, a, n) for (int i = a; i < n; i++)
#define repa1(i, a, n) for (int i = a; i <= n; i++)
#define repd(i, n) for (int i = n - 1; i >= 0; i--)
#define repd1(i, n) for (int i = n; i >= 1; i--)
#define repda(i, n, a) for (int i = n; i > a; i--)
#define repda1(i, n, a) for (int i = n; i >= a; i--)
#define FOR(i, a, n, step) for (int i = a; i < n; i += step)
#define repv(itr, v) \
for (__typeof((v).begin()) itr = (v).begin(); itr != (v).end(); itr++)
#define repV(i, v) for (auto i : v)
#define repE(i, v) for (auto &i : v)
#define MS(x, y) memset(x, y, sizeof(x))
#define MC(x) MS(x, 0)
#define MCP(x, y) memcpy(x, y, sizeof(y))
#define sqr(x) ((x) * (x))
#define UN(v) sort(All(v)), v.erase(unique(All(v)), v.end())
#define filein(x) freopen(x, "r", stdin)
#define fileout(x) freopen(x, "w", stdout)
#define fileio(x) \
freopen(x ".in", "r", stdin); \
freopen(x ".out", "w", stdout)
#define filein2(filename, name) ifstream name(filename, ios::in)
#define fileout2(filename, name) ofstream name(filename, ios::out)
#define file(filename, name) fstream name(filename, ios::in | ios::out)
#define Pause system("pause")
#define Cls system("cls")
#define fs first
#define sc second
#define PC(x) putchar(x)
#define GC(x) x = getchar()
#define Endl PC('\n')
#define SF scanf
#define PF printf
inline int Read() {
int X = 0, w = 0;
char ch = 0;
while (!isdigit(ch)) {
w |= ch == '-';
ch = getchar();
}
while (isdigit(ch))
X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
return w ? -X : X;
}
inline void Write(int x) {
if (x < 0)
putchar('-'), x = -x;
if (x > 9)
Write(x / 10);
putchar(x % 10 + '0');
}
inline LL powmod(LL a, LL b) {
LL res = 1;
a %= MOD;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1)
res = res * a % MOD;
a = a * a % MOD;
}
return res;
}
inline LL gcdll(LL a, LL b) { return b ? gcdll(b, a % b) : a; }
const int dx[] = {0, 1, 0, -1, 1, -1, -1, 1};
const int dy[] = {1, 0, -1, 0, -1, -1, 1, 1};
/**************************************************************Begin***************************************************************/
const int maxn = 100010;
int n, cnt0, cnt1;
int main() {
SF("%d", &n);
rep(i, n) {
int x;
SF("%d", &x);
if (x % 2)
cnt1++;
else
cnt0++;
}
PF("%s", cnt1 ? "first" : "second");
return 0;
}
/***************************************************************End****************************************************************/
| [
"expression.operation.binary.remove"
] | 991,508 | 991,509 | u424955889 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
int n, b;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &b);
if (b & 1) {
cout << "second" << endl;
return 0;
}
}
cout << "first" << endl;
} | #include <bits/stdc++.h>
using namespace std;
int n, b;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &b);
if (b & 1) {
cout << "first" << endl;
return 0;
}
}
cout << "second" << endl;
} | [
"literal.string.change",
"io.output.change"
] | 991,512 | 991,513 | u032327689 | cpp |
p03197 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
long long ans = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
ans ^= x;
}
if (ans & 1) {
cout << "first" << endl;
} else {
cout << "second" << endl;
}
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
long long ans = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
ans |= x;
}
if (ans & 1) {
cout << "first" << endl;
} else {
cout << "second" << endl;
}
return 0;
}
| [
"expression.operator.change"
] | 991,514 | 991,515 | u957188497 | cpp |
p03197 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
int ans = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
ans ^= x;
}
if (ans & 1) {
cout << "first" << endl;
} else {
cout << "second" << endl;
}
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
long long ans = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
ans |= x;
}
if (ans & 1) {
cout << "first" << endl;
} else {
cout << "second" << endl;
}
return 0;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"expression.operator.change"
] | 991,516 | 991,515 | u957188497 | cpp |
p03197 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <complex>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define Rep(i, a, b) for (int i = a; i < b; i++)
#define REP(i, a, b) for (int i = a; i <= b; i++)
#define rev(i, n) for (int i = n - 1; i >= 0; i--)
#define vi vector<int>
#define vvi vector<vi>
#define pb push_back
#define pi pair<int, int>
#define vp vector<pair<int, int>>
#define mp make_pair
#define all(v) (v).begin(), (v).end()
#define fi first
#define se second
#define MEMSET(a) memset(a, 0, sizeof(a))
#define inf (1ll << 60)
#define Yes(f) cout << (f ? "Yes" : "No") << endl
#define yes(f) cout << (f ? "yes" : "no") << endl
#define YES(f) cout << (f ? "YES" : "NO") << endl
using namespace std;
const int mod = 1e9 + 7;
void run();
void init() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(12);
}
signed main() {
init();
run();
return 0;
}
void run() {
int n;
cin >> n;
int a;
int o = 0;
int e = 0;
rep(i, n) {
cin >> a;
if (a % 2)
o++;
else
e++;
}
cout << (e <= o ? "first" : "second") << endl;
}
| #define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <complex>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define Rep(i, a, b) for (int i = a; i < b; i++)
#define REP(i, a, b) for (int i = a; i <= b; i++)
#define rev(i, n) for (int i = n - 1; i >= 0; i--)
#define vi vector<int>
#define vvi vector<vi>
#define pb push_back
#define pi pair<int, int>
#define vp vector<pair<int, int>>
#define mp make_pair
#define all(v) (v).begin(), (v).end()
#define fi first
#define se second
#define MEMSET(a) memset(a, 0, sizeof(a))
#define inf (1ll << 60)
#define Yes(f) cout << (f ? "Yes" : "No") << endl
#define yes(f) cout << (f ? "yes" : "no") << endl
#define YES(f) cout << (f ? "YES" : "NO") << endl
using namespace std;
const int mod = 1e9 + 7;
void run();
void init() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(12);
}
signed main() {
init();
run();
return 0;
}
void run() {
int n;
cin >> n;
int a;
int o = 0;
int e = 0;
rep(i, n) {
cin >> a;
if (a % 2)
o++;
else
e++;
}
cout << (o ? "first" : "second") << endl;
}
| [
"expression.operation.binary.remove"
] | 991,521 | 991,522 | u128527648 | cpp |
p03197 | #include "bits/stdc++.h"
using namespace std;
#define Rep(b, e, i) for (int i = b; i <= e; i++)
#define Repr(e, b, i) for (int i = e; i >= b; i--)
#define rep(n, i) Rep(0, n - 1, i)
#define repr(n, i) Repr(n - 1, 0, i)
#define all(v) (v).begin(), (v).end()
#define pb(v) push_back(v)
#define uniq(v) (v).erase(unique(all(v)), (v).end())
#define bitcnt(x) __builtin_popcount(x)
#define fst first
#define snd second
#define Pqaz(T) priority_queue<T, vector<T>, greater<T>>
#define Pqza(T) priority_queue<T>
#define put(x) cout << x;
#define putsp(x) cout << x << ' ';
#define putbd cout << "---------------------------------------------" << endl;
#define putln(x) cout << x << endl;
#define debug(x) cerr << #x << "=" << x << endl;
#define ENJYU std::ios::sync_with_stdio(false) std::cin.tie(0);
typedef long long ll;
typedef pair<ll, ll> llP;
typedef pair<int, int> intP;
typedef complex<double> comp;
typedef vector<int> vec;
typedef vector<ll> vecll;
typedef vector<double> vecd;
typedef vector<vec> mat;
typedef vector<vecll> matll;
typedef vector<vecd> matd;
template <class T> ostream &operator<<(ostream &o, const vector<T> &v) {
o << "{";
for (int i = 0; i < (int)v.size(); i++)
o << (i > 0 ? ", " : "") << v[i];
o << "}";
return o;
}
const int MAX = 200020;
const double PI = 3.14159265358979323846;
const double EPS = 1e-12;
const int INF = 1 << 29;
const ll INFL = 1e18;
const ll MOD = 1000000007;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
// const int dx[]={-1,-1,-1,0,1,1,1,0},dy[]={-1,0,1,1,1,0,-1,-1};
//********************************template
//END****************************************//
void solve() {
int N;
cin >> N;
int ans = 0;
rep(N, i) {
int d;
cin >> d;
if (d & 1)
ans ^= 1;
}
cout << (ans ? "first" : "second") << endl;
}
int main() {
solve();
// cout << "yui(*-v・)yui" << endl;
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
#define Rep(b, e, i) for (int i = b; i <= e; i++)
#define Repr(e, b, i) for (int i = e; i >= b; i--)
#define rep(n, i) Rep(0, n - 1, i)
#define repr(n, i) Repr(n - 1, 0, i)
#define all(v) (v).begin(), (v).end()
#define pb(v) push_back(v)
#define uniq(v) (v).erase(unique(all(v)), (v).end())
#define bitcnt(x) __builtin_popcount(x)
#define fst first
#define snd second
#define Pqaz(T) priority_queue<T, vector<T>, greater<T>>
#define Pqza(T) priority_queue<T>
#define put(x) cout << x;
#define putsp(x) cout << x << ' ';
#define putbd cout << "---------------------------------------------" << endl;
#define putln(x) cout << x << endl;
#define debug(x) cerr << #x << "=" << x << endl;
#define ENJYU std::ios::sync_with_stdio(false) std::cin.tie(0);
typedef long long ll;
typedef pair<ll, ll> llP;
typedef pair<int, int> intP;
typedef complex<double> comp;
typedef vector<int> vec;
typedef vector<ll> vecll;
typedef vector<double> vecd;
typedef vector<vec> mat;
typedef vector<vecll> matll;
typedef vector<vecd> matd;
template <class T> ostream &operator<<(ostream &o, const vector<T> &v) {
o << "{";
for (int i = 0; i < (int)v.size(); i++)
o << (i > 0 ? ", " : "") << v[i];
o << "}";
return o;
}
const int MAX = 200020;
const double PI = 3.14159265358979323846;
const double EPS = 1e-12;
const int INF = 1 << 29;
const ll INFL = 1e18;
const ll MOD = 1000000007;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
// const int dx[]={-1,-1,-1,0,1,1,1,0},dy[]={-1,0,1,1,1,0,-1,-1};
//********************************template
//END****************************************//
void solve() {
int N;
cin >> N;
int ans = 0;
rep(N, i) {
int d;
cin >> d;
if (d & 1)
ans = 1;
}
cout << (ans ? "first" : "second") << endl;
}
int main() {
solve();
// cout << "yui(*-v・)yui" << endl;
return 0;
}
| [
"assignment.value.change"
] | 991,523 | 991,524 | u344412812 | cpp |
p03197 | #include <bits/stdc++.h>
#ifdef _WIN32
#include "debug.hpp"
#endif
using namespace std;
#define rep(i, N) repf(i, 0, N)
#define reps(i, N) repfs(i, 1, N)
#define repf(i, a, b) for (int i = a; i < b; i++)
#define repfs(i, a, b) for (int i = a; i <= b; i++)
#define repr(i, N) for (int i = N - 1; i >= 0; i--)
#define reprs(i, N) for (int i = N; i > 0; i--)
#define pb push_back
template <typename T> void chmax(T &a, T b) { a = max(a, b); };
template <typename T> void chmin(T &a, T b) { a = min(a, b); };
typedef long long ll;
typedef pair<int, int> P;
const int INF = 100000000;
const int MOD = 1000000007;
const int dx[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
const int dy[9] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
//--------------------------------------//
int n, a;
bool b;
void solve() {
if (b)
cout << "first" << endl;
else
cout << "second" << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n;
rep(i, n) {
cin >> a;
if (a % 2 == 1)
b = !b;
}
solve();
return 0;
}
| #include <bits/stdc++.h>
#ifdef _WIN32
#include "debug.hpp"
#endif
using namespace std;
#define rep(i, N) repf(i, 0, N)
#define reps(i, N) repfs(i, 1, N)
#define repf(i, a, b) for (int i = a; i < b; i++)
#define repfs(i, a, b) for (int i = a; i <= b; i++)
#define repr(i, N) for (int i = N - 1; i >= 0; i--)
#define reprs(i, N) for (int i = N; i > 0; i--)
#define pb push_back
template <typename T> void chmax(T &a, T b) { a = max(a, b); };
template <typename T> void chmin(T &a, T b) { a = min(a, b); };
typedef long long ll;
typedef pair<int, int> P;
const int INF = 100000000;
const int MOD = 1000000007;
const int dx[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
const int dy[9] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
//--------------------------------------//
int n, a;
bool b;
void solve() {
if (b)
cout << "first" << endl;
else
cout << "second" << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n;
rep(i, n) {
cin >> a;
if (a % 2 == 1)
b = true;
}
solve();
return 0;
}
| [
"assignment.value.change",
"expression.operation.unary.remove"
] | 991,529 | 991,530 | u073946233 | cpp |
p03197 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
#define repeat(i, n) for (long long i = 0; (i) < (n); ++(i))
#define debug(x) cerr << #x << ": " << x << '\n'
#define debugArray(x, n) \
for (long long i = 0; (i) < (n); ++(i)) \
cerr << #x << "[" << i << "]: " << x[i] << '\n'
#define debugArrayP(x, n) \
for (long long i = 0; (i) < (n); ++(i)) \
cerr << #x << "[" << i << "]: " << x[i].first << " " << x[i].second << '\n'
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> Pii;
typedef vector<int> vint;
typedef vector<ll> vll;
const ll INF = INT_MAX;
const ll MOD = 1e9 + 7;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
bool winner = 0;
repeat(i, N) {
int a;
cin >> a;
winner ^= a & 1;
}
cout << (winner ? "first" : "second") << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
#define repeat(i, n) for (long long i = 0; (i) < (n); ++(i))
#define debug(x) cerr << #x << ": " << x << '\n'
#define debugArray(x, n) \
for (long long i = 0; (i) < (n); ++(i)) \
cerr << #x << "[" << i << "]: " << x[i] << '\n'
#define debugArrayP(x, n) \
for (long long i = 0; (i) < (n); ++(i)) \
cerr << #x << "[" << i << "]: " << x[i].first << " " << x[i].second << '\n'
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> Pii;
typedef vector<int> vint;
typedef vector<ll> vll;
const ll INF = INT_MAX;
const ll MOD = 1e9 + 7;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
bool winner = 0;
repeat(i, N) {
ll a;
cin >> a;
winner |= a & 1;
}
cout << (winner ? "first" : "second") << endl;
return 0;
}
| [
"variable_declaration.type.change",
"expression.operator.change"
] | 991,534 | 991,535 | u120143737 | cpp |
p03197 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <map>
#include <queue>
#include <stack>
#include <vector>
using namespace std;
typedef long long LL;
inline char gc() {
// static char buf[100000],*p1,*p2;
// return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
return getchar();
}
inline int read() {
int ans = 0, fh = 1;
char ch = gc();
while (ch < '0' || ch > '9') {
if (ch == '-')
fh = -1;
ch = gc();
}
while (ch >= '0' && ch <= '9')
ans = (ans << 1) + (ans << 3) + ch - '0', ch = gc();
return ans * fh;
}
int main() {
// freopen(".in","r",stdin);
int n, x, ok = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
if (x % 2 == 0)
ok = 1;
}
if (ok)
printf("first\n");
else
printf("second\n");
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <map>
#include <queue>
#include <stack>
#include <vector>
using namespace std;
typedef long long LL;
inline char gc() {
// static char buf[100000],*p1,*p2;
// return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
return getchar();
}
inline int read() {
int ans = 0, fh = 1;
char ch = gc();
while (ch < '0' || ch > '9') {
if (ch == '-')
fh = -1;
ch = gc();
}
while (ch >= '0' && ch <= '9')
ans = (ans << 1) + (ans << 3) + ch - '0', ch = gc();
return ans * fh;
}
int main() {
// freopen(".in","r",stdin);
int n, x, ok = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
if (x % 2 == 1)
ok = 1;
}
if (ok)
printf("first\n");
else
printf("second\n");
return 0;
}
| [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 991,538 | 991,539 | u122992041 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
int n, x;
int main() {
while (scanf("%d", &n) != EOF) {
x = 0;
for (int i = 1, y; i <= n; ++i) {
scanf("%d", &y);
x += y & 1;
}
puts(x & 1 ? "first" : "second");
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int n, x;
int main() {
while (scanf("%d", &n) != EOF) {
x = 0;
for (int i = 1, y; i <= n; ++i) {
scanf("%d", &y);
x += y & 1;
}
puts(x ? "first" : "second");
}
return 0;
}
| [
"expression.operation.binary.remove"
] | 991,547 | 991,548 | u717168969 | cpp |
p03197 | // Pantyhose(black) + glasses = infinity
#include <bits/stdc++.h>
using namespace std;
#define debug(x) cerr << #x << " = " << x << '\n';
#define BP() cerr << "OK!\n";
#define PR(A, n) \
{ \
cerr << #A << " = "; \
for (int _ = 1; _ <= n; ++_) \
cerr << A[_] << ' '; \
cerr << '\n'; \
}
#define PR0(A, n) \
{ \
cerr << #A << " = "; \
for (int _ = 0; _ < n; ++_) \
cerr << A[_] << ' '; \
cerr << '\n'; \
}
#define FILE_NAME "data"
int main() {
#ifdef GLASSES_GIRL
freopen(FILE_NAME ".inp", "r", stdin);
freopen(FILE_NAME ".out", "w", stdout);
#endif
ios::sync_with_stdio(0);
cin.tie(0);
int n;
bool ok = false;
cin >> n;
for (int i = 1; i <= n; ++i) {
int x;
if (x % 2)
ok = true;
}
if (ok)
cout << "first";
else
cout << "second";
} | // Pantyhose(black) + glasses = infinity
#include <bits/stdc++.h>
using namespace std;
#define debug(x) cerr << #x << " = " << x << '\n';
#define BP() cerr << "OK!\n";
#define PR(A, n) \
{ \
cerr << #A << " = "; \
for (int _ = 1; _ <= n; ++_) \
cerr << A[_] << ' '; \
cerr << '\n'; \
}
#define PR0(A, n) \
{ \
cerr << #A << " = "; \
for (int _ = 0; _ < n; ++_) \
cerr << A[_] << ' '; \
cerr << '\n'; \
}
#define FILE_NAME "data"
int main() {
#ifdef GLASSES_GIRL
freopen(FILE_NAME ".inp", "r", stdin);
freopen(FILE_NAME ".out", "w", stdout);
#endif
ios::sync_with_stdio(0);
cin.tie(0);
int n;
bool ok = false;
cin >> n;
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
if (x % 2)
ok = true;
}
if (ok)
cout << "first";
else
cout << "second";
} | [] | 991,549 | 991,550 | u682090147 | cpp |
p03196 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
ll i, j, k, n, m, p, ans = 1;
ll Pow(ll n, ll m) {
ll ans = 1;
while (m > 1) {
if (m % 2 == 0) {
m /= 2;
n = n * n;
} else {
ans = ans * n;
m /= 2;
n = n * n;
}
}
return n * ans;
}
int main() {
cin >> p >> n;
if (p == 1) {
cout << n << endl;
return 0;
}
if (n == 1) {
cout << 1 << endl;
return 0;
}
ll ans = (ll)pow((double)n, (double)(1.0 / p));
for (i = ans; i >= 1; i--) {
ll k = Pow(i, p);
if (k > 0 && n % k == 0) {
cout << i << endl;
return 0;
}
}
cout << 1 << endl;
return 0;
}
/*
2 999999999999
3
*/ | #include <bits/stdc++.h>
#define ll unsigned long long
using namespace std;
ll i, j, k, n, m, p, ans = 1;
ll Pow(ll n, ll m) {
ll ans = 1;
while (m > 1) {
if (m % 2 == 0) {
m /= 2;
n = n * n;
} else {
ans = ans * n;
m /= 2;
n = n * n;
}
}
return n * ans;
}
int main() {
cin >> p >> n;
if (p == 1) {
cout << n << endl;
return 0;
}
if (n == 1) {
cout << 1 << endl;
return 0;
}
ll ans = (ll)pow((double)n, (double)(1.0 / p));
for (i = ans + 1; i >= 2; i--) {
ll k = Pow(i, p);
if (k > 0 && n % k == 0) {
cout << i << endl;
return 0;
}
}
cout << 1 << endl;
return 0;
}
/*
2 999999999999
3
*/ | [
"control_flow.loop.for.initializer.change",
"assignment.change",
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 991,559 | 991,558 | u032327689 | cpp |
p03196 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <complex>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define Rep(i, a, b) for (int i = a; i < b; i++)
#define REP(i, a, b) for (int i = a; i <= b; i++)
#define rev(i, n) for (int i = n - 1; i >= 0; i--)
#define vi vector<int>
#define vvi vector<vi>
#define pb push_back
#define pi pair<int, int>
#define vp vector<pair<int, int>>
#define mp make_pair
#define all(v) (v).begin(), (v).end()
#define fi first
#define se second
#define MEMSET(a) memset(a, 0, sizeof(a))
#define inf (1ll << 60)
#define Yes(f) cout << (f ? "Yes" : "No") << endl
#define yes(f) cout << (f ? "yes" : "no") << endl
#define YES(f) cout << (f ? "YES" : "NO") << endl
using namespace std;
const int mod = 1e9 + 7;
void run();
void init() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(12);
}
signed main() {
init();
run();
return 0;
}
int pow(int x, int n) {
int ans = 1;
while (n > 0) {
if ((n & 1) == 1) {
ans = ans * x;
}
x = x * x;
n >>= 1;
}
return ans;
}
void run() {
int n, p;
cin >> n >> p;
if (n == 1) {
cout << p << endl;
return;
}
if (n > 40) {
cout << 1 << endl;
return;
}
int ans = 1;
int t;
for (int i = 2; (t = pow(i, n)) <= p; i++) {
if (p % t == 0) {
ans *= i;
p /= t;
}
}
cout << ans << endl;
}
| #define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <complex>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define Rep(i, a, b) for (int i = a; i < b; i++)
#define REP(i, a, b) for (int i = a; i <= b; i++)
#define rev(i, n) for (int i = n - 1; i >= 0; i--)
#define vi vector<int>
#define vvi vector<vi>
#define pb push_back
#define pi pair<int, int>
#define vp vector<pair<int, int>>
#define mp make_pair
#define all(v) (v).begin(), (v).end()
#define fi first
#define se second
#define MEMSET(a) memset(a, 0, sizeof(a))
#define inf (1ll << 60)
#define Yes(f) cout << (f ? "Yes" : "No") << endl
#define yes(f) cout << (f ? "yes" : "no") << endl
#define YES(f) cout << (f ? "YES" : "NO") << endl
using namespace std;
const int mod = 1e9 + 7;
void run();
void init() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(12);
}
signed main() {
init();
run();
return 0;
}
int pow(int x, int n) {
int ans = 1;
while (n > 0) {
if ((n & 1) == 1) {
ans = ans * x;
}
x = x * x;
n >>= 1;
}
return ans;
}
void run() {
int n, p;
cin >> n >> p;
if (n == 1) {
cout << p << endl;
return;
}
if (n > 60) {
cout << 1 << endl;
return;
}
int ans = 1;
int t;
for (int i = 2; (t = pow(i, n)) <= p; i++) {
while (p % t == 0) {
ans *= i;
p /= t;
}
}
cout << ans << endl;
}
| [
"literal.number.change",
"control_flow.branch.if.condition.change",
"control_flow.branch.while.replace.add",
"control_flow.loop.if.replace.remove"
] | 991,572 | 991,573 | u128527648 | cpp |
p03196 | #pragma GCC optimize "-O3"
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int lmax = 1999999999;
const long long lmx = 1999999999999999999;
ll Nn, N, P;
ll ans = 1LL;
ll lp[10000004];
int main() {
std::ios::sync_with_stdio(false);
cin >> Nn >> P;
if (Nn == 1LL) {
cout << P << endl;
return 0;
}
N = P;
for (ll i = 2; i * i <= N; ++i) {
if (lp[i] == 0) {
ll k = 0;
while (P % i == 0) {
P /= i;
k++;
}
if (k >= Nn) {
ans *= i;
}
}
for (ll j = i; j * j <= N; j += i)
lp[j] = 1;
}
cout << ans << endl;
}
/*
* *
* * * *
* * * *
* * * *
* * * *
* * *
* *
* *
* *
* *
* *
* *
* *
* *
*
*/
| #pragma GCC optimize "-O3"
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int lmax = 1999999999;
const long long lmx = 1999999999999999999;
ll Nn, N, P;
ll ans = 1LL;
ll lp[10000004];
int main() {
std::ios::sync_with_stdio(false);
cin >> Nn >> P;
if (Nn == 1LL) {
cout << P << endl;
return 0;
}
N = P;
for (ll i = 2; i * i <= N; ++i) {
if (lp[i] == 0) {
ll k = 0;
while (P % i == 0) {
P /= i;
k++;
}
while (k >= Nn) {
ans *= i;
k -= Nn;
}
}
for (ll j = i; j * j <= N; j += i)
lp[j] = 1;
}
cout << ans << endl;
}
/*
* *
* * * *
* * * *
* * * *
* * * *
* * *
* *
* *
* *
* *
* *
* *
* *
* *
*
*/
| [
"control_flow.branch.while.replace.add",
"control_flow.loop.if.replace.remove",
"assignment.add"
] | 991,586 | 991,587 | u786839198 | cpp |
p03196 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <valarray>
#include <vector>
#define rep(X, Y) for (int(X) = 0; (X) < (Y); ++(X))
#define rrep(X, Y) for (int(X) = Y - 1; (X) >= 0; --(X))
#define repa(X, A, Y) for (int(X) = A; (X) <= (Y); ++(X))
#define all(X) (X).begin(), (X).end()
#define mod(n, m) (((n) % (m) + (m)) % m)
#define fi first
#define sc second
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
const int INFINT = 1 << 30; // 1.07x10^ 9
const ll INFLL = 1LL << 60; // 1.15x10^18
const double EPS = 1e-10;
const int MOD = 1000000007;
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const ll MAX_PRIME = 1e6 + 100;
ll N, P;
bool prime[MAX_PRIME];
void init_prime(ll p) {
memset(prime, true, sizeof(prime));
for (ll i = 2; i * i <= p; ++i) {
if (prime[i] == true) {
for (ll j = 2; i * j * i * j <= p; ++j) {
prime[i * j] = false;
}
}
}
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
cin >> N >> P;
if (N == 1) {
cout << P << endl;
return 0;
}
init_prime(P);
ll ans = 1;
for (ll i = 2; i * i <= P; ++i) {
if (prime[i] && P % i == 0) {
ll tmp = 0;
while (P % i == 0) {
P /= i;
++tmp;
}
while (tmp / N > 0) {
ans *= i;
tmp /= N;
}
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <valarray>
#include <vector>
#define rep(X, Y) for (int(X) = 0; (X) < (Y); ++(X))
#define rrep(X, Y) for (int(X) = Y - 1; (X) >= 0; --(X))
#define repa(X, A, Y) for (int(X) = A; (X) <= (Y); ++(X))
#define all(X) (X).begin(), (X).end()
#define mod(n, m) (((n) % (m) + (m)) % m)
#define fi first
#define sc second
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
const int INFINT = 1 << 30; // 1.07x10^ 9
const ll INFLL = 1LL << 60; // 1.15x10^18
const double EPS = 1e-10;
const int MOD = 1000000007;
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const ll MAX_PRIME = 1e6 + 100;
ll N, P;
bool prime[MAX_PRIME];
void init_prime(ll p) {
memset(prime, true, sizeof(prime));
for (ll i = 2; i * i <= p; ++i) {
if (prime[i] == true) {
for (ll j = 2; i * j * i * j <= p; ++j) {
prime[i * j] = false;
}
}
}
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
cin >> N >> P;
if (N == 1) {
cout << P << endl;
return 0;
}
init_prime(P);
ll ans = 1;
for (ll i = 2; i * i <= P; ++i) {
if (prime[i] && P % i == 0) {
ll tmp = 0;
while (P % i == 0) {
P /= i;
++tmp;
}
while (tmp / N > 0) {
ans *= i;
tmp -= N;
}
}
}
cout << ans << endl;
return 0;
}
| [
"expression.operator.change"
] | 991,588 | 991,589 | u373364108 | cpp |
p03196 | #include <bits/stdc++.h>
#define INF 1e9
#define llINF 1e18
#define MOD 1000000007
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define ll long long
#define ALL(a) (a).begin(), (a).end()
#define Yes(hoge) cout << ((hoge) ? "Yes" : "No") << endl;
#define YES(hoge) cout << ((hoge) ? "YES" : "NO") << endl;
typedef struct aaaaa {
int x, y, t;
} Grid;
using namespace std;
int main() {
ll n, p;
cin >> n >> p;
vector<pair<ll, ll>> prime;
prime.pb(mp(2, 0));
for (ll i = 3; i <= sqrt(1000000100000LL); i += 2) {
bool flag = true;
for (ll j = 2; j <= sqrt(i); j++) {
if (i % j == 0) {
flag = false;
break;
}
}
if (flag)
prime.pb(mp(i, 0));
}
ll pp = p;
ll cnt = 0;
while (pp > 1) {
while (pp % prime[cnt].F == 0) {
prime[cnt].S++;
pp /= prime[cnt].F;
}
cnt++;
if (cnt == prime.size())
break;
}
ll ans = 1;
if (n == 1) {
ans *= pp;
}
for (ll i = 0; i < prime.size(); i++) {
if ((ll)(prime[i].F) * ((ll)(prime[i].S) / n) != 0)
ans *= (ll)(prime[i].F) * ((ll)(prime[i].S) / n);
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define INF 1e9
#define llINF 1e18
#define MOD 1000000007
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define ll long long
#define ALL(a) (a).begin(), (a).end()
#define Yes(hoge) cout << ((hoge) ? "Yes" : "No") << endl;
#define YES(hoge) cout << ((hoge) ? "YES" : "NO") << endl;
typedef struct aaaaa {
int x, y, t;
} Grid;
using namespace std;
int main() {
ll n, p;
cin >> n >> p;
vector<pair<ll, ll>> prime;
prime.pb(mp(2, 0));
for (ll i = 3; i <= sqrt(1000000100000LL); i += 2) {
bool flag = true;
for (ll j = 2; j <= sqrt(i); j++) {
if (i % j == 0) {
flag = false;
break;
}
}
if (flag)
prime.pb(mp(i, 0));
}
ll pp = p;
ll cnt = 0;
while (pp > 1) {
while (pp % prime[cnt].F == 0) {
prime[cnt].S++;
pp /= prime[cnt].F;
}
cnt++;
if (cnt == prime.size())
break;
}
ll ans = 1;
if (n == 1) {
ans *= pp;
}
for (ll i = 0; i < prime.size(); i++) {
if ((ll)(prime[i].F) * ((ll)(prime[i].S) / n) != 0)
ans *= pow((ll)(prime[i].F), ((ll)(prime[i].S) / n));
}
cout << ans << endl;
return 0;
}
| [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 991,592 | 991,593 | u905715926 | cpp |
p03196 | #include <bits/stdc++.h>
#define rep2(x, fr, to) for (int(x) = (fr); (x) < (to); (x)++)
#define rep(x, to) for (int(x) = 0; (x) < (to); (x)++)
#define repr(x, fr, to) for (int(x) = (fr); (x) >= (to); (x)--)
#define all(c) (c).begin(), (c).end()
#define sz(v) (int)(v).size()
using namespace std;
typedef long long ll;
typedef vector<int> VI;
typedef pair<int, int> pii;
const int mod = (int)1e9 + 7;
void dbg() { cerr << "\n"; }
template <typename T, typename... T2> void dbg(const T &fst, const T2 &...rst) {
cerr << fst << ": ";
dbg(rst...);
}
map<ll, int> fctm(ll x) {
map<ll, int> fmp;
for (; x >= 4 && x % 2 == 0; x /= 2)
fmp[2]++;
for (ll d = 3, q = x / d; q >= d; q = x / d) {
if (x % d == 0)
fmp[d]++, x = q;
else
d += 2;
}
if (x != 1)
fmp[x]++; // note: if x==1: {{1,1}}
return fmp;
}
int main() {
// cin.tie(0); ios_base::sync_with_stdio(false);
ll n, p;
cin >> n >> p;
if (p == 1) {
cout << 1 << "\n";
return 0;
}
if (n == 1) {
cout << n << "\n";
return 0;
}
auto rc = fctm(p);
// for(auto x :rc) printf("%d:%d, ",x.first,x.second); puts("");
ll ans = 1;
for (auto x : rc) {
ll w = x.second / n;
if (w < 1)
continue;
ll z = 1;
rep(i, w) z *= x.first;
ans *= z;
}
cout << ans << "\n";
return 0;
}
| #include <bits/stdc++.h>
#define rep2(x, fr, to) for (int(x) = (fr); (x) < (to); (x)++)
#define rep(x, to) for (int(x) = 0; (x) < (to); (x)++)
#define repr(x, fr, to) for (int(x) = (fr); (x) >= (to); (x)--)
#define all(c) (c).begin(), (c).end()
#define sz(v) (int)(v).size()
using namespace std;
typedef long long ll;
typedef vector<int> VI;
typedef pair<int, int> pii;
const int mod = (int)1e9 + 7;
void dbg() { cerr << "\n"; }
template <typename T, typename... T2> void dbg(const T &fst, const T2 &...rst) {
cerr << fst << ": ";
dbg(rst...);
}
map<ll, int> fctm(ll x) {
map<ll, int> fmp;
for (; x >= 4 && x % 2 == 0; x /= 2)
fmp[2]++;
for (ll d = 3, q = x / d; q >= d; q = x / d) {
if (x % d == 0)
fmp[d]++, x = q;
else
d += 2;
}
if (x != 1)
fmp[x]++; // note: if x==1: {{1,1}}
return fmp;
}
int main() {
// cin.tie(0); ios_base::sync_with_stdio(false);
ll n, p;
cin >> n >> p;
if (p == 1) {
cout << 1 << "\n";
return 0;
}
if (n == 1) {
cout << p << "\n";
return 0;
}
auto rc = fctm(p);
// for(auto x :rc) printf("%d:%d, ",x.first,x.second); puts("");
ll ans = 1;
for (auto x : rc) {
ll w = x.second / n;
if (w < 1)
continue;
ll z = 1;
rep(i, w) z *= x.first;
ans *= z;
}
cout << ans << "\n";
return 0;
}
| [
"identifier.change",
"io.output.change"
] | 991,594 | 991,595 | u714564133 | cpp |
p03196 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#pragma region
using namespace std;
#define FOR(i, r, n) for (ll i = (ll)(r); i < (ll)(n); i++)
#define rep(i, n) FOR(i, 0LL, n)
#define RFOR(i, r, n) for (ll i = (ll)(n - 1); i >= r; i--)
#define rrep(i, n) RFOR(i, 0LL, n)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define COUNT(a, y, x) upper_bound(all(a), y) - lower_bound(all(a), x)
#define UNIQUE(a) \
sort(all(a)); \
a.erase(unique(all(a)), a.end())
#define pb push_back
#define endl '\n'
typedef long long int ll;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef vector<string> vs;
typedef map<ll, ll> MAP;
const ll inf = 2222222222222222222LL;
const ll mod = 1000000007LL;
ll n = 0, m = 0, ans = 0, tmp = 0, ma = -inf, mi = inf;
string s;
bool ok;
ll dx[9] = {0, 1, -1, 0, 0, 1, 1, -1, -1},
dy[9] = {0, 0, 0, 1, -1, 1, -1, 1, -1};
#pragma endregion
#define MAX 222222
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
ans = 1;
ll cur = m;
for (ll i = 2; i * i <= m; i++) {
ll cnt = 0;
while (cur % i == 0) {
cur /= i;
cnt++;
}
if (cnt >= n) {
tmp = 1;
rep(j, cnt / n) tmp *= i;
ans *= tmp;
}
}
if (cur != 1)
ans *= cur;
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#pragma region
using namespace std;
#define FOR(i, r, n) for (ll i = (ll)(r); i < (ll)(n); i++)
#define rep(i, n) FOR(i, 0LL, n)
#define RFOR(i, r, n) for (ll i = (ll)(n - 1); i >= r; i--)
#define rrep(i, n) RFOR(i, 0LL, n)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define COUNT(a, y, x) upper_bound(all(a), y) - lower_bound(all(a), x)
#define UNIQUE(a) \
sort(all(a)); \
a.erase(unique(all(a)), a.end())
#define pb push_back
#define endl '\n'
typedef long long int ll;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef vector<string> vs;
typedef map<ll, ll> MAP;
const ll inf = 2222222222222222222LL;
const ll mod = 1000000007LL;
ll n = 0, m = 0, ans = 0, tmp = 0, ma = -inf, mi = inf;
string s;
bool ok;
ll dx[9] = {0, 1, -1, 0, 0, 1, 1, -1, -1},
dy[9] = {0, 0, 0, 1, -1, 1, -1, 1, -1};
#pragma endregion
#define MAX 222222
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
ans = 1;
ll cur = m;
for (ll i = 2; i * i <= m; i++) {
ll cnt = 0;
while (cur % i == 0) {
cur /= i;
cnt++;
}
if (cnt >= n) {
tmp = 1;
rep(j, cnt / n) tmp *= i;
ans *= tmp;
}
}
if (cur != 1 && n == 1)
ans *= cur;
cout << ans << endl;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 991,596 | 991,597 | u215122692 | cpp |
p03196 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const ll INF = 1e16;
const ll MOD = 1e9 + 7;
#define REP(i, n) for (ll i = 0; i < n; i++)
#define Yes(condition) \
if (condition) { \
cout << "Yes" << '\n'; \
} else { \
cout << "No" << '\n'; \
}
#define YES(condition) \
if (condition) { \
cout << "YES" << '\n'; \
} else { \
cout << "NO" << '\n'; \
}
#define yes(condition) \
if (condition) { \
cout << "yes" << '\n'; \
} else { \
cout << "no" << '\n'; \
}
int main() {
ll n, p;
cin >> n >> p;
map<ll, ll> mp;
ll cnt = 0;
ll m = p;
for (ll i = 2; i <= sqrt(p); i++) {
while (m % i == 0) {
mp[i]++;
m /= i;
cnt++;
// cout << i << endl;
}
}
if (m != 1) {
mp[m]++;
}
ll ans = 1;
for (auto x : mp) {
if (x.second >= n) {
ans *= x.first * (x.second / n);
}
}
cout << ans << endl;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const ll INF = 1e16;
const ll MOD = 1e9 + 7;
#define REP(i, n) for (ll i = 0; i < n; i++)
#define Yes(condition) \
if (condition) { \
cout << "Yes" << '\n'; \
} else { \
cout << "No" << '\n'; \
}
#define YES(condition) \
if (condition) { \
cout << "YES" << '\n'; \
} else { \
cout << "NO" << '\n'; \
}
#define yes(condition) \
if (condition) { \
cout << "yes" << '\n'; \
} else { \
cout << "no" << '\n'; \
}
int main() {
ll n, p;
cin >> n >> p;
map<ll, ll> mp;
ll cnt = 0;
ll m = p;
for (ll i = 2; i <= sqrt(p); i++) {
while (m % i == 0) {
mp[i]++;
m /= i;
cnt++;
// cout << i << endl;
}
}
if (m != 1) {
mp[m]++;
}
ll ans = 1;
for (auto x : mp) {
if (x.second >= n) {
ans *= pow(x.first, (x.second / n));
// cout << x.first << ' ' << x.second << endl;
}
}
cout << ans << endl;
}
| [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 991,604 | 991,605 | u711985352 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, a) for (int i = 0; i < (a); i++)
const ll MOD = 1000000007;
int main() {
ll N, P;
cin >> N >> P;
if (N == 1LL) {
cout << P << endl;
return 0;
}
if (P == 1LL || P <= N) {
cout << 1 << endl;
return 0;
}
map<ll, ll> mp;
ll tmp = P;
for (ll i = 2; i * i <= tmp; i++) {
while (tmp % i == 0) {
mp[i]++;
tmp /= i;
}
}
if (tmp != 1LL)
mp[tmp]++;
ll ans = 1LL;
for (auto m : mp) {
if (m.second >= N) {
ans *= 1LL * m.first * (m.second / N);
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, a) for (int i = 0; i < (a); i++)
const ll MOD = 1000000007;
int main() {
ll N, P;
cin >> N >> P;
if (N == 1LL) {
cout << P << endl;
return 0;
}
if (P == 1LL || P <= N) {
cout << 1 << endl;
return 0;
}
map<ll, ll> mp;
ll tmp = P;
for (ll i = 2; i * i <= tmp; i++) {
while (tmp % i == 0) {
mp[i]++;
tmp /= i;
}
}
if (tmp != 1LL)
mp[tmp]++;
ll ans = 1LL;
for (auto m : mp) {
if (m.second >= N) {
ans *= pow(m.first, (m.second / N));
}
}
cout << ans << endl;
return 0;
} | [
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 991,606 | 991,607 | u046768272 | cpp |
p03196 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define RFOR(i, a, b) for (int i = (a); i > (b); --i)
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define all(c) begin(c), end(c)
#define rall(c) rbegin(c), rend(c)
#define SZ(a) ((ll)a.size())
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
int main() {
ll N, P;
cin >> N >> P;
ll tmpP = P;
if (N == 1)
cout << P << endl;
else {
ll sq = (int)(sqrt((double)P) + 1.0);
vector<ll> a(sq);
for (int i = 2; i < sq; i++) {
if (tmpP == 1)
break;
while (tmpP % i == 0) {
tmpP = tmpP / i;
a[i]++;
}
}
ll ans = 1;
rep(i, sq) {
while (a[i] >= N) {
ans = ans * i;
a[i] = a[i] / N;
}
}
cout << ans << endl;
}
return 0;
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define RFOR(i, a, b) for (int i = (a); i > (b); --i)
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define all(c) begin(c), end(c)
#define rall(c) rbegin(c), rend(c)
#define SZ(a) ((ll)a.size())
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
int main() {
ll N, P;
cin >> N >> P;
ll tmpP = P;
if (N == 1)
cout << P << endl;
else {
ll sq = (int)(sqrt((double)P) + 1.0);
vector<ll> a(sq);
for (int i = 2; i < sq; i++) {
if (tmpP == 1)
break;
while (tmpP % i == 0) {
tmpP = tmpP / i;
a[i]++;
}
}
ll ans = 1;
rep(i, sq) {
while (a[i] >= N) {
ans = ans * i;
a[i] = a[i] - N;
}
}
cout << ans << endl;
}
return 0;
}
| [
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 991,612 | 991,613 | u260638714 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
#define int long long
int n, p;
bool is_prime[1000001];
vector<int> prime;
vector<int> f;
int cnt = 0;
int res = 1;
void sieve() {
for (int i = 2; i <= 1000000; i++)
is_prime[i] = true;
is_prime[0] = is_prime[1] = false;
for (int i = 2; i * i <= 1000000; i++)
if (is_prime[i])
for (int j = i * i; j <= 1000000; j += i)
is_prime[j] = false;
for (int i = 2; i <= 1000000; i++)
if (is_prime[i])
prime.push_back(i);
}
void factorise() {
for (int i = 0; i < prime.size(); i++) {
if (prime[i] > p)
break;
while (p % prime[i] == 0) {
p /= prime[i];
f.push_back(prime[i]);
}
}
if (p != 1)
f.push_back(p);
return;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
sieve();
cin >> n >> p;
if (p == 1) {
cout << 1;
return 0;
}
factorise();
f.push_back(0);
for (int i = ((int)f.size()) - 1; i >= 0; i--) {
if (f[i] != f[i + 1])
cnt = 1;
else
cnt++;
if (cnt == n) {
cnt = 0;
res *= f[i];
}
}
cout << res;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
int n, p;
bool is_prime[1000001];
vector<int> prime;
vector<int> f;
int cnt = 0;
int res = 1;
void sieve() {
for (int i = 2; i <= 1000000; i++)
is_prime[i] = true;
is_prime[0] = is_prime[1] = false;
for (int i = 2; i * i <= 1000000; i++)
if (is_prime[i])
for (int j = i * i; j <= 1000000; j += i)
is_prime[j] = false;
for (int i = 2; i <= 1000000; i++)
if (is_prime[i])
prime.push_back(i);
}
void factorise() {
for (int i = 0; i < prime.size(); i++) {
if (prime[i] > p)
break;
while (p % prime[i] == 0) {
p /= prime[i];
f.push_back(prime[i]);
}
}
if (p != 1)
f.push_back(p);
return;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
sieve();
cin >> n >> p;
if (p == 1) {
cout << 1;
return 0;
}
factorise();
f.push_back(0);
for (int i = ((int)f.size()) - 2; i >= 0; i--) {
if (f[i] != f[i + 1])
cnt = 1;
else
cnt++;
if (cnt == n) {
cnt = 0;
res *= f[i];
}
}
cout << res;
} | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 991,616 | 991,617 | u402883146 | cpp |
p03196 | #include <algorithm>
#include <stdio.h>
using namespace std;
using ll = long long;
int main() {
ll n, p, r = 1;
scanf("%lld %lld", &n, &p);
for (ll x = 2; x * x < p; x++) {
int count = 0;
for (; p % x == 0; count++)
p /= x;
for (int i = 0; i + n <= count; i += n)
r *= x;
}
if (n == 1)
r *= p;
printf("%lld\n", r);
} | #include <algorithm>
#include <stdio.h>
using namespace std;
using ll = long long;
int main() {
ll n, p, r = 1;
scanf("%lld %lld", &n, &p);
for (ll x = 2; x * x <= p; x++) {
int count = 0;
for (; p % x == 0; count++)
p /= x;
for (int i = 0; i + n <= count; i += n)
r *= x;
}
if (n == 1)
r *= p;
printf("%lld\n", r);
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 991,620 | 991,621 | u196520288 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
#define INF_LL (int64)1e18
#define INF (int32)1e9
#define REP(i, n) for (int64 i = 0; i < (n); i++)
#define FOR(i, a, b) for (int64 i = (a); i < (b); i++)
#define all(x) x.begin(), x.end()
#define fs first
#define sc second
using int32 = int_fast32_t;
using uint32 = uint_fast32_t;
using int64 = int_fast64_t;
using uint64 = uint_fast64_t;
using PII = pair<int32, int32>;
using PLL = pair<int64, int64>;
const double eps = 1e-10;
template <typename A, typename B> inline void chmin(A &a, B b) {
if (a > b)
a = b;
}
template <typename A, typename B> inline void chmax(A &a, B b) {
if (a < b)
a = b;
}
const int64 mod = 1e9 + 7;
int64 N, P;
int64 powp(int64 a, int64 b) {
if (b == 0)
return 1;
if (b % 2)
return a * powp(a, b - 1);
int64 ret = powp(a, b / 2);
return ret * ret;
}
int main(void) {
cin >> N >> P;
if (N == 1) {
cout << P << endl;
return 0;
}
int64 res = 1;
for (int64 i = 2; i * i <= P; i++) {
int32 cnt = 0;
while (P % i == 0) {
cnt++;
P /= i;
}
if (cnt >= N)
res *= i * (cnt / N);
}
cout << res << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define INF_LL (int64)1e18
#define INF (int32)1e9
#define REP(i, n) for (int64 i = 0; i < (n); i++)
#define FOR(i, a, b) for (int64 i = (a); i < (b); i++)
#define all(x) x.begin(), x.end()
#define fs first
#define sc second
using int32 = int_fast32_t;
using uint32 = uint_fast32_t;
using int64 = int_fast64_t;
using uint64 = uint_fast64_t;
using PII = pair<int32, int32>;
using PLL = pair<int64, int64>;
const double eps = 1e-10;
template <typename A, typename B> inline void chmin(A &a, B b) {
if (a > b)
a = b;
}
template <typename A, typename B> inline void chmax(A &a, B b) {
if (a < b)
a = b;
}
const int64 mod = 1e9 + 7;
int64 N, P;
int64 powp(int64 a, int64 b) {
if (b == 0)
return 1;
if (b % 2)
return a * powp(a, b - 1);
int64 ret = powp(a, b / 2);
return ret * ret;
}
int main(void) {
cin >> N >> P;
if (N == 1) {
cout << P << endl;
return 0;
}
int64 res = 1;
for (int64 i = 2; i * i <= P; i++) {
int32 cnt = 0;
while (P % i == 0) {
cnt++;
P /= i;
}
if (cnt >= N)
res *= powp(i, cnt / N);
}
cout << res << endl;
}
| [
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.add"
] | 991,622 | 991,623 | u360980679 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
#define INF_LL (int64)1e18
#define INF (int32)1e9
#define REP(i, n) for (int64 i = 0; i < (n); i++)
#define FOR(i, a, b) for (int64 i = (a); i < (b); i++)
#define all(x) x.begin(), x.end()
#define fs first
#define sc second
using int32 = int_fast32_t;
using uint32 = uint_fast32_t;
using int64 = int_fast64_t;
using uint64 = uint_fast64_t;
using PII = pair<int32, int32>;
using PLL = pair<int64, int64>;
const double eps = 1e-10;
template <typename A, typename B> inline void chmin(A &a, B b) {
if (a > b)
a = b;
}
template <typename A, typename B> inline void chmax(A &a, B b) {
if (a < b)
a = b;
}
const int64 mod = 1e9 + 7;
int64 N, P;
int64 powp(int64 a, int64 b) {
if (b == 0)
return 1;
if (b % 2)
return a * powp(a, b - 1);
int64 ret = powp(a, b / 2);
return ret * ret;
}
int main(void) {
cin >> N >> P;
if (N == 1) {
cout << P << endl;
return 0;
}
int64 res = 1;
for (int32 i = 2; i * i <= P; i++) {
int32 cnt = 0;
while (P % i == 0) {
cnt++;
P /= i;
}
if (cnt >= N)
res *= i * (cnt / N);
}
cout << res << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define INF_LL (int64)1e18
#define INF (int32)1e9
#define REP(i, n) for (int64 i = 0; i < (n); i++)
#define FOR(i, a, b) for (int64 i = (a); i < (b); i++)
#define all(x) x.begin(), x.end()
#define fs first
#define sc second
using int32 = int_fast32_t;
using uint32 = uint_fast32_t;
using int64 = int_fast64_t;
using uint64 = uint_fast64_t;
using PII = pair<int32, int32>;
using PLL = pair<int64, int64>;
const double eps = 1e-10;
template <typename A, typename B> inline void chmin(A &a, B b) {
if (a > b)
a = b;
}
template <typename A, typename B> inline void chmax(A &a, B b) {
if (a < b)
a = b;
}
const int64 mod = 1e9 + 7;
int64 N, P;
int64 powp(int64 a, int64 b) {
if (b == 0)
return 1;
if (b % 2)
return a * powp(a, b - 1);
int64 ret = powp(a, b / 2);
return ret * ret;
}
int main(void) {
cin >> N >> P;
if (N == 1) {
cout << P << endl;
return 0;
}
int64 res = 1;
for (int64 i = 2; i * i <= P; i++) {
int32 cnt = 0;
while (P % i == 0) {
cnt++;
P /= i;
}
if (cnt >= N)
res *= powp(i, cnt / N);
}
cout << res << endl;
}
| [
"control_flow.loop.for.initializer.change",
"variable_declaration.type.change",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.add"
] | 991,624 | 991,623 | u360980679 | cpp |
p03196 | #include <cmath>
#include <iostream>
using namespace std;
int main() {
long long N, P;
int count = 0;
int ans = 1;
cin >> P >> N;
if (P == 1) {
cout << N;
return 0;
}
for (long long i = 2; i < sqrt(N); i++) {
while (N % i == 0) {
N /= i;
count++;
}
ans *= (int)(pow(i, (int)(count / P)));
count = 0;
}
cout << ans;
return 0;
}
| #include <cmath>
#include <iostream>
using namespace std;
int main() {
long long N, P;
int count = 0;
int ans = 1;
cin >> P >> N;
if (P == 1) {
cout << N;
return 0;
}
for (long long i = 2; i < sqrt(N) + 3; i++) {
while (N % i == 0) {
N /= i;
count++;
}
ans *= (int)(pow(i, (int)(count / P)));
count = 0;
}
cout << ans;
return 0;
}
| [
"control_flow.loop.for.condition.change"
] | 991,629 | 991,630 | u637067145 | cpp |
p03196 | #include <bits/stdc++.h>
#ifdef _WIN32
#include "debug.hpp"
#endif
using namespace std;
#define rep(i, N) repf(i, 0, N)
#define reps(i, N) repfs(i, 1, N)
#define repf(i, a, b) for (int i = a; i < b; i++)
#define repfs(i, a, b) for (int i = a; i <= b; i++)
#define repr(i, N) for (int i = N - 1; i >= 0; i--)
#define reprs(i, N) for (int i = N; i > 0; i--)
#define pb push_back
template <typename T> void chmax(T &a, T b) { a = max(a, b); };
template <typename T> void chmin(T &a, T b) { a = min(a, b); };
typedef long long ll;
typedef pair<int, int> P;
const int INF = 100000000;
const int MOD = 1000000007;
const int dx[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
const int dy[9] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
//--------------------------------------//
ll n, p;
map<ll, ll> primes;
ll ans = 1;
void update(ll num) {
if (primes[num] == n) {
ans *= num;
}
}
void factorize(ll num) {
bool is_roop = true;
while (is_roop) {
is_roop = false;
for (ll i = 2; i * i <= num; i++)
if (num % i == 0) {
is_roop = true;
num /= i;
primes[i]++;
update(i);
break;
}
}
primes[num]++;
update(num);
}
void solve() {
factorize(p);
cout << ans << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> p;
solve();
return 0;
}
| #include <bits/stdc++.h>
#ifdef _WIN32
#include "debug.hpp"
#endif
using namespace std;
#define rep(i, N) repf(i, 0, N)
#define reps(i, N) repfs(i, 1, N)
#define repf(i, a, b) for (int i = a; i < b; i++)
#define repfs(i, a, b) for (int i = a; i <= b; i++)
#define repr(i, N) for (int i = N - 1; i >= 0; i--)
#define reprs(i, N) for (int i = N; i > 0; i--)
#define pb push_back
template <typename T> void chmax(T &a, T b) { a = max(a, b); };
template <typename T> void chmin(T &a, T b) { a = min(a, b); };
typedef long long ll;
typedef pair<int, int> P;
const int INF = 100000000;
const int MOD = 1000000007;
const int dx[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
const int dy[9] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
//--------------------------------------//
ll n, p;
map<ll, ll> primes;
ll ans = 1;
void update(ll num) {
if (primes[num] % n == 0) {
ans *= num;
}
}
void factorize(ll num) {
bool is_roop = true;
while (is_roop) {
is_roop = false;
for (ll i = 2; i * i <= num; i++)
if (num % i == 0) {
is_roop = true;
num /= i;
primes[i]++;
update(i);
break;
}
}
primes[num]++;
update(num);
}
void solve() {
factorize(p);
cout << ans << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> p;
solve();
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 991,643 | 991,644 | u073946233 | cpp |
p03196 | #include <bits/stdc++.h>
#ifdef _WIN32
#include "debug.hpp"
#endif
using namespace std;
#define rep(i, N) repf(i, 0, N)
#define reps(i, N) repfs(i, 1, N)
#define repf(i, a, b) for (int i = a; i < b; i++)
#define repfs(i, a, b) for (int i = a; i <= b; i++)
#define repr(i, N) for (int i = N - 1; i >= 0; i--)
#define reprs(i, N) for (int i = N; i > 0; i--)
#define pb push_back
template <typename T> void chmax(T &a, T b) { a = max(a, b); };
template <typename T> void chmin(T &a, T b) { a = min(a, b); };
typedef long long ll;
typedef pair<int, int> P;
const int INF = 100000000;
const int MOD = 1000000007;
const int dx[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
const int dy[9] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
//--------------------------------------//
ll n, p;
map<ll, int> primes;
ll ans = 1;
void update(ll num) {
if (primes[num] == n) {
ans *= num;
}
}
void factorize(ll num) {
bool is_roop = true;
while (is_roop) {
is_roop = false;
for (ll i = 2; i * i <= num; i++)
if (num % i == 0) {
is_roop = true;
num /= i;
primes[i]++;
update(i);
break;
}
}
primes[num]++;
update(num);
}
void solve() {
factorize(p);
cout << ans << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> p;
solve();
return 0;
}
| #include <bits/stdc++.h>
#ifdef _WIN32
#include "debug.hpp"
#endif
using namespace std;
#define rep(i, N) repf(i, 0, N)
#define reps(i, N) repfs(i, 1, N)
#define repf(i, a, b) for (int i = a; i < b; i++)
#define repfs(i, a, b) for (int i = a; i <= b; i++)
#define repr(i, N) for (int i = N - 1; i >= 0; i--)
#define reprs(i, N) for (int i = N; i > 0; i--)
#define pb push_back
template <typename T> void chmax(T &a, T b) { a = max(a, b); };
template <typename T> void chmin(T &a, T b) { a = min(a, b); };
typedef long long ll;
typedef pair<int, int> P;
const int INF = 100000000;
const int MOD = 1000000007;
const int dx[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
const int dy[9] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
//--------------------------------------//
ll n, p;
map<ll, ll> primes;
ll ans = 1;
void update(ll num) {
if (primes[num] % n == 0) {
ans *= num;
}
}
void factorize(ll num) {
bool is_roop = true;
while (is_roop) {
is_roop = false;
for (ll i = 2; i * i <= num; i++)
if (num % i == 0) {
is_roop = true;
num /= i;
primes[i]++;
update(i);
break;
}
}
primes[num]++;
update(num);
}
void solve() {
factorize(p);
cout << ans << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> p;
solve();
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 991,645 | 991,644 | u073946233 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, a) FOR(i, 0, a)
typedef long long ll;
ll N, P;
ll pw(ll n, int m) {
ll ret = 1;
while (m) {
if (m & 1) {
ret *= n;
n *= n;
}
m >>= 1;
}
return ret;
}
int main() {
cin >> N >> P;
ll ans = 1;
for (int i = 2; i * i <= P; i++) {
int cnt = 0;
while (P % i == 0) {
P /= i;
cnt++;
}
if (cnt >= N) {
ans *= pw(i, (cnt / N));
}
}
if (P != 1 && N == 1) {
ans *= P;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, a) FOR(i, 0, a)
typedef long long ll;
ll N, P;
ll pw(ll n, int m) {
ll ret = 1;
while (m) {
if (m & 1) {
ret *= n;
}
n *= n;
m >>= 1;
}
return ret;
}
int main() {
cin >> N >> P;
ll ans = 1;
for (ll i = 2; i * i <= P; i++) {
int cnt = 0;
while (P % i == 0) {
P /= i;
cnt++;
}
if (cnt >= N) {
ans *= pw(i, (cnt / N));
}
}
if (P != 1 && N == 1) {
ans *= P;
}
cout << ans << endl;
return 0;
} | [
"control_flow.loop.for.initializer.change",
"variable_declaration.type.change"
] | 991,656 | 991,655 | u533920479 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAX = 1e6 + 5;
bool isPrime[MAX];
int main() {
ll n, p;
cin >> n >> p;
if (n == 1) {
cout << n;
return 0;
}
vector<int> primes;
for (int i = 0; i < MAX; i++) {
isPrime[i] = true;
}
isPrime[0] = false;
isPrime[1] = false;
primes.push_back(2);
for (int i = 2; i < MAX; i++) {
if (!isPrime[i])
continue;
primes.push_back(i);
for (int j = i + i; j < MAX; j += i) {
isPrime[i] = false;
}
}
vector<int> ans(primes.size(), 0);
for (int i = 0; i < primes.size(); i++) {
if (p < primes[i])
break;
while (p % primes[i] == 0) {
ans[i]++;
p /= primes[i];
}
}
ll res = 1;
for (int i = 0; i < ans.size(); i++) {
res *= pow(primes[i], ans[i] / n);
}
cout << res;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAX = 1e6 + 5;
bool isPrime[MAX];
int main() {
ll n, p;
cin >> n >> p;
if (n == 1) {
cout << p;
return 0;
}
vector<int> primes;
for (int i = 0; i < MAX; i++) {
isPrime[i] = true;
}
isPrime[0] = false;
isPrime[1] = false;
primes.push_back(2);
for (int i = 2; i < MAX; i++) {
if (!isPrime[i])
continue;
primes.push_back(i);
for (int j = i + i; j < MAX; j += i) {
isPrime[i] = false;
}
}
vector<int> ans(primes.size(), 0);
for (int i = 0; i < primes.size(); i++) {
if (p < primes[i])
break;
while (p % primes[i] == 0) {
ans[i]++;
p /= primes[i];
}
}
ll res = 1;
for (int i = 0; i < ans.size(); i++) {
res *= pow(primes[i], ans[i] / n);
}
cout << res;
} | [
"identifier.change",
"io.output.change"
] | 991,659 | 991,660 | u385577213 | cpp |
p03196 | /* ---------- STL Libraries ---------- */
// IO library
#include <cstdio>
#include <fstream>
#include <iomanip>
#include <ios>
#include <iostream>
// algorithm library
#include <algorithm>
#include <cmath>
#include <numeric>
#include <random>
// container library
#include <array>
#include <bitset>
#include <deque>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
/* ---------- Namespace ---------- */
using namespace std;
/* ---------- Type ---------- */
using ll = long long;
#define int ll
/* ---------- Constants */
const ll MOD = 1e9 + 7;
const int INF = 1LL << 55;
/* v-v-v-v-v-v-v-v-v Main Part v-v-v-v-v-v-v-v-v */
map<int, int> prime_factor(int n) {
map<int, int> ret;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
ret[i]++;
n /= i;
}
}
if (n != 1)
ret[n] = 1;
return move(ret);
};
signed main() {
int N, P;
cin >> N >> P;
map<int, int> factor = prime_factor(P);
map<int, int>::iterator it;
int ret = 1;
for (it = factor.begin(); it != factor.end(); it++) {
if (it->second >= N) {
ret *= it->first * (it->second / N);
}
}
cout << ret << endl;
return 0;
} | /* ---------- STL Libraries ---------- */
// IO library
#include <cstdio>
#include <fstream>
#include <iomanip>
#include <ios>
#include <iostream>
// algorithm library
#include <algorithm>
#include <cmath>
#include <numeric>
#include <random>
// container library
#include <array>
#include <bitset>
#include <deque>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
/* ---------- Namespace ---------- */
using namespace std;
/* ---------- Type ---------- */
using ll = long long;
#define int ll
/* ---------- Constants */
const ll MOD = 1e9 + 7;
const int INF = 1LL << 55;
/* v-v-v-v-v-v-v-v-v Main Part v-v-v-v-v-v-v-v-v */
map<int, int> prime_factor(int n) {
map<int, int> ret;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
ret[i]++;
n /= i;
}
}
if (n != 1)
ret[n] = 1;
return move(ret);
};
signed main() {
int N, P;
cin >> N >> P;
map<int, int> factor = prime_factor(P);
map<int, int>::iterator it;
int ret = 1;
for (it = factor.begin(); it != factor.end(); it++) {
if (it->second >= N) {
ret *= pow(it->first, it->second / N);
}
}
cout << ret << endl;
return 0;
} | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change"
] | 991,661 | 991,662 | u853132965 | cpp |
p03196 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using namespace placeholders;
using LL = long long;
using ULL = unsigned long long;
using VI = vector<int>;
using VVI = vector<vector<int>>;
using VS = vector<string>;
using ISS = istringstream;
using OSS = ostringstream;
using PII = pair<int, int>;
using VPII = vector<pair<int, int>>;
template <typename T = int> using VT = vector<T>;
template <typename T = int> using VVT = vector<vector<T>>;
template <typename T = int> using LIM = numeric_limits<T>;
template <typename T> inline istream &operator>>(istream &s, vector<T> &v) {
for (T &t : v) {
s >> t;
}
return s;
}
template <typename T>
inline ostream &operator<<(ostream &s, const vector<T> &v) {
for (int i = 0; i < int(v.size()); ++i) {
s << (" " + !i) << v[i];
}
return s;
}
void in_impl(){};
template <typename T, typename... TS> void in_impl(T &head, TS &...tail) {
cin >> head;
in_impl(tail...);
}
#define IN(T, ...) \
T __VA_ARGS__; \
in_impl(__VA_ARGS__);
template <typename T> struct getv_fmt;
template <> struct getv_fmt<int> { static constexpr const char *fmt = "%d"; };
template <> struct getv_fmt<long long> {
static constexpr const char *fmt = "%lld";
};
template <typename T> void getv(std::vector<T> &v) {
for_each(begin(v), end(v), [](T &a) { scanf(getv_fmt<T>::fmt, &a); });
};
template <typename T> inline T fromString(const string &s) {
T res;
istringstream iss(s);
iss >> res;
return res;
}
template <typename T> inline string toString(const T &a) {
ostringstream oss;
oss << a;
return oss.str();
}
#define NUMBERED(name, number) NUMBERED2(name, number)
#define NUMBERED2(name, number) name##_##number
#define REP1(n) REP2(NUMBERED(REP_COUNTER, __LINE__), n)
#define REP2(i, n) REP3(i, 0, n)
#define REP3(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define GET_REP(a, b, c, F, ...) F
#define REP(...) GET_REP(__VA_ARGS__, REP3, REP2, REP1)(__VA_ARGS__)
#define FOR(e, c) for (auto &&e : c)
#define ALL(c) begin(c), end(c)
#define AALL(a) \
(remove_all_extents<decltype(a)>::type *)a, \
(remove_all_extents<decltype(a)>::type *)a + \
sizeof(a) / sizeof(remove_all_extents<decltype(a)>::type)
#define DRANGE(c, p) begin(c), begin(c) + (p), end(c)
#define SZ(v) ((int)(v).size())
#define EXIST(c, e) ((c).find(e) != (c).end())
template <typename T> inline bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <typename T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
#define PB push_back
#define EM emplace
#define EB emplace_back
#define BI back_inserter
#define MP make_pair
#define fst first
#define snd second
#define DUMP(x) cerr << #x << " = " << (x) << endl
// 素因数分解 O( √N )
vector<long long> primeFactorization(long long N) {
if (N == 1) {
return vector<long long>();
}
vector<long long> result;
for (long long p = 2; p * p <= N; p++) {
while (!(N % p)) {
result.push_back(p);
N /= p;
}
}
if (N != 1) {
result.push_back(N);
}
return result;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(12) << fixed;
IN(LL, N, P);
const auto factors = primeFactorization(P);
map<LL, int> counts;
for_each(ALL(factors), [&](const LL p) { ++counts[p]; });
LL res = 1;
FOR(p, counts) {
LL num = p.snd / N;
if (num) {
res *= num * p.fst;
}
}
cout << res << endl;
return 0;
} | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using namespace placeholders;
using LL = long long;
using ULL = unsigned long long;
using VI = vector<int>;
using VVI = vector<vector<int>>;
using VS = vector<string>;
using ISS = istringstream;
using OSS = ostringstream;
using PII = pair<int, int>;
using VPII = vector<pair<int, int>>;
template <typename T = int> using VT = vector<T>;
template <typename T = int> using VVT = vector<vector<T>>;
template <typename T = int> using LIM = numeric_limits<T>;
template <typename T> inline istream &operator>>(istream &s, vector<T> &v) {
for (T &t : v) {
s >> t;
}
return s;
}
template <typename T>
inline ostream &operator<<(ostream &s, const vector<T> &v) {
for (int i = 0; i < int(v.size()); ++i) {
s << (" " + !i) << v[i];
}
return s;
}
void in_impl(){};
template <typename T, typename... TS> void in_impl(T &head, TS &...tail) {
cin >> head;
in_impl(tail...);
}
#define IN(T, ...) \
T __VA_ARGS__; \
in_impl(__VA_ARGS__);
template <typename T> struct getv_fmt;
template <> struct getv_fmt<int> { static constexpr const char *fmt = "%d"; };
template <> struct getv_fmt<long long> {
static constexpr const char *fmt = "%lld";
};
template <typename T> void getv(std::vector<T> &v) {
for_each(begin(v), end(v), [](T &a) { scanf(getv_fmt<T>::fmt, &a); });
};
template <typename T> inline T fromString(const string &s) {
T res;
istringstream iss(s);
iss >> res;
return res;
}
template <typename T> inline string toString(const T &a) {
ostringstream oss;
oss << a;
return oss.str();
}
#define NUMBERED(name, number) NUMBERED2(name, number)
#define NUMBERED2(name, number) name##_##number
#define REP1(n) REP2(NUMBERED(REP_COUNTER, __LINE__), n)
#define REP2(i, n) REP3(i, 0, n)
#define REP3(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define GET_REP(a, b, c, F, ...) F
#define REP(...) GET_REP(__VA_ARGS__, REP3, REP2, REP1)(__VA_ARGS__)
#define FOR(e, c) for (auto &&e : c)
#define ALL(c) begin(c), end(c)
#define AALL(a) \
(remove_all_extents<decltype(a)>::type *)a, \
(remove_all_extents<decltype(a)>::type *)a + \
sizeof(a) / sizeof(remove_all_extents<decltype(a)>::type)
#define DRANGE(c, p) begin(c), begin(c) + (p), end(c)
#define SZ(v) ((int)(v).size())
#define EXIST(c, e) ((c).find(e) != (c).end())
template <typename T> inline bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <typename T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
#define PB push_back
#define EM emplace
#define EB emplace_back
#define BI back_inserter
#define MP make_pair
#define fst first
#define snd second
#define DUMP(x) cerr << #x << " = " << (x) << endl
// 素因数分解 O( √N )
vector<long long> primeFactorization(long long N) {
if (N == 1) {
return vector<long long>();
}
vector<long long> result;
for (long long p = 2; p * p <= N; p++) {
while (!(N % p)) {
result.push_back(p);
N /= p;
}
}
if (N != 1) {
result.push_back(N);
}
return result;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(12) << fixed;
IN(LL, N, P);
const auto factors = primeFactorization(P);
map<LL, int> counts;
for_each(ALL(factors), [&](const LL p) { ++counts[p]; });
LL res = 1;
FOR(p, counts) {
LL num = p.snd / N;
REP(num) { res *= p.fst; }
}
cout << res << endl;
return 0;
} | [
"expression.operation.binary.remove"
] | 991,665 | 991,666 | u938924220 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = (0); (i) < (long long)(n); ++(i))
using ll = long long;
using P = pair<int, int>;
using namespace std;
// 素因数分解
map<ll, ll> prime_factor(ll n) {
map<ll, ll> res;
for (ll i = 2; i * i <= n; ++i) {
while (n % i == 0) {
++res[i];
n /= i;
}
}
if (n != 1)
res[n] = 1;
return res;
}
int main() {
ll N, P;
cin >> N >> P;
if (N == 1) {
cout << P << endl;
return 0;
}
map<ll, ll> tmp = prime_factor(P);
ll ans = 1;
for (auto &t : tmp) {
if (t.second >= N) {
ll tmp = t.second / N;
ans *= t.first * tmp;
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = (0); (i) < (long long)(n); ++(i))
using ll = long long;
using P = pair<int, int>;
using namespace std;
// 素因数分解
map<ll, ll> prime_factor(ll n) {
map<ll, ll> res;
for (ll i = 2; i * i <= n; ++i) {
while (n % i == 0) {
++res[i];
n /= i;
}
}
if (n != 1)
res[n] = 1;
return res;
}
int main() {
ll N, P;
cin >> N >> P;
if (N == 1) {
cout << P << endl;
return 0;
}
map<ll, ll> tmp = prime_factor(P);
ll ans = 1;
for (auto &t : tmp) {
// cerr << t.first << "-> " << t.second << endl;
if (t.second >= N) {
ll tmp = t.second / N;
ans *= powl(t.first, tmp);
}
}
cout << ans << endl;
}
| [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 991,669 | 991,670 | u482544950 | cpp |
p03196 | // warm heart, wagging tail,and a smile just for you!
// ███████████
// ███╬╬╬╬╬╬╬╬╬╬███
// ███╬╬╬╬╬╬╬██╬╬╬╬╬╬███
// ███████████
// ██╬╬╬╬╬████╬╬████╬╬╬╬╬██
// █████████╬╬╬╬╬████████████╬╬╬╬╬██╬╬╬╬╬╬███╬╬╬╬╬██
// ████████╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬█████████╬╬╬╬╬╬██╬╬╬╬╬╬╬██
// ████╬██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬█████████╬╬╬╬╬╬╬╬╬╬╬██
// ███╬╬╬█╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██╬╬███╬╬╬╬╬╬╬█████
// ███╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██╬╬╬████████╬╬╬╬╬██
// ███╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬███╬╬╬╬╬╬╬╬╬███
// ███╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬█████╬╬╬╬╬╬╬██
// ████╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬████╬╬╬╬╬████
// █████████████╬╬╬╬╬╬╬╬██╬╬╬╬╬████╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬█████╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬███╬╬╬╬██████
// ████╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██╬╬██████╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██████╬╬╬╬╬╬╬███████████╬╬╬╬╬╬╬╬██╬╬╬██╬╬╬██
// ███╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬████╬╬╬╬╬╬╬╬╬╬╬█╬╬╬╬╬╬╬██╬╬╬╬╬╬╬╬██
// ██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██╬╬╬╬▓▓▓▓▓▓╬╬╬████╬╬████╬╬╬╬╬╬╬▓▓▓▓▓▓▓▓██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██╬╬╬╬╬╬╬███
// ██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██████▓▓▓▓▓▓▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓▓▓▓▓▓▓██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██╬╬╬╬█████
// ███╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬███╬╬╬╬╬██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬█████╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬████████
// ███╬╬╬╬╬╬╬╬╬╬╬╬╬█████╬╬╬╬╬╬╬╬██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬███╬╬██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██
// ██████████████
// ████╬╬╬╬╬╬███████████████████████████╬╬╬╬╬██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬████
// ███████ █████
// ███████████████████
#include "bits/stdc++.h"
using namespace std;
#define MOD 1000000007
#define INF 1LL << 60
#define fs first
#define sc second
#define pb push_back
#define int long long
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (b - 1); i >= a; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#define ITR(itr, mp) for (auto itr = (mp).begin(); itr != (mp).end(); ++itr)
#define RITR(itr, mp) for (auto itr = (mp).rbegin(); itr != (mp).rend(); ++itr)
#define range(i, a, b) (a) <= (i) && (i) < (b)
#define debug(x) cout << #x << " = " << (x) << endl;
typedef pair<int, int> P;
typedef vector<vector<P>> Graph;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, p;
cin >> n >> p;
map<int, int> mp;
int tmp = p;
for (int i = 2; i <= sqrt(p); i += 2) {
bool flag = true;
for (int j = 3; j <= sqrt(i); j += 2) {
if (i % j == 0) {
flag = false;
break;
}
}
if (flag || i == 2) {
while (tmp % i == 0) {
mp[i]++;
tmp /= i;
}
}
if (i == 2)
i--;
}
if (tmp != 1)
mp[tmp]++;
int ans = 1;
ITR(itr, mp) {
if (itr->sc / n)
ans *= itr->fs * (itr->sc / n);
}
cout << ans << endl;
return 0;
} | // warm heart, wagging tail,and a smile just for you!
// ███████████
// ███╬╬╬╬╬╬╬╬╬╬███
// ███╬╬╬╬╬╬╬██╬╬╬╬╬╬███
// ███████████
// ██╬╬╬╬╬████╬╬████╬╬╬╬╬██
// █████████╬╬╬╬╬████████████╬╬╬╬╬██╬╬╬╬╬╬███╬╬╬╬╬██
// ████████╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬█████████╬╬╬╬╬╬██╬╬╬╬╬╬╬██
// ████╬██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬█████████╬╬╬╬╬╬╬╬╬╬╬██
// ███╬╬╬█╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██╬╬███╬╬╬╬╬╬╬█████
// ███╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██╬╬╬████████╬╬╬╬╬██
// ███╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬███╬╬╬╬╬╬╬╬╬███
// ███╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬█████╬╬╬╬╬╬╬██
// ████╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬████╬╬╬╬╬████
// █████████████╬╬╬╬╬╬╬╬██╬╬╬╬╬████╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬█████╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬███╬╬╬╬██████
// ████╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██╬╬██████╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██████╬╬╬╬╬╬╬███████████╬╬╬╬╬╬╬╬██╬╬╬██╬╬╬██
// ███╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬████╬╬╬╬╬╬╬╬╬╬╬█╬╬╬╬╬╬╬██╬╬╬╬╬╬╬╬██
// ██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██╬╬╬╬▓▓▓▓▓▓╬╬╬████╬╬████╬╬╬╬╬╬╬▓▓▓▓▓▓▓▓██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██╬╬╬╬╬╬╬███
// ██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██████▓▓▓▓▓▓▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓▓▓▓▓▓▓██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██╬╬╬╬█████
// ███╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬███╬╬╬╬╬██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬█████╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬████████
// ███╬╬╬╬╬╬╬╬╬╬╬╬╬█████╬╬╬╬╬╬╬╬██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬███╬╬██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██
// ██████████████
// ████╬╬╬╬╬╬███████████████████████████╬╬╬╬╬██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬████
// ███████ █████
// ███████████████████
#include "bits/stdc++.h"
using namespace std;
#define MOD 1000000007
#define INF 1LL << 60
#define fs first
#define sc second
#define pb push_back
#define int long long
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (b - 1); i >= a; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#define ITR(itr, mp) for (auto itr = (mp).begin(); itr != (mp).end(); ++itr)
#define RITR(itr, mp) for (auto itr = (mp).rbegin(); itr != (mp).rend(); ++itr)
#define range(i, a, b) (a) <= (i) && (i) < (b)
#define debug(x) cout << #x << " = " << (x) << endl;
typedef pair<int, int> P;
typedef vector<vector<P>> Graph;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, p;
cin >> n >> p;
map<int, int> mp;
int tmp = p;
for (int i = 2; i <= sqrt(p); i += 2) {
bool flag = true;
for (int j = 3; j <= sqrt(i); j += 2) {
if (i % j == 0) {
flag = false;
break;
}
}
if (flag || i == 2) {
while (tmp % i == 0) {
mp[i]++;
tmp /= i;
}
}
if (i == 2)
i--;
}
if (tmp != 1)
mp[tmp]++;
int ans = 1;
ITR(itr, mp) {
if (itr->sc / n)
ans *= pow(itr->fs, (itr->sc / n));
}
cout << ans << endl;
return 0;
} | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 991,675 | 991,676 | u239493918 | cpp |
p03196 | #include "bits/stdc++.h"
#define REP(i, n) for (ll i = 0; i < ll(n); ++i)
#define RREP(i, n) for (ll i = ll(n) - 1; i >= 0; --i)
#define FOR(i, m, n) for (ll i = m; i < ll(n); ++i)
#define RFOR(i, m, n) for (ll i = ll(n) - 1; i >= ll(m); --i)
#define ALL(v) (v).begin(), (v).end()
#define UNIQUE(v) v.erase(unique(ALL(v)), v.end());
#define INF 1000000001ll
#define MOD 1000000007ll
#define EPS 1e-9
const int dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const int dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, p;
cin >> n >> p;
if (n == 1) {
cout << p << endl;
return 0;
}
ll ans = 1;
for (ll i = 2; i * i <= p; ++i) {
int cnt = 0;
while (p % i == 0) {
p /= i;
cnt++;
}
ll k = 1;
REP(i, cnt / n) k *= i;
ans *= k;
}
cout << ans << endl;
} | #include "bits/stdc++.h"
#define REP(i, n) for (ll i = 0; i < ll(n); ++i)
#define RREP(i, n) for (ll i = ll(n) - 1; i >= 0; --i)
#define FOR(i, m, n) for (ll i = m; i < ll(n); ++i)
#define RFOR(i, m, n) for (ll i = ll(n) - 1; i >= ll(m); --i)
#define ALL(v) (v).begin(), (v).end()
#define UNIQUE(v) v.erase(unique(ALL(v)), v.end());
#define INF 1000000001ll
#define MOD 1000000007ll
#define EPS 1e-9
const int dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const int dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, p;
cin >> n >> p;
if (n == 1) {
cout << p << endl;
return 0;
}
ll ans = 1;
for (ll i = 2; i * i <= p; ++i) {
int cnt = 0;
while (p % i == 0) {
p /= i;
cnt++;
}
ll k = 1;
REP(j, cnt / n) k *= i;
ans *= k;
}
cout << ans << endl;
} | [
"assignment.variable.change",
"identifier.change",
"call.arguments.change"
] | 991,687 | 991,688 | u918357423 | cpp |
p03196 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<VI> VVI;
#define MP make_pair
#define PB push_back
#define inf 1000000007
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
vector<long long> dev;
vector<int> id;
void prime_factor(long long N) {
for (int i = 2; (long long)i * i <= N; i++) {
int cnt = 0;
while (N % i == 0) {
cnt++;
N /= i;
}
if (cnt) {
dev.push_back(i);
id.push_back(cnt);
}
}
if (N != 1) {
dev.push_back(N);
id.push_back(1);
}
return;
}
int main() {
ll n, p;
cin >> n >> p;
if (n == 1) {
cout << p << endl;
} else {
prime_factor(p);
ll tmp = 1;
for (int i = 0; i < dev.size(); i++) {
for (int j = 0; j < (id[i] / n); i++) {
tmp *= dev[i];
}
}
cout << tmp << endl;
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<VI> VVI;
#define MP make_pair
#define PB push_back
#define inf 1000000007
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
vector<long long> dev;
vector<int> id;
void prime_factor(long long N) {
for (int i = 2; (long long)i * i <= N; i++) {
int cnt = 0;
while (N % i == 0) {
cnt++;
N /= i;
}
if (cnt) {
dev.push_back(i);
id.push_back(cnt);
}
}
if (N != 1) {
dev.push_back(N);
id.push_back(1);
}
return;
}
int main() {
ll n, p;
cin >> n >> p;
if (n == 1) {
cout << p << endl;
} else {
prime_factor(p);
ll tmp = 1;
for (int i = 0; i < dev.size(); i++) {
for (int j = 0; j < (id[i] / n); j++) {
tmp *= dev[i];
}
}
cout << tmp << endl;
}
return 0;
} | [
"identifier.change"
] | 991,689 | 991,690 | u007610006 | cpp |
p03196 | #define _CRT_SECURE_NO_WARNINGS
#define _SCL_SECURE_NO_WARNINGS
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <valarray>
#include <vector>
using namespace std;
typedef unsigned int uint;
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<LL, LL> PP;
#define REP(i, a, n) for (LL i = (a), i##_max = (n); i < i##_max; ++i)
#define REM(i, a, n) for (LL i = (LL)(n)-1, i##min = (a); i >= i##min; --i)
#define ALL(arr) (arr).begin(), (arr).end()
#define FLOAT fixed << setprecision(16)
#define SPEEDUP \
{ \
cin.tie(NULL); \
ios::sync_with_stdio(false); \
}
const int INF = 0x3FFFFFFF;
const LL INFLL = 0x3FFFFFFF3FFFFFFF;
const double INFD = 1.0e+308;
const string INFSTR = "\x7f";
const double EPS = 1.0e-9;
void YesNo(bool b) { cout << (b ? "Yes" : "No") << endl; }
void YESNO(bool b) { cout << (b ? "YES" : "NO") << endl; }
template <class T, class U>
istream &operator>>(istream &ist, pair<T, U> &right) {
return ist >> right.first >> right.second;
}
template <class T, class U>
ostream &operator<<(ostream &ost, const pair<T, U> &right) {
return ost << right.first << ' ' << right.second;
}
template <class T, class TCompatible, size_t N>
void Fill(T (&dest)[N], const TCompatible &val) {
fill(dest, dest + N, val);
}
template <class T, class TCompatible, size_t M, size_t N>
void Fill(T (&dest)[M][N], const TCompatible &val) {
for (int i = 0; i < M; ++i)
Fill(dest[i], val);
}
template <class T> T Compare(T left, T right) {
return left > right ? 1 : (left < right ? -1 : 0);
}
istream &Ignore(istream &ist) {
string s;
ist >> s;
return ist;
}
bool Inside(int i, int j, int h, int w) {
return i >= 0 && i < h && j >= 0 && j < w;
}
template <class T> T Next() {
T buf;
cin >> buf;
return buf;
}
#ifdef ONLY_MY_ENVIR
#include "BIT.h"
#include "Factorization.h"
#include "FlowSolver.h"
#include "Geometry.h"
#include "Global.h"
#include "Graph.h"
#include "IntMod.h"
#include "Math.h"
#include "Matrix.h"
#include "Position.h"
#include "Range.h"
#include "Rational.h"
#include "SegmentTree.h"
#include "SegmentTree2D.h"
#include "SuffixArray.h"
#include "Tree.h"
#include "UnionFind.h"
#endif
#ifdef __GNUC__
typedef __int128 LLL;
istream &operator>>(istream &ist, __int128 &val) {
LL tmp;
ist >> tmp;
val = tmp;
return ist;
}
ostream &operator<<(ostream &ost, __int128 val) {
LL tmp = val;
ost << tmp;
return ost;
}
#endif
#if 1234567891
#include <array>
#include <random>
#include <unordered_map>
#include <unordered_set>
template <typename T>
using PriorityQ = priority_queue<T, vector<T>, greater<T>>;
// template <class T>
// auto Is(const T& value) { return [value](const auto& comparand) -> bool {
// return comparand == value; }; }
#endif
LL N, K;
map<LL, int> Factor(LL n) {
map<LL, int> mp;
for (LL i = 2; i * i < n; ++i) {
int cnt = 0;
while (n % i == 0) {
++cnt;
n /= i;
}
if (cnt != 0) {
mp[i] = cnt;
}
}
if (n != 1) {
mp[n] = 1;
}
return mp;
}
int main() {
cin >> N >> K;
auto mp = Factor(K);
LL prod = 1;
for (auto &&p : mp) {
int cnt = p.second / N;
while (cnt--) {
prod *= p.first;
}
}
cout << prod << endl;
return 0;
}
| #define _CRT_SECURE_NO_WARNINGS
#define _SCL_SECURE_NO_WARNINGS
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <valarray>
#include <vector>
using namespace std;
typedef unsigned int uint;
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<LL, LL> PP;
#define REP(i, a, n) for (LL i = (a), i##_max = (n); i < i##_max; ++i)
#define REM(i, a, n) for (LL i = (LL)(n)-1, i##min = (a); i >= i##min; --i)
#define ALL(arr) (arr).begin(), (arr).end()
#define FLOAT fixed << setprecision(16)
#define SPEEDUP \
{ \
cin.tie(NULL); \
ios::sync_with_stdio(false); \
}
const int INF = 0x3FFFFFFF;
const LL INFLL = 0x3FFFFFFF3FFFFFFF;
const double INFD = 1.0e+308;
const string INFSTR = "\x7f";
const double EPS = 1.0e-9;
void YesNo(bool b) { cout << (b ? "Yes" : "No") << endl; }
void YESNO(bool b) { cout << (b ? "YES" : "NO") << endl; }
template <class T, class U>
istream &operator>>(istream &ist, pair<T, U> &right) {
return ist >> right.first >> right.second;
}
template <class T, class U>
ostream &operator<<(ostream &ost, const pair<T, U> &right) {
return ost << right.first << ' ' << right.second;
}
template <class T, class TCompatible, size_t N>
void Fill(T (&dest)[N], const TCompatible &val) {
fill(dest, dest + N, val);
}
template <class T, class TCompatible, size_t M, size_t N>
void Fill(T (&dest)[M][N], const TCompatible &val) {
for (int i = 0; i < M; ++i)
Fill(dest[i], val);
}
template <class T> T Compare(T left, T right) {
return left > right ? 1 : (left < right ? -1 : 0);
}
istream &Ignore(istream &ist) {
string s;
ist >> s;
return ist;
}
bool Inside(int i, int j, int h, int w) {
return i >= 0 && i < h && j >= 0 && j < w;
}
template <class T> T Next() {
T buf;
cin >> buf;
return buf;
}
#ifdef ONLY_MY_ENVIR
#include "BIT.h"
#include "Factorization.h"
#include "FlowSolver.h"
#include "Geometry.h"
#include "Global.h"
#include "Graph.h"
#include "IntMod.h"
#include "Math.h"
#include "Matrix.h"
#include "Position.h"
#include "Range.h"
#include "Rational.h"
#include "SegmentTree.h"
#include "SegmentTree2D.h"
#include "SuffixArray.h"
#include "Tree.h"
#include "UnionFind.h"
#endif
#ifdef __GNUC__
typedef __int128 LLL;
istream &operator>>(istream &ist, __int128 &val) {
LL tmp;
ist >> tmp;
val = tmp;
return ist;
}
ostream &operator<<(ostream &ost, __int128 val) {
LL tmp = val;
ost << tmp;
return ost;
}
#endif
#if 1234567891
#include <array>
#include <random>
#include <unordered_map>
#include <unordered_set>
template <typename T>
using PriorityQ = priority_queue<T, vector<T>, greater<T>>;
// template <class T>
// auto Is(const T& value) { return [value](const auto& comparand) -> bool {
// return comparand == value; }; }
#endif
LL N, K;
map<LL, int> Factor(LL n) {
map<LL, int> mp;
for (LL i = 2; i * i <= n; ++i) {
int cnt = 0;
while (n % i == 0) {
++cnt;
n /= i;
}
if (cnt != 0) {
mp[i] = cnt;
}
}
if (n != 1) {
mp[n] = 1;
}
return mp;
}
int main() {
cin >> N >> K;
auto mp = Factor(K);
LL prod = 1;
for (auto &&p : mp) {
LL cnt = p.second / N;
while (cnt--) {
prod *= p.first;
}
}
cout << prod << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"variable_declaration.type.change"
] | 991,691 | 991,692 | u993619636 | cpp |
p03196 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define REP(i, n) for (ll i = 0; i < n; i++)
template <class T>
using reversed_priority_queue = priority_queue<T, vector<T>, greater<T>>;
typedef long long ll;
vector<long long> PrimeFactorization(long long n) {
vector<long long> res;
long long t = n;
for (long long i = 2; i * i <= t;) {
if (n % i == 0)
res.push_back(i), n /= i;
else
i++;
}
if (n != 1)
res.push_back(n);
return res;
}
ll pow_t(ll n, ll k) {
ll ret = 1LL;
REP(i, k) ret *= n;
return ret;
}
int main() {
ll N, P;
cin >> N >> P;
vector<ll> prime = PrimeFactorization(P);
map<ll, ll> cnt;
REP(i, prime.size()) { cnt[prime[i]]++; }
ll ans = 1LL;
for (auto itr = cnt.begin(); itr != cnt.end(); itr++) {
ll num = itr->first;
ll sum = itr->second;
if (sum / N > 0) {
ans *= pow_t((sum / N), num);
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define REP(i, n) for (ll i = 0; i < n; i++)
template <class T>
using reversed_priority_queue = priority_queue<T, vector<T>, greater<T>>;
typedef long long ll;
vector<long long> PrimeFactorization(long long n) {
vector<long long> res;
long long t = n;
for (long long i = 2; i * i <= t;) {
if (n % i == 0)
res.push_back(i), n /= i;
else
i++;
}
if (n != 1)
res.push_back(n);
return res;
}
ll pow_t(ll n, ll k) {
ll ret = 1LL;
REP(i, k) ret *= n;
return ret;
}
int main() {
ll N, P;
cin >> N >> P;
vector<ll> prime = PrimeFactorization(P);
map<ll, ll> cnt;
REP(i, prime.size()) { cnt[prime[i]]++; }
ll ans = 1LL;
for (auto itr = cnt.begin(); itr != cnt.end(); itr++) {
ll num = itr->first;
ll sum = itr->second;
if (sum / N > 0) {
ans *= pow_t(num, (sum / N));
}
}
cout << ans << endl;
return 0;
}
| [
"call.arguments.add",
"call.arguments.change"
] | 991,695 | 991,696 | u693386219 | cpp |
p03196 | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <ciso646>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n)-1; i >= 0; i--)
#define inf 0x3f3f3f3f3f3f3f3f
#define ALL(a) (a).begin(), (a).end()
#define DEBUG(x) // cerr<<#x<<": "<<x<<endl
#define ll long long
#define ull unsigned long long
using pii = pair<ll, ll>;
#define eps 1e-14
#define SETUP \
cin.tie(0), ios::sync_with_stdio(false), \
cout << setprecision(15) << std::fixed;
template <class T> using vec2 = std::vector<vector<T>>;
namespace {
struct input_returnner {
ll N;
input_returnner(ll N_ = 0) : N(N_) {}
template <typename T> operator vector<T>() const {
vector<T> res(N);
for (auto &a : res)
cin >> a;
return std::move(res);
}
template <typename T> operator T() const {
T res;
cin >> res;
return res;
}
template <typename T> T operator-(T right) {
return T(input_returnner()) - right;
}
template <typename T> T operator+(T right) {
return T(input_returnner()) + right;
}
template <typename T> T operator*(T right) {
return T(input_returnner()) * right;
}
template <typename T> T operator/(T right) {
return T(input_returnner()) / right;
}
template <typename T> T operator<<(T right) {
return T(input_returnner()) << right;
}
template <typename T> T operator>>(T right) {
return T(input_returnner()) >> right;
}
};
template <typename T> input_returnner in() { return in<T>(); }
input_returnner in() { return input_returnner(); }
input_returnner in(ll N) { return std::move(input_returnner(N)); }
} // namespace
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
template <typename T> struct is_vector : std::false_type {};
template <typename T> struct is_vector<std::vector<T>> : std::true_type {};
template <typename T> constexpr bool is_vector_v = is_vector<T>::value;
template <typename T>
std::ostream &operator<<(std::ostream &out, const std::vector<T> &v) {
if (!v.empty()) {
for (int i = 0; i < v.size(); ++i) {
out << v[i] << (i == v.size() - 1 ? "\n" : (is_vector_v<T> ? "" : ", "));
}
}
return out;
}
namespace std {
// ref:
// https://stackoverflow.com/questions/7110301/generic-hash-for-tuples-in-unordered-map-unordered-set
template <class T> inline void hash_combine(std::size_t &seed, T const &v) {
seed ^= std::hash<T>()(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
// Recursive template code derived from Matthieu M.
template <class Tuple, size_t Index = std::tuple_size<Tuple>::value - 1>
struct HashValueImpl {
static void apply(size_t &seed, Tuple const &tuple) {
HashValueImpl<Tuple, Index - 1>::apply(seed, tuple);
hash_combine(seed, std::get<Index>(tuple));
}
};
template <class Tuple> struct HashValueImpl<Tuple, 0> {
static void apply(size_t &seed, Tuple const &tuple) {
hash_combine(seed, std::get<0>(tuple));
}
};
template <typename... TT> struct hash<std::tuple<TT...>> {
size_t operator()(std::tuple<TT...> const &tt) const {
size_t seed = 0;
HashValueImpl<std::tuple<TT...>>::apply(seed, tt);
return seed;
}
};
template <class T, class U> class hash<std::pair<T, U>> {
public:
size_t operator()(const std::pair<T, U> &x) const {
return hash<std::tuple<T, U>>()(std::tie(x.first, x.second));
}
};
} // namespace std
// ref: https://stackoverflow.com/questions/6245735/pretty-print-stdtuple
namespace aux {
template <std::size_t...> struct seq {};
template <std::size_t N, std::size_t... Is>
struct gen_seq : gen_seq<N - 1, N - 1, Is...> {};
template <std::size_t... Is> struct gen_seq<0, Is...> : seq<Is...> {};
template <class Ch, class Tr, class Tuple, std::size_t... Is>
void print_tuple(std::basic_ostream<Ch, Tr> &os, Tuple const &t, seq<Is...>) {
using swallow = int[];
(void)swallow{0,
(void(os << (Is == 0 ? "" : ", ") << std::get<Is>(t)), 0)...};
}
} // namespace aux
template <class Ch, class Tr, class... Args>
auto operator<<(std::basic_ostream<Ch, Tr> &os, std::tuple<Args...> const &t)
-> std::basic_ostream<Ch, Tr> & {
os << "(";
aux::print_tuple(os, t, aux::gen_seq<sizeof...(Args)>());
return os << ")";
}
template <class S, class T>
std::ostream &operator<<(std::ostream &os, const std::pair<S, T> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
// ref:
// https://stackoverflow.com/questions/8542591/c11-reverse-range-based-for-loo�Fp
template <typename T> struct reversion_wrapper { T &iterable; };
template <typename T> auto begin(reversion_wrapper<T> w) {
return std::rbegin(w.iterable);
}
template <typename T> auto end(reversion_wrapper<T> w) {
return std::rend(w.iterable);
}
template <typename T> reversion_wrapper<T> REV(T &&iterable) {
return {iterable};
}
template <class T> bool inside(T left, T val, T right) {
return left <= val and val < right;
}
template <class T> T bitCount(T num) {
T res = 0;
while (num > 0) {
if (num & 1)
++res;
num >>= 1;
}
return res;
}
ll MOD = 1e9 + 7;
void solve();
signed main() {
SETUP;
#ifdef _DEBUG
while (true) {
#endif
solve();
#ifdef _DEBUG
cout << "-------" << endl;
}
#endif
#ifdef _DEBUG
system("pause");
#endif
return 0;
}
#define int ll
// template
class prime {
private:
public:
std::vector<int> primes;
std::vector<bool> isPrime;
prime(int num = 0) {
if (num == 0)
return;
isPrime.resize(num + 1);
fill(isPrime.begin(), isPrime.end(), true);
int ma = sqrt(num) + 1;
isPrime[0] = isPrime[1] = false;
int cnt = 0;
for (int i = 2; i <= ma; ++i)
if (isPrime[i]) {
for (int j = 2; i * j <= num; ++j) {
isPrime[i * j] = false;
cnt++;
}
}
primes.reserve(cnt);
for (int i = 0; i < isPrime.size(); ++i)
if (isPrime[i]) {
primes.push_back(i);
}
}
bool IsPrime(int num) {
if (num < isPrime.size())
return isPrime[num];
for (auto p : primes) {
if (num % p == 0)
return false;
}
int ma = sqrt(num) + 1;
for (int i = primes.back(); i <= ma; i += 2) {
if (num % i == 0)
return false;
}
return true;
}
std::map<int, int> GetFactor(int num) {
std::map<int, int> res;
int a = 2;
auto it = primes.begin();
while (num >= a * a) {
if (num % a == 0) {
res[a]++;
num /= a;
} else {
++it;
if (it == primes.end()) {
break;
}
a = *it;
}
}
res[num]++;
return res;
}
};
int gcd(int a, int b) { return b != 0 ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a * b / gcd(a, b); }
// a x + b y = gcd(a, b)
int extgcd(int a, int b, int &x, int &y) {
int g = a;
x = 1;
y = 0;
if (b != 0)
g = extgcd(b, a % b, y, x), y -= (a / b) * x;
return g;
}
inline long long mod(long long a, long long m) { return (a % m + m) % m; }
// condition: gcd(a,m) == 1
long long modinv(long long a, long long m) {
long long x, y;
extgcd(a, m, x, y);
return mod(x, m);
}
void solve() {
int N, P;
cin >> N >> P;
prime primes(sqrt(P) + 1);
auto factors = primes.GetFactor(P);
int res = 1;
for (auto &a : factors) {
int cnt = a.second / N;
if (cnt == 0)
continue;
res *= a.first * cnt;
}
cout << res << endl;
}
| #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <ciso646>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n)-1; i >= 0; i--)
#define inf 0x3f3f3f3f3f3f3f3f
#define ALL(a) (a).begin(), (a).end()
#define DEBUG(x) // cerr<<#x<<": "<<x<<endl
#define ll long long
#define ull unsigned long long
using pii = pair<ll, ll>;
#define eps 1e-14
#define SETUP \
cin.tie(0), ios::sync_with_stdio(false), \
cout << setprecision(15) << std::fixed;
template <class T> using vec2 = std::vector<vector<T>>;
namespace {
struct input_returnner {
ll N;
input_returnner(ll N_ = 0) : N(N_) {}
template <typename T> operator vector<T>() const {
vector<T> res(N);
for (auto &a : res)
cin >> a;
return std::move(res);
}
template <typename T> operator T() const {
T res;
cin >> res;
return res;
}
template <typename T> T operator-(T right) {
return T(input_returnner()) - right;
}
template <typename T> T operator+(T right) {
return T(input_returnner()) + right;
}
template <typename T> T operator*(T right) {
return T(input_returnner()) * right;
}
template <typename T> T operator/(T right) {
return T(input_returnner()) / right;
}
template <typename T> T operator<<(T right) {
return T(input_returnner()) << right;
}
template <typename T> T operator>>(T right) {
return T(input_returnner()) >> right;
}
};
template <typename T> input_returnner in() { return in<T>(); }
input_returnner in() { return input_returnner(); }
input_returnner in(ll N) { return std::move(input_returnner(N)); }
} // namespace
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
template <typename T> struct is_vector : std::false_type {};
template <typename T> struct is_vector<std::vector<T>> : std::true_type {};
template <typename T> constexpr bool is_vector_v = is_vector<T>::value;
template <typename T>
std::ostream &operator<<(std::ostream &out, const std::vector<T> &v) {
if (!v.empty()) {
for (int i = 0; i < v.size(); ++i) {
out << v[i] << (i == v.size() - 1 ? "\n" : (is_vector_v<T> ? "" : ", "));
}
}
return out;
}
namespace std {
// ref:
// https://stackoverflow.com/questions/7110301/generic-hash-for-tuples-in-unordered-map-unordered-set
template <class T> inline void hash_combine(std::size_t &seed, T const &v) {
seed ^= std::hash<T>()(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
// Recursive template code derived from Matthieu M.
template <class Tuple, size_t Index = std::tuple_size<Tuple>::value - 1>
struct HashValueImpl {
static void apply(size_t &seed, Tuple const &tuple) {
HashValueImpl<Tuple, Index - 1>::apply(seed, tuple);
hash_combine(seed, std::get<Index>(tuple));
}
};
template <class Tuple> struct HashValueImpl<Tuple, 0> {
static void apply(size_t &seed, Tuple const &tuple) {
hash_combine(seed, std::get<0>(tuple));
}
};
template <typename... TT> struct hash<std::tuple<TT...>> {
size_t operator()(std::tuple<TT...> const &tt) const {
size_t seed = 0;
HashValueImpl<std::tuple<TT...>>::apply(seed, tt);
return seed;
}
};
template <class T, class U> class hash<std::pair<T, U>> {
public:
size_t operator()(const std::pair<T, U> &x) const {
return hash<std::tuple<T, U>>()(std::tie(x.first, x.second));
}
};
} // namespace std
// ref: https://stackoverflow.com/questions/6245735/pretty-print-stdtuple
namespace aux {
template <std::size_t...> struct seq {};
template <std::size_t N, std::size_t... Is>
struct gen_seq : gen_seq<N - 1, N - 1, Is...> {};
template <std::size_t... Is> struct gen_seq<0, Is...> : seq<Is...> {};
template <class Ch, class Tr, class Tuple, std::size_t... Is>
void print_tuple(std::basic_ostream<Ch, Tr> &os, Tuple const &t, seq<Is...>) {
using swallow = int[];
(void)swallow{0,
(void(os << (Is == 0 ? "" : ", ") << std::get<Is>(t)), 0)...};
}
} // namespace aux
template <class Ch, class Tr, class... Args>
auto operator<<(std::basic_ostream<Ch, Tr> &os, std::tuple<Args...> const &t)
-> std::basic_ostream<Ch, Tr> & {
os << "(";
aux::print_tuple(os, t, aux::gen_seq<sizeof...(Args)>());
return os << ")";
}
template <class S, class T>
std::ostream &operator<<(std::ostream &os, const std::pair<S, T> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
// ref:
// https://stackoverflow.com/questions/8542591/c11-reverse-range-based-for-loo�Fp
template <typename T> struct reversion_wrapper { T &iterable; };
template <typename T> auto begin(reversion_wrapper<T> w) {
return std::rbegin(w.iterable);
}
template <typename T> auto end(reversion_wrapper<T> w) {
return std::rend(w.iterable);
}
template <typename T> reversion_wrapper<T> REV(T &&iterable) {
return {iterable};
}
template <class T> bool inside(T left, T val, T right) {
return left <= val and val < right;
}
template <class T> T bitCount(T num) {
T res = 0;
while (num > 0) {
if (num & 1)
++res;
num >>= 1;
}
return res;
}
ll MOD = 1e9 + 7;
void solve();
signed main() {
SETUP;
#ifdef _DEBUG
while (true) {
#endif
solve();
#ifdef _DEBUG
cout << "-------" << endl;
}
#endif
#ifdef _DEBUG
system("pause");
#endif
return 0;
}
#define int ll
// template
class prime {
private:
public:
std::vector<int> primes;
std::vector<bool> isPrime;
prime(int num = 0) {
if (num == 0)
return;
isPrime.resize(num + 1);
fill(isPrime.begin(), isPrime.end(), true);
int ma = sqrt(num) + 1;
isPrime[0] = isPrime[1] = false;
int cnt = 0;
for (int i = 2; i <= ma; ++i)
if (isPrime[i]) {
for (int j = 2; i * j <= num; ++j) {
isPrime[i * j] = false;
cnt++;
}
}
primes.reserve(cnt);
for (int i = 0; i < isPrime.size(); ++i)
if (isPrime[i]) {
primes.push_back(i);
}
}
bool IsPrime(int num) {
if (num < isPrime.size())
return isPrime[num];
for (auto p : primes) {
if (num % p == 0)
return false;
}
int ma = sqrt(num) + 1;
for (int i = primes.back(); i <= ma; i += 2) {
if (num % i == 0)
return false;
}
return true;
}
std::map<int, int> GetFactor(int num) {
std::map<int, int> res;
int a = 2;
auto it = primes.begin();
while (num >= a * a) {
if (num % a == 0) {
res[a]++;
num /= a;
} else {
++it;
if (it == primes.end()) {
break;
}
a = *it;
}
}
res[num]++;
return res;
}
};
int gcd(int a, int b) { return b != 0 ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a * b / gcd(a, b); }
// a x + b y = gcd(a, b)
int extgcd(int a, int b, int &x, int &y) {
int g = a;
x = 1;
y = 0;
if (b != 0)
g = extgcd(b, a % b, y, x), y -= (a / b) * x;
return g;
}
inline long long mod(long long a, long long m) { return (a % m + m) % m; }
// condition: gcd(a,m) == 1
long long modinv(long long a, long long m) {
long long x, y;
extgcd(a, m, x, y);
return mod(x, m);
}
void solve() {
int N, P;
cin >> N >> P;
prime primes(sqrt(P) + 1);
auto factors = primes.GetFactor(P);
int res = 1;
for (auto &a : factors) {
int cnt = a.second / N;
if (cnt == 0)
continue;
res *= pow(a.first, cnt);
}
cout << res << endl;
}
| [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 991,702 | 991,703 | u579875569 | cpp |
p03196 | #include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define REP2(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define REPD(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define REP(i, n) REP2(i, 0, n)
#define ALL(c) (c).begin(), (c).end()
#define PB(e) push_back(e)
#define FOREACH(i, c) for (auto i = (c).begin(); i != (c).end(); ++i)
#define MP(a, b) make_pair(a, b)
#define BIT(n, m) (((n) >> (m)) & 1)
typedef long long ll;
template <typename S, typename T>
ostream &operator<<(ostream &out, const pair<S, T> &p) {
out << "(" << p.first << ", " << p.second << ")";
return out;
}
template <typename T> ostream &operator<<(ostream &out, const vector<T> &v) {
out << "[";
REP(i, v.size()) {
if (i > 0)
out << ", ";
out << v[i];
}
out << "]";
return out;
}
int main(int argc, char *argv[]) {
ll N, P;
cin >> N >> P;
if (N == 1) {
cout << P << endl;
return 0;
}
ll res = 1;
for (ll i = 2; i * i <= P; i++) {
int count = 0;
while (P % i == 0) {
P /= i;
count++;
}
if (count >= N) {
res *= i;
}
}
cout << res << endl;
return 0;
}
| #include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define REP2(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define REPD(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define REP(i, n) REP2(i, 0, n)
#define ALL(c) (c).begin(), (c).end()
#define PB(e) push_back(e)
#define FOREACH(i, c) for (auto i = (c).begin(); i != (c).end(); ++i)
#define MP(a, b) make_pair(a, b)
#define BIT(n, m) (((n) >> (m)) & 1)
typedef long long ll;
template <typename S, typename T>
ostream &operator<<(ostream &out, const pair<S, T> &p) {
out << "(" << p.first << ", " << p.second << ")";
return out;
}
template <typename T> ostream &operator<<(ostream &out, const vector<T> &v) {
out << "[";
REP(i, v.size()) {
if (i > 0)
out << ", ";
out << v[i];
}
out << "]";
return out;
}
int main(int argc, char *argv[]) {
ll N, P;
cin >> N >> P;
if (N == 1) {
cout << P << endl;
return 0;
}
ll res = 1;
for (ll i = 2; i * i <= P; i++) {
int count = 0;
while (P % i == 0) {
P /= i;
count++;
}
while (count >= N) {
res *= i;
count -= N;
}
}
cout << res << endl;
return 0;
}
| [
"control_flow.branch.while.replace.add",
"control_flow.loop.if.replace.remove",
"assignment.add"
] | 991,706 | 991,707 | u202239169 | cpp |
p03194 | /*
このコード、と～おれ!
Be accepted!
∧＿∧
（｡･ω･｡)つ━☆・*。
⊂ ノ ・゜+.
しーＪ °。+ *´¨)
.· ´¸.·*´¨) ¸.·*¨)
(¸.·´ (¸.·'* ☆
*/
#include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <stdio.h>
#include <string>
#include <unordered_map>
#include <vector>
#pragma GCC optimize("Ofast")
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep1(i, n) for (int i = 1; i <= (n); ++i)
#define rep2(i, n) for (int i = 2; i < (n); ++i)
#define repr(i, n) for (int i = n; i >= 0; --i)
#define reprm(i, n) for (int i = n - 1; i >= 0; --i)
#define printynl(a) printf(a ? "yes\n" : "no\n")
#define printyn(a) printf(a ? "Yes\n" : "No\n")
#define printYN(a) printf(a ? "YES\n" : "NO\n")
#define printin(a) printf(a ? "possible\n" : "inposible\n")
#define printdb(a) printf("%.50lf\n", a) //少数出力
#define printdbd(a) printf("%.16lf\n", a) //少数出力(桁少なめ)
#define prints(s) printf("%s\n", s.c_str()) // string出力
#define all(x) (x).begin(), (x).end()
#define allsum(a, b, c) ((a + b) * c / 2) //等差数列の和、初項,末項,項数
#define pb push_back
#define priq priority_queue
#define rpriq priq<int, vector<int>, greater<int>>
#define deg_to_rad(deg) (((deg) / 360.0) * 2.0 * PI)
#define rad_to_deg(rad) (((rad) / 2.0 / PI) * 360.0)
#define Please return
#define AC 0
using ll = long long;
constexpr int INF = 1073741823;
constexpr int MINF = -1073741823;
constexpr ll LINF = ll(4661686018427387903);
constexpr ll MOD = 1000000007;
const double PI = acos(-1);
using namespace std;
void scans(string &str) {
char c;
str = "";
scanf("%c", &c);
if (c == '\n')
scanf("%c", &c); //最初の改行対策
while (c != '\n' && c != -1) {
str += c;
scanf("%c", &c);
}
}
void scanc(char &str) {
char c;
scanf("%c", &c);
if (c == -1)
return;
while (c == '\n') {
scanf("%c", &c);
}
str = c;
}
double acot(double x) { return PI / 2 - atan(x); }
/*-----------------------------------------ここからコード-----------------------------------------*/
map<int64_t, int64_t> prime_factor(int64_t n) { //素因数分解
map<int64_t, int64_t> ret;
for (int64_t 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 n, p;
scanf("%lld%lld", &n, &p);
auto a = prime_factor(p);
ll ans = 1;
for (auto aa : a) {
if (aa.second >= n)
ans *= aa.first * (aa.second / n);
}
printf("%lld\n", ans);
Please AC;
}
| /*
このコード、と～おれ!
Be accepted!
∧＿∧
（｡･ω･｡)つ━☆・*。
⊂ ノ ・゜+.
しーＪ °。+ *´¨)
.· ´¸.·*´¨) ¸.·*¨)
(¸.·´ (¸.·'* ☆
*/
#include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <stdio.h>
#include <string>
#include <unordered_map>
#include <vector>
#pragma GCC optimize("Ofast")
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep1(i, n) for (int i = 1; i <= (n); ++i)
#define rep2(i, n) for (int i = 2; i < (n); ++i)
#define repr(i, n) for (int i = n; i >= 0; --i)
#define reprm(i, n) for (int i = n - 1; i >= 0; --i)
#define printynl(a) printf(a ? "yes\n" : "no\n")
#define printyn(a) printf(a ? "Yes\n" : "No\n")
#define printYN(a) printf(a ? "YES\n" : "NO\n")
#define printin(a) printf(a ? "possible\n" : "inposible\n")
#define printdb(a) printf("%.50lf\n", a) //少数出力
#define printdbd(a) printf("%.16lf\n", a) //少数出力(桁少なめ)
#define prints(s) printf("%s\n", s.c_str()) // string出力
#define all(x) (x).begin(), (x).end()
#define allsum(a, b, c) ((a + b) * c / 2) //等差数列の和、初項,末項,項数
#define pb push_back
#define priq priority_queue
#define rpriq priq<int, vector<int>, greater<int>>
#define deg_to_rad(deg) (((deg) / 360.0) * 2.0 * PI)
#define rad_to_deg(rad) (((rad) / 2.0 / PI) * 360.0)
#define Please return
#define AC 0
using ll = long long;
constexpr int INF = 1073741823;
constexpr int MINF = -1073741823;
constexpr ll LINF = ll(4661686018427387903);
constexpr ll MOD = 1000000007;
const double PI = acos(-1);
using namespace std;
void scans(string &str) {
char c;
str = "";
scanf("%c", &c);
if (c == '\n')
scanf("%c", &c); //最初の改行対策
while (c != '\n' && c != -1) {
str += c;
scanf("%c", &c);
}
}
void scanc(char &str) {
char c;
scanf("%c", &c);
if (c == -1)
return;
while (c == '\n') {
scanf("%c", &c);
}
str = c;
}
double acot(double x) { return PI / 2 - atan(x); }
/*-----------------------------------------ここからコード-----------------------------------------*/
map<int64_t, int64_t> prime_factor(int64_t n) { //素因数分解
map<int64_t, int64_t> ret;
for (int64_t 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 n, p;
scanf("%lld%lld", &n, &p);
auto a = prime_factor(p);
ll ans = 1;
for (auto aa : a) {
if (aa.second >= n)
ans *= pow(aa.first, aa.second / n);
}
printf("%lld\n", ans);
Please AC;
}
| [
"call.add",
"assignment.value.change",
"expression.operation.binary.change"
] | 991,713 | 991,714 | u917972976 | cpp |
p03194 | #include <bits/stdc++.h>
#include <math.h>
#define _GLIBCXX_DEBUG
#define _LIBCPP_DEBUG 0
using namespace std;
#define ll long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define MOD (1000000007)
#define vi vector<int>
#define vl vector<ll>
#define vb vector<bool>
#define vvi vector<vi>
#define vvl vector<vl>
#define pii pair<int, int>
#define pli pair<ll, int>
#define pb push_back
#define mp make_pair
#define all(a) (a).begin(), (a).end()
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;
}
return false;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
ll keta(ll n) {
string s = to_string(n);
ll num = s.size();
return num;
}
const ll INF = 1LL << 60;
const int dh[4] = {1, 0, -1, 0};
const int dw[4] = {0, 1, 0, -1};
struct Edge {
int to;
int weight;
Edge(int t, int w) : to(t), weight(w) {}
};
using Graph = vector<vector<Edge>>;
using P = pair<ll, int>;
const int MAX = 1e6;
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] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main() {
ll n, p;
cin >> n >> p;
int P = p;
map<ll, ll> C;
for (ll i = 2; i * i <= P; i++) {
while (p % i == 0) {
p /= i;
C[i]++;
}
}
if (p != 1)
C[p]++;
ll ans = 1LL;
for (auto c : C) {
ll q = c.second;
ll num = q / n;
// cout << c.first << " " << c.second << " " << num << endl;
rep(i, num) ans *= c.first;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
#include <math.h>
#define _GLIBCXX_DEBUG
#define _LIBCPP_DEBUG 0
using namespace std;
#define ll long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define MOD (1000000007)
#define vi vector<int>
#define vl vector<ll>
#define vb vector<bool>
#define vvi vector<vi>
#define vvl vector<vl>
#define pii pair<int, int>
#define pli pair<ll, int>
#define pb push_back
#define mp make_pair
#define all(a) (a).begin(), (a).end()
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;
}
return false;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
ll keta(ll n) {
string s = to_string(n);
ll num = s.size();
return num;
}
const ll INF = 1LL << 60;
const int dh[4] = {1, 0, -1, 0};
const int dw[4] = {0, 1, 0, -1};
struct Edge {
int to;
int weight;
Edge(int t, int w) : to(t), weight(w) {}
};
using Graph = vector<vector<Edge>>;
using P = pair<ll, int>;
const int MAX = 1e6;
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] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main() {
ll n, p;
cin >> n >> p;
ll P = p;
map<ll, ll> C;
for (ll i = 2; i * i <= P; i++) {
while (p % i == 0) {
p /= i;
C[i]++;
}
}
if (p != 1)
C[p]++;
ll ans = 1LL;
for (auto c : C) {
ll q = c.second;
ll num = q / n;
// cout << c.first << " " << c.second << " " << num << endl;
rep(i, num) ans *= c.first;
}
cout << ans << endl;
}
| [
"variable_declaration.type.change"
] | 991,715 | 991,716 | u354567428 | cpp |
p03194 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define rep(i, a, b) for (int i = a; i < (b); ++i)
#define p(s) std::cout << s;
#define pl(s) std::cout << s << endl;
#define printIf(j, s1, s2) cout << (j ? s1 : s2) << endl;
#define YES(j) cout << (j ? "YES" : "NO") << endl;
#define Yes(j) std::cout << (j ? "Yes" : "No") << endl;
#define yes(j) std::cout << (j ? "yes" : "no") << endl;
#define all(v) v.begin(), v.end()
#define showVector(v) \
REP(i, v.size()) { \
p(v[i]); \
p(" ") \
} \
pl("")
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
typedef long long int ll;
typedef pair<ll, ll> P_ii;
typedef pair<double, double> P_dd;
template <class T> vector<T> make_vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
const int MOD = 1000000007;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
void addM(long long &a, long long b) {
a += b;
if (a >= MOD)
a -= MOD;
}
void mulM(long long &a, long long b) { a = ((a % MOD) * (b % MOD)) % MOD; }
// a^b mod M
long myPow(long a, long b, int M) {
long ret = 1;
long tmp = a;
while (b > 0) {
if ((b & 1) == 1)
ret = (ret * tmp) % M;
tmp = (tmp * tmp) % M;
b = b >> 1;
}
return ret;
}
// nCk mod M
int nCk(int n, int k, int M) {
long ret = 1;
int mi = min(k, n - k);
for (int i = 1; i <= mi; i++) {
ret = (ret * myPow(i, M - 2, M)) % M;
}
for (int i = n - mi + 1; i <= n; i++) {
ret = (ret * i) % M;
}
return (int)ret;
};
vector<pair<long long, long long>> prime_factorize(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_pair(p, num));
}
if (n != 1)
res.push_back(make_pair(n, 1));
return res;
}
int main() {
ll N, P;
cin >> N >> P;
auto pf = prime_factorize(P);
ll ans = 1;
for (auto p : pf) {
ll tmp = p.first * (p.second / N);
if (tmp > 0)
ans *= tmp;
}
pl(ans)
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define rep(i, a, b) for (int i = a; i < (b); ++i)
#define p(s) std::cout << s;
#define pl(s) std::cout << s << endl;
#define printIf(j, s1, s2) cout << (j ? s1 : s2) << endl;
#define YES(j) cout << (j ? "YES" : "NO") << endl;
#define Yes(j) std::cout << (j ? "Yes" : "No") << endl;
#define yes(j) std::cout << (j ? "yes" : "no") << endl;
#define all(v) v.begin(), v.end()
#define showVector(v) \
REP(i, v.size()) { \
p(v[i]); \
p(" ") \
} \
pl("")
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
typedef long long int ll;
typedef pair<ll, ll> P_ii;
typedef pair<double, double> P_dd;
template <class T> vector<T> make_vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
const int MOD = 1000000007;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
void addM(long long &a, long long b) {
a += b;
if (a >= MOD)
a -= MOD;
}
void mulM(long long &a, long long b) { a = ((a % MOD) * (b % MOD)) % MOD; }
// a^b mod M
long myPow(long a, long b, int M) {
long ret = 1;
long tmp = a;
while (b > 0) {
if ((b & 1) == 1)
ret = (ret * tmp) % M;
tmp = (tmp * tmp) % M;
b = b >> 1;
}
return ret;
}
// nCk mod M
int nCk(int n, int k, int M) {
long ret = 1;
int mi = min(k, n - k);
for (int i = 1; i <= mi; i++) {
ret = (ret * myPow(i, M - 2, M)) % M;
}
for (int i = n - mi + 1; i <= n; i++) {
ret = (ret * i) % M;
}
return (int)ret;
};
vector<pair<long long, long long>> prime_factorize(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_pair(p, num));
}
if (n != 1)
res.push_back(make_pair(n, 1));
return res;
}
int main() {
ll N, P;
cin >> N >> P;
auto pf = prime_factorize(P);
ll ans = 1;
for (auto p : pf) {
ll tmp = pow(p.first, p.second / N);
if (tmp > 0)
ans *= tmp;
}
pl(ans)
return 0;
} | [
"call.add",
"expression.operation.binary.change"
] | 991,730 | 991,731 | u491550356 | cpp |
p03194 | // g++ -std=c++11 a.cpp
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <utility>
#include <vector>
#define loop(i, a, b) for (int i = a; i < b; i++)
#define rep(i, a) loop(i, 0, a)
#define FOR(i, a) for (auto i : a)
#define pb push_back
#define all(in) in.begin(), in.end()
#define shosu(x) fixed << setprecision(x)
#define show1d(v) \
{ \
rep(_, v.size()) cout << " " << v[_]; \
puts(""); \
}
#define show2d(v) \
{ rep(__, v.size()) show1d(v[__]); }
using namespace std;
// kaewasuretyuui
typedef long long ll;
#define int ll
typedef int Def;
typedef pair<Def, Def> pii;
typedef vector<Def> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef vector<string> vs;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef pair<Def, pii> pip;
typedef vector<pip> vip;
#define mt make_tuple
typedef tuple<int, int, int, int> tp;
typedef vector<tp> vt;
template <typename A, typename B> bool cmin(A &a, const B &b) {
return a > b ? (a = b, true) : false;
}
template <typename A, typename B> bool cmax(A &a, const B &b) {
return a < b ? (a = b, true) : false;
}
// template<class C>constexpr int size(const C &c){return (int)c.size();}
// template<class T,size_t N> constexpr int size(const T
// (&xs)[N])noexcept{return (int)N;}
const double PI = acos(-1);
const double EPS = 1e-9;
Def inf = sizeof(Def) == sizeof(long long) ? 2e18 : 1e9 + 10;
// int dx[]={0,1,0,-1};
// int dy[]={1,0,-1,0};//RDLU
#define yes puts("YES")
#define no puts("NO")
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, p;
cin >> n >> p;
if (n == 1) {
cout << p << endl;
return 0;
}
int t = 1;
for (int i = 2; i * i <= p; i++)
if (p % i == 0) {
int c = 0;
while (p % i == 0) {
p /= i;
c++;
}
rep(i, c / n) t *= i;
}
cout << t << endl;
}
| // g++ -std=c++11 a.cpp
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <utility>
#include <vector>
#define loop(i, a, b) for (int i = a; i < b; i++)
#define rep(i, a) loop(i, 0, a)
#define FOR(i, a) for (auto i : a)
#define pb push_back
#define all(in) in.begin(), in.end()
#define shosu(x) fixed << setprecision(x)
#define show1d(v) \
{ \
rep(_, v.size()) cout << " " << v[_]; \
puts(""); \
}
#define show2d(v) \
{ rep(__, v.size()) show1d(v[__]); }
using namespace std;
// kaewasuretyuui
typedef long long ll;
#define int ll
typedef int Def;
typedef pair<Def, Def> pii;
typedef vector<Def> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef vector<string> vs;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef pair<Def, pii> pip;
typedef vector<pip> vip;
#define mt make_tuple
typedef tuple<int, int, int, int> tp;
typedef vector<tp> vt;
template <typename A, typename B> bool cmin(A &a, const B &b) {
return a > b ? (a = b, true) : false;
}
template <typename A, typename B> bool cmax(A &a, const B &b) {
return a < b ? (a = b, true) : false;
}
// template<class C>constexpr int size(const C &c){return (int)c.size();}
// template<class T,size_t N> constexpr int size(const T
// (&xs)[N])noexcept{return (int)N;}
const double PI = acos(-1);
const double EPS = 1e-9;
Def inf = sizeof(Def) == sizeof(long long) ? 2e18 : 1e9 + 10;
// int dx[]={0,1,0,-1};
// int dy[]={1,0,-1,0};//RDLU
#define yes puts("YES")
#define no puts("NO")
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, p;
cin >> n >> p;
if (n == 1) {
cout << p << endl;
return 0;
}
int t = 1;
for (int i = 2; i * i <= p; i++)
if (p % i == 0) {
int c = 0;
while (p % i == 0) {
p /= i;
c++;
}
rep(j, c / n) t *= i;
}
cout << t << endl;
}
| [
"assignment.variable.change",
"identifier.change",
"call.arguments.change"
] | 991,737 | 991,738 | u010004797 | cpp |
p03194 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
typedef long long ll;
int main(void) {
ll n, p;
cin >> n >> p;
for (ll i = pow(p, 1.0 / double(n)); i > 0; i--) {
if (p % ll(pow(i, n)) == 0) {
cout << i - 1 << endl;
break;
}
}
}
| #include <bits/stdc++.h>
#include <iostream>
using namespace std;
typedef long long ll;
int main(void) {
ll n, p;
cin >> n >> p;
for (ll i = pow(p, 1.0 / double(n)) + 1; i > 0; i--) {
if (p % ll(pow(i, n)) == 0) {
cout << i << endl;
return 0;
}
}
}
| [
"control_flow.loop.for.initializer.change",
"assignment.change",
"expression.operation.binary.remove",
"control_flow.break.remove",
"control_flow.return.add",
"function.return_value.change"
] | 991,759 | 991,760 | u050428930 | cpp |
p03194 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
typedef long long ll;
int main(void) {
ll n, p;
cin >> n >> p;
for (ll i = pow(p, 1.0 / double(n)); i > 0; i--) {
if (p % ll(pow(i, n)) == 0) {
cout << i + 1 << endl;
break;
}
}
}
| #include <bits/stdc++.h>
#include <iostream>
using namespace std;
typedef long long ll;
int main(void) {
ll n, p;
cin >> n >> p;
for (ll i = pow(p, 1.0 / double(n)) + 1; i > 0; i--) {
if (p % ll(pow(i, n)) == 0) {
cout << i << endl;
return 0;
}
}
}
| [
"control_flow.loop.for.initializer.change",
"assignment.change",
"expression.operation.binary.remove",
"control_flow.break.remove",
"control_flow.return.add",
"function.return_value.change"
] | 991,761 | 991,760 | u050428930 | cpp |
p03194 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m;
while (cin >> n >> m) {
long long int ans = 1;
if (n == 1 || m == 1) {
cout << m << endl;
continue;
}
long long int maxx = sqrt(m);
maxx += 2;
for (long long int i = 2; i <= maxx; i++) {
long long int c = 0;
while (m % i == 0) {
m = m / i;
c++;
if (c == n)
ans = ans * i;
}
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m;
while (cin >> n >> m) {
long long int ans = 1;
if (n == 1 || m == 1) {
cout << m << endl;
continue;
}
long long int maxx = sqrt(m);
maxx += 2;
for (long long int i = 2; i <= maxx; i++) {
long long int c = 0;
while (m % i == 0) {
m = m / i;
c++;
if (c == n) {
ans = ans * i;
c = 0;
}
}
}
cout << ans << endl;
}
}
| [
"assignment.add"
] | 991,765 | 991,766 | u886817267 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.