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 |
|---|---|---|---|---|---|---|---|
p02929 | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define forn(i, n) for (int i = 0; i < (int)(n); ++i)
typedef long long LL;
typedef pair<int, int> PII;
const int MOD = int(1e9) + 7;
int n;
char s[200005];
int a[200005];
int main() {
scanf("%d%s", &n, s);
n *= 2;
a[0] =... | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define forn(i, n) for (int i = 0; i < (int)(n); ++i)
typedef long long LL;
typedef pair<int, int> PII;
const int MOD = int(1e9) + 7;
int n;
char s[200005];
int a[200005];
int main() {
scanf("%d%s", &n, s);
n *= 2;
a[0] =... | [
"control_flow.branch.if.condition.change"
] | 732,092 | 732,093 | u155202361 | cpp |
p02930 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n - 1; i >= 0; --i)
#define FOR(i, m, n) for (int i = m; i < n; ++i)
#define FORR(i, m, n) for (int i = m; i >= n; --i)
#define ALL(v) (v).begin(), ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n - 1; i >= 0; --i)
#define FOR(i, m, n) for (int i = m; i < n; ++i)
#define FORR(i, m, n) for (int i = m; i >= n; --i)
#define ALL(v) (v).begin(), ... | [
"expression.operation.binary.add"
] | 732,104 | 732,105 | u244626757 | cpp |
p02929 | #include <algorithm>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
using ll = long long;
using ld = long double;
u... | #include <algorithm>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
using ll = long long;
using ld = long double;
u... | [
"control_flow.branch.if.condition.change"
] | 732,110 | 732,111 | u916974091 | cpp |
p02929 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> P;
typedef pair<ll, ll> l_l;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
#define pb push_back
#define sz(x) (int)(x).size()
#define fi first
#define se seco... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> P;
typedef pair<ll, ll> l_l;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
#define pb push_back
#define sz(x) (int)(x).size()
#define fi first
#define se seco... | [
"literal.number.change",
"variable_declaration.value.change"
] | 732,134 | 732,132 | u796877631 | cpp |
p02929 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> P;
typedef pair<ll, ll> l_l;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
#define pb push_back
#define sz(x) (int)(x).size()
#define fi first
#define se seco... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> P;
typedef pair<ll, ll> l_l;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
#define pb push_back
#define sz(x) (int)(x).size()
#define fi first
#define se seco... | [
"literal.number.change",
"variable_declaration.value.change"
] | 732,135 | 732,132 | u796877631 | cpp |
p02929 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define PI acos(-1)
#define pcnt __builtin_popcountll
#define rng(a) a.begin(), a.end()
#define sz(x) (int)(x).size()
#define v(T) vector<T>
#define vv(T) v(v(T))
#define fi first
#define se second
using namespace std;
typedef long long ll;
typed... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define PI acos(-1)
#define pcnt __builtin_popcountll
#define rng(a) a.begin(), a.end()
#define sz(x) (int)(x).size()
#define v(T) vector<T>
#define vv(T) v(v(T))
#define fi first
#define se second
using namespace std;
typedef long long ll;
typed... | [
"literal.number.change",
"io.output.change"
] | 732,138 | 732,139 | u482770395 | cpp |
p02929 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
int main() {
ll n;
cin >> n;
string s;
cin >> s;
vector<bool> side(n);
side[0] = false;
ll t = 0, f = 1;
for (ll i = 1; i < 2 * n; i++) {
if (s[i - 1] != s[i]) {
side[i] = side[i - 1];
} else... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
int main() {
ll n;
cin >> n;
string s;
cin >> s;
vector<bool> side(2 * n);
side[0] = false;
ll t = 0, f = 1;
for (ll i = 1; i < 2 * n; i++) {
if (s[i - 1] != s[i]) {
side[i] = side[i - 1];
}... | [
"assignment.change",
"control_flow.return.add",
"control_flow.return.0.add"
] | 732,144 | 732,143 | u904123392 | cpp |
p02929 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int base = 1e9 + 7;
int main() {
int n;
cin >> n;
string s;
cin >> s;
vector<int> dif(2 * n + 1, 0);
dif[0] = (s[0] == 'B' ? 1 : 0);
dif[2 * n] = (s[2 * n] == 'B' ? 1 : 0);
for (int i = 1; i < 2 * n; ++i)
if (s[i] != s[i - 1... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int base = 1e9 + 7;
int main() {
int n;
cin >> n;
string s;
cin >> s;
vector<int> dif(2 * n + 1, 0);
dif[0] = (s[0] == 'B' ? 1 : 0);
dif[2 * n] = (s[2 * n - 1] == 'B' ? 1 : 0);
for (int i = 1; i < 2 * n; ++i)
if (s[i] != s[i... | [
"assignment.change"
] | 732,145 | 732,146 | u809975392 | cpp |
p02929 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a) for (int i = 0; i < (a); i++)
#define ALL(a) (a).begin(), (a).end()
typedef long long ll;
typedef pair<int, int> P;
const int INF = 1e9;
const int MOD = 1e9 + 7;
using ll = long long;
template <ll MOD = 1000000007> struct Mint {
ll x;
Mint() : x(0) {... | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a) for (int i = 0; i < (a); i++)
#define ALL(a) (a).begin(), (a).end()
typedef long long ll;
typedef pair<int, int> P;
const int INF = 1e9;
const int MOD = 1e9 + 7;
using ll = long long;
template <ll MOD = 1000000007> struct Mint {
ll x;
Mint() : x(0) {... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 732,157 | 732,158 | u366398972 | cpp |
p02929 | #include <algorithm>
#include <bits/stdc++.h>
#include <cstdio>
#include <math.h>
#include <queue>
using namespace std;
template <class T> using V = vector<T>;
template <class S, class T> using P = pair<S, T>;
template <class... T> using TP = tuple<T...>;
using ll = long long;
using db = double;
using ldb = long db;
... | #include <algorithm>
#include <bits/stdc++.h>
#include <cstdio>
#include <math.h>
#include <queue>
using namespace std;
template <class T> using V = vector<T>;
template <class S, class T> using P = pair<S, T>;
template <class... T> using TP = tuple<T...>;
using ll = long long;
using db = double;
using ldb = long db;
... | [
"control_flow.branch.if.condition.change"
] | 732,179 | 732,180 | u177143886 | cpp |
p02929 | #include <bits/stdc++.h>
#define N (long long)(1e9 + 7)
#define MAX 500000
using namespace std;
long long factorial[MAX] = {0}, finverse[MAX] = {0}, inverse[MAX] = {0};
void smodfact() {
factorial[0] = factorial[1] = 1;
finverse[0] = finverse[1] = 1;
inverse[1] = 1;
for (int i = 2; i < MAX; ++i) {
factori... | #include <bits/stdc++.h>
#define N (long long)(1e9 + 7)
#define MAX 500000
using namespace std;
long long factorial[MAX] = {0}, finverse[MAX] = {0}, inverse[MAX] = {0};
void smodfact() {
factorial[0] = factorial[1] = 1;
finverse[0] = finverse[1] = 1;
inverse[1] = 1;
for (int i = 2; i < MAX; ++i) {
factori... | [
"misc.opposites",
"expression.operator.compare.change",
"call.arguments.change",
"expression.operation.binary.change",
"control_flow.return.add"
] | 732,206 | 732,207 | u269963329 | cpp |
p02929 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define int 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 itn int
#define all(x) (x).begin(), (x).end()
const long long INF = 1LL << 60;
const int MOD = 1000000007;
long... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define int 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 itn int
#define all(x) (x).begin(), (x).end()
const long long INF = 1LL << 60;
const int MOD = 1000000007;
long... | [
"control_flow.branch.if.condition.change"
] | 732,212 | 732,213 | u616029737 | cpp |
p02929 | #include <bits/stdc++.h>
#define MODD 1000000007
using namespace std;
long long fac(int n) {
long long ans = 1;
for (int i = 2; i <= n; i++) {
ans = (ans * i) % MODD;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
string s;
cin >> n >> s;
int d[100005]; // ... | #include <bits/stdc++.h>
#define MODD 1000000007
using namespace std;
long long fac(int n) {
long long ans = 1;
for (int i = 2; i <= n; i++) {
ans = (ans * i) % MODD;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
string s;
cin >> n >> s;
int d[200005]; ... | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 732,220 | 732,219 | u358689692 | cpp |
p02929 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define RREP(i, n) for (int i = int(n) - 1; i >= 0; --i)
#define rep(i, a, b) for (int i = int(a); i < int(b); ++i)
#define rrep(i, a, b) for (int i = int(a) - 1; i >= int(b); --i)
#define All(x) (x).begin(), (x).end()
#define r... | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define RREP(i, n) for (int i = int(n) - 1; i >= 0; --i)
#define rep(i, a, b) for (int i = int(a); i < int(b); ++i)
#define rrep(i, a, b) for (int i = int(a) - 1; i >= int(b); --i)
#define All(x) (x).begin(), (x).end()
#define r... | [
"expression.operation.binary.remove"
] | 732,221 | 732,222 | u203033720 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> x;
x.resize(n);
vector<int> y;
y.resize(n);
vector<pair<long double, int>> p;
p.resize(n);
for (int i = 0; i < n; ++i) {
cin >> x[i] >> y[i];
p[i] =... | #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> x;
x.resize(n);
vector<int> y;
y.resize(n);
vector<pair<long double, int>> p;
p.resize(n);
for (int i = 0; i < n; ++i) {
cin >> x[i] >> y[i];
p[i] =... | [
"control_flow.loop.for.condition.change",
"assignment.change"
] | 732,223 | 732,224 | u639210885 | cpp |
p02926 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
typedef double ld;
ld PI = acos(-1), EPS = 1e-15, a[100], b[100];
ld n, ans, A, B, L;
int main(void) {
cin >> n;
// cout<<PI<<endl;
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i];
for (int i = 0; i < 360; i++) {
A = 0, B = 0;
L = (ld... | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
typedef double ld;
ld PI = acos(-1), EPS = 1e-15, a[100], b[100];
ld n, ans, A, B, L;
int main(void) {
cin >> n;
// cout<<PI<<endl;
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i];
for (int i = 0; i < 360; i++) {
A = 0, B = 0;
L = (ld... | [
"identifier.change",
"call.function.change",
"control_flow.branch.if.condition.change"
] | 732,225 | 732,226 | u050428930 | cpp |
p02926 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
typedef double ld;
ld PI = 2 * acos(-1), EPS = 1e-15, a[100], b[100];
ld n, ans, A, B, L;
int main(void) {
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i];
for (int i = 0; i < 360; i++) {
A = 0, B = 0;
L = (ld)((ld)i / 360);
... | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
typedef double ld;
ld PI = acos(-1), EPS = 1e-15, a[100], b[100];
ld n, ans, A, B, L;
int main(void) {
cin >> n;
// cout<<PI<<endl;
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i];
for (int i = 0; i < 360; i++) {
A = 0, B = 0;
L = (ld... | [
"expression.operation.binary.remove",
"literal.number.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change",
"identifier.change",
"call.function.change",
"control_flow.branch.if.condition.change"
] | 732,227 | 732,226 | u050428930 | cpp |
p02926 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
typedef long double ld;
ld n, s[100], t[100], x, y, ans;
int main(void) {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i] >> t[i];
}
for (int i = 0; i < 360; i++) {
x = 0.0, y = 0.0;
for (int j = 0; j < n; j++) {
if (cos(i *... | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
typedef long double ld;
ld n, s[100], t[100], x, y, ans;
int main(void) {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i] >> t[i];
}
for (int i = 0; i < 360; i++) {
x = 0.0, y = 0.0;
for (int j = 0; j < n; j++) {
if (cos(i *... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 732,228 | 732,229 | u050428930 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
using i64 = long long;
#define endl "\n"
const i64 MOD = 998244353;
int main() {
i64 N;
cin >> N;
vector<pair<i64, i64>> xy(N);
for (i64 i = 0; i < N; i++)
cin >> xy[i].first >> xy[i].second;
sort(xy.begin(), xy.end(),
[](const pair<i64, i64> &l, cons... | #include <bits/stdc++.h>
using namespace std;
using i64 = long long;
#define endl "\n"
const i64 MOD = 998244353;
int main() {
i64 N;
cin >> N;
vector<pair<i64, i64>> xy(N);
for (i64 i = 0; i < N; i++)
cin >> xy[i].first >> xy[i].second;
sort(xy.begin(), xy.end(),
[](const pair<i64, i64> &l, cons... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 732,237 | 732,238 | u623115612 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define FOR(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define ALLOF(c) (c).begin(), (c).... | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define FOR(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define ALLOF(c) (c).begin(), (c).... | [
"expression.operation.binary.remove"
] | 732,245 | 732,246 | u624678037 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define FOR(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define ALLOF(c) (c).begin(), (c).... | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define FOR(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define ALLOF(c) (c).begin(), (c).... | [
"expression.operation.binary.add"
] | 732,247 | 732,248 | u624678037 | cpp |
p02926 | #include <iostream>
#define _USE_MATH_DEFINES
#include <algorithm>
#include <array>
#include <cstdio>
#include <cstring>
#include <deque>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
ty... | #include <iostream>
#define _USE_MATH_DEFINES
#include <algorithm>
#include <array>
#include <cstdio>
#include <cstring>
#include <deque>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
ty... | [] | 732,249 | 732,250 | u215268883 | cpp |
p02926 | #include <bits/stdc++.h>
#define MAX_N 200001
#define mod 1000000007
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define REP(i, n) for (ll i = 0; i < n; i++)
#define REV(i, n) for (ll i = n - 1; i >= 0; i--)
#define ALL(v) v.begin(), v.end()
#define... | #include <bits/stdc++.h>
#define MAX_N 200001
#define mod 1000000007
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define REP(i, n) for (ll i = 0; i < n; i++)
#define REV(i, n) for (ll i = n - 1; i >= 0; i--)
#define ALL(v) v.begin(), v.end()
#define... | [
"misc.opposites",
"control_flow.branch.if.condition.change"
] | 732,254 | 732,255 | u876442898 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> P;
typedef pair<int, int> Pi;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define fi first
#define se second
#define endl "\n"
template <typename T> inline b... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> P;
typedef pair<int, int> Pi;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define fi first
#define se second
#define endl "\n"
template <typename T> inline b... | [
"assignment.change"
] | 732,256 | 732,257 | u340010271 | cpp |
p02926 | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
const ll MOD = (ll)(1e9 + 7);
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int(i) = 0; (i) < (int)(n); (i)++)
#ifdef LOCAL
#define debug(x) cerr << #x << ": " << x << endl
#else
#define debug(x)... | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
const ll MOD = (ll)(1e9 + 7);
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int(i) = 0; (i) < (int)(n); (i)++)
#ifdef LOCAL
#define debug(x) cerr << #x << ": " << x << endl
#else
#define debug(x)... | [
"expression.operator.arithmetic.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 732,258 | 732,259 | u422592877 | cpp |
p02926 | #include <bits/stdc++.h>
#define ll long long int
#define pb push_back
#define ss second
#define ff first
#define INF 30000000000001
#define ll_max 9000000000000000001
#define mod 1000000007
#define PI 3.14159265358979323846L
#define fast \
ios_base::s... | #include <bits/stdc++.h>
#define ll long long int
#define pb push_back
#define ss second
#define ff first
#define INF 30000000000001
#define ll_max 9000000000000000001
#define mod 1000000007
#define PI 3.14159265358979323846L
#define fast \
ios_base::s... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.loop.condition.change"
] | 732,260 | 732,261 | u775313130 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
#define ALL(x) x.begin(), x.end()
#define rep(i, n) for (int i = 0; i < n; i++)
#define debug(v) \
cout << #v << ":"; \
for (auto x : v) { ... | #include <bits/stdc++.h>
using namespace std;
#define ALL(x) x.begin(), x.end()
#define rep(i, n) for (int i = 0; i < n; i++)
#define debug(v) \
cout << #v << ":"; \
for (auto x : v) { ... | [
"call.remove"
] | 732,262 | 732,263 | u022832318 | cpp |
p02926 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
#define yn ... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
#define yn ... | [
"assignment.variable.change"
] | 732,270 | 732,271 | u791593901 | cpp |
p02926 | #include <bits/stdc++.h>
#define REP(i, s, n) for (int i = s; i < n; ++i)
#define rep(i, n) REP(i, 0, n)
#define ALL(x) x.begin(), x.end()
#define EPS (1e-12)
#define equals(a, b) (fabs((a) - (b)) < EPS)
using namespace std;
typedef long long ll;
bool LTE(double a, double b) { return equals(a, b) || a < b; }
bool LT... | #include <bits/stdc++.h>
#define REP(i, s, n) for (int i = s; i < n; ++i)
#define rep(i, n) REP(i, 0, n)
#define ALL(x) x.begin(), x.end()
#define EPS (1e-12)
#define equals(a, b) (fabs((a) - (b)) < EPS)
using namespace std;
typedef long long ll;
bool LTE(double a, double b) { return equals(a, b) || a < b; }
bool LT... | [
"literal.number.change",
"variable_declaration.value.change"
] | 732,286 | 732,287 | u412073904 | cpp |
p02926 | #pragma gcc optimize("Ofast")
#include "bits/stdc++.h"
using namespace std;
typedef int64_t lld;
typedef pair<int, int> pii;
typedef pair<lld, lld> pll;
typedef pair<int, pll> pip;
typedef pair<pll, int> ppi;
typedef pair<lld, pll> plp;
typedef pair<pll, lld> ppl;
typedef pair<pll, pll> ppp;
template <typename T> usin... | #pragma gcc optimize("Ofast")
#include "bits/stdc++.h"
using namespace std;
typedef int64_t lld;
typedef pair<int, int> pii;
typedef pair<lld, lld> pll;
typedef pair<int, pll> pip;
typedef pair<pll, int> ppi;
typedef pair<lld, pll> plp;
typedef pair<pll, lld> ppl;
typedef pair<pll, pll> ppp;
template <typename T> usin... | [
"literal.number.change",
"variable_declaration.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 732,295 | 732,296 | u579678749 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout << #x " = " << ((x)) << endl
template <class T, class U>
ostream &operator<<(ostream ... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout << #x " = " << ((x)) << endl
template <class T, class U>
ostream &operator<<(ostream ... | [
"literal.number.change",
"variable_declaration.value.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 732,300 | 732,301 | u696805736 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout << #x " = " << ((x)) << endl
template <class T, class U>
ostream &operator<<(ostream ... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout << #x " = " << ((x)) << endl
template <class T, class U>
ostream &operator<<(ostream ... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 732,302 | 732,301 | u696805736 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
#define int long long
const int MOD = 998244353;
signed main() {
int n;
cin >> n;
double x, y;
vector<pair<double, pair<double, double>>> p;
for (int i = 0; i < n; i++) {
cin >> x >> y;
if (x != 0 || y != 0)
p.push_back(make_pair(atan2(y, x), make_p... | #include <bits/stdc++.h>
using namespace std;
#define int long long
const int MOD = 998244353;
signed main() {
int n;
cin >> n;
double x, y;
vector<pair<double, pair<double, double>>> p;
for (int i = 0; i < n; i++) {
cin >> x >> y;
if (x != 0 || y != 0)
p.push_back(make_pair(atan2(y, x), make_p... | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 732,306 | 732,307 | u651317892 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
#define int long long
const int MOD = 998244353;
signed main() {
int n;
cin >> n;
float x, y;
vector<pair<double, pair<double, double>>> p;
for (int i = 0; i < n; i++) {
cin >> x >> y;
if (x != 0 || y != 0)
p.push_back(make_pair(atan2(y, x), make_pa... | #include <bits/stdc++.h>
using namespace std;
#define int long long
const int MOD = 998244353;
signed main() {
int n;
cin >> n;
double x, y;
vector<pair<double, pair<double, double>>> p;
for (int i = 0; i < n; i++) {
cin >> x >> y;
if (x != 0 || y != 0)
p.push_back(make_pair(atan2(y, x), make_p... | [
"variable_declaration.type.primitive.change",
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 732,308 | 732,307 | u651317892 | cpp |
p02926 | //@Author: wxyww
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define pi pair<double, double>
const int N = 110;
ll read() ... | //@Author: wxyww
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define pi pair<double, double>
const int N = 110;
ll read() ... | [
"call.add",
"call.arguments.change"
] | 732,314 | 732,315 | u748042489 | cpp |
p02926 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < ... | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < ... | [
"call.arguments.add"
] | 732,318 | 732,319 | u834415466 | cpp |
p02926 | #include <algorithm>
#include <bitset>
#include <cfloat>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#includ... | #include <algorithm>
#include <bitset>
#include <cfloat>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#includ... | [] | 732,324 | 732,325 | u809967037 | cpp |
p02926 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define vv(a, b, c, d) vector<vector<d>>(a, vector<d>(b, c))
#define vvi std::vector<std::vector<int>>
#de... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define vv(a, b, c, d) vector<vector<d>>(a, vector<d>(b, c))
#define vvi std::vector<std::vector<int>>
#de... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 732,332 | 732,333 | u816587940 | cpp |
p02926 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <climits>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include ... | #include <algorithm>
#include <bitset>
#include <cctype>
#include <climits>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include ... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 732,336 | 732,337 | u632353278 | cpp |
p02926 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <climits>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include ... | #include <algorithm>
#include <bitset>
#include <cctype>
#include <climits>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include ... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 732,338 | 732,337 | u632353278 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; i++)
const double eps = 1e-9;
struct V {
double x, y;
V(double x = 0, double y = 0) : x(x), y(y) {}
V &operator+=(const V &v) {
x += v.x;
y += v.y;
return *this;
}
V operator+(const V &v)... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; i++)
const double eps = 1e-9;
struct V {
double x, y;
V(double x = 0, double y = 0) : x(x), y(y) {}
V &operator+=(const V &v) {
x += v.x;
y += v.y;
return *this;
}
V operator+(const V &v)... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 732,348 | 732,349 | u326152409 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
int n;
cin >> n;
pair<double, double> xy[n];
for (int i = 0; i < n; ++i) {
cin >> xy[i].first >> xy[i].second;
}
sort(xy, xy + n, [](const auto &p1, const auto &p2) {
return atan2(p1.second, p1.first) < atan2(p2.... | #include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
int n;
cin >> n;
pair<double, double> xy[n];
for (int i = 0; i < n; ++i) {
cin >> xy[i].first >> xy[i].second;
}
sort(xy, xy + n, [](const auto &p1, const auto &p2) {
return atan2(p1.second, p1.first) < atan2(p2.... | [
"control_flow.loop.for.condition.change",
"assignment.change"
] | 732,352 | 732,353 | u399987025 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
#define _USES_MATH_DEFINES
#define x first
#define y second
int cmp(pair<int, int> a, pair<int, int> b) {
auto f = [](long double Rad) -> long double {
if (Rad < 0)
Rad += (2 * M_PI);
return Rad;
};
return f(atan2l(a.y, a.x)) < f(atan2l(b.y, b.x));
}
... | #include <bits/stdc++.h>
using namespace std;
#define _USES_MATH_DEFINES
#define x first
#define y second
int cmp(pair<int, int> a, pair<int, int> b) {
auto f = [](long double Rad) -> long double {
if (Rad < 0)
Rad += (2 * M_PI);
return Rad;
};
return f(atan2l(a.y, a.x)) < f(atan2l(b.y, b.x));
}
... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 732,359 | 732,360 | u206133536 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
int n;
long long x[105], y[105], id[205];
long double ans;
int main() {
scanf("%d", &n);
rep(i, n) {
scanf("%lld%lld", x + i, y + i);
id[i] = i;
}
sort(id, id + n,
[](int a, int b) { return atan2(x[a], y... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
int n;
long long x[105], y[105], id[205];
long double ans;
int main() {
scanf("%d", &n);
rep(i, n) {
scanf("%lld%lld", x + i, y + i);
id[i] = i;
}
sort(id, id + n,
[](int a, int b) { return atan2(x[a], y... | [
"control_flow.loop.for.condition.change"
] | 732,361 | 732,362 | u309985845 | cpp |
p02926 | #include <bits/stdc++.h>
#define For(a, b, c) for (int a = b; a <= c; ++a)
using namespace std;
const int N = 107;
struct V {
int x, y;
bool operator<(const V &_) const { return atan2(y, x) < atan2(_.y, _.x); }
V operator+(const V &_) const { return (V){x + _.x, y + _.y}; }
long long len2() { return 1LL * x * x... | #include <bits/stdc++.h>
#define For(a, b, c) for (int a = b; a <= c; ++a)
using namespace std;
const int N = 107;
struct V {
int x, y;
bool operator<(const V &_) const { return atan2(y, x) < atan2(_.y, _.x); }
V operator+(const V &_) const { return (V){x + _.x, y + _.y}; }
long long len2() { return 1LL * x * x... | [
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 732,363 | 732,364 | u748639332 | cpp |
p02926 | #include <bits/stdc++.h>
//#pragma GCC optimize ("O3")
//#pragma GCC target ("sse4")
//#pragma GCC target ("avx,tune=native")
// Use above if bruteforcing with lots of small operations. Or just use it
// anytime, there's no downside. AVX is better slightly
using namespace std;
typedef long long ll;
typedef pair<int, in... | #include <bits/stdc++.h>
//#pragma GCC optimize ("O3")
//#pragma GCC target ("sse4")
//#pragma GCC target ("avx,tune=native")
// Use above if bruteforcing with lots of small operations. Or just use it
// anytime, there's no downside. AVX is better slightly
using namespace std;
typedef long long ll;
typedef pair<int, in... | [
"preprocessor.define.value.change",
"literal.integer.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 732,365 | 732,366 | u360501542 | cpp |
p02926 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <ss... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <ss... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 732,376 | 732,377 | u120810144 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
struct Benri {
Benri() {
std::cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
}
} benri;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using pii = pair<int, int>;
using vll = vector<long long>;
using pll =... | #include <bits/stdc++.h>
using namespace std;
struct Benri {
Benri() {
std::cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
}
} benri;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using pii = pair<int, int>;
using vll = vector<long long>;
using pll =... | [
"variable_declaration.value.change",
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.initializer.change"
] | 732,378 | 732,379 | u073486874 | cpp |
p02926 | #include <algorithm>
#include <bitset>
#include <climits>
#include <complex>
#include <cstring>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
... | #include <algorithm>
#include <bitset>
#include <climits>
#include <complex>
#include <cstring>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"expression.operator.compare.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change"
] | 732,384 | 732,385 | u003873207 | cpp |
p02926 | #include <algorithm>
#include <bitset>
#include <climits>
#include <complex>
#include <cstring>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
... | #include <algorithm>
#include <bitset>
#include <climits>
#include <complex>
#include <cstring>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 732,386 | 732,385 | u003873207 | cpp |
p02926 | #include <algorithm>
#include <bitset>
#include <climits>
#include <complex>
#include <cstring>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
... | #include <algorithm>
#include <bitset>
#include <climits>
#include <complex>
#include <cstring>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 732,387 | 732,385 | u003873207 | cpp |
p02926 | /* _
_ooOoo_
o8888888o
88" . "88
(| -_- |)
O\ = /O
____/`---'\____
.' \\| |// `.
/ \\||| : |||// \
... | /* _
_ooOoo_
o8888888o
88" . "88
(| -_- |)
O\ = /O
____/`---'\____
.' \\| |// `.
/ \\||| : |||// \
... | [
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one"
] | 732,388 | 732,389 | u061984624 | cpp |
p02926 | /* _
_ooOoo_
o8888888o
88" . "88
(| -_- |)
O\ = /O
____/`---'\____
.' \\| |// `.
/ \\||| : |||// \
... | /* _
_ooOoo_
o8888888o
88" . "88
(| -_- |)
O\ = /O
____/`---'\____
.' \\| |// `.
/ \\||| : |||// \
... | [
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change",
"variable_declaration.type.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one"
] | 732,390 | 732,389 | u061984624 | cpp |
p02926 | // Created by AboAbdoMC
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#define db1(x) cout << #x << "=" << x << '\n'
#define db2(x, y) cout << #x << "=" << x << "," << #y << "=" << y << '\n'
#define db3(x, y, z) \
cout << #x << "=" << x << ... | // Created by AboAbdoMC
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#define db1(x) cout << #x << "=" << x << '\n'
#define db2(x, y) cout << #x << "=" << x << "," << #y << "=" << y << '\n'
#define db3(x, y, z) \
cout << #x << "=" << x << ... | [
"identifier.change",
"control_flow.branch.if.condition.change",
"variable_access.subscript.index.change",
"call.function.change"
] | 732,391 | 732,392 | u216673135 | cpp |
p02926 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
int main() {
vector<pair<int, int>> v;
int n;
cin >> n;
int x, y;
for (int i = 0; i < n; ++i) {
cin >> x >> y;
if (x != 0 || y != 0)
v.emplace_back(x, y);
}
sort(v.begin(), ... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
int main() {
vector<pair<int, int>> v;
int n;
cin >> n;
long long x, y;
for (int i = 0; i < n; ++i) {
cin >> x >> y;
if (x != 0 || y != 0)
v.emplace_back(x, y);
}
sort(v.beg... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 732,393 | 732,394 | u021107862 | cpp |
p02930 | #include <bits/stdc++.h>
using namespace std;
int n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) {
int tmp = (i ^ j);
int ans = 0;
while (tmp) {
ans++;
tmp >>= 1;
}
printf("%d%c", ans, j == n ? '\n' : ' ');
}
ret... | #include <bits/stdc++.h>
using namespace std;
int n;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) {
int tmp = (i ^ j);
int ans = 0;
while (tmp) {
ans++;
tmp >>= 1;
}
printf("%d%c", ans, j == n - 1 ? '\n' : ' ');
}
r... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"misc.off_by_one"
] | 732,407 | 732,408 | u276450837 | cpp |
p02930 | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
typedef long long ll;
template <class T> void byebye(T _rpl) {
cout << _rpl << endl;
exit(0);
}
int nextint() {
int x;
scanf("%d", &x);
return x;
}
ll nextll() {
ll x;
scanf("%lld", &x);
return x;
}
int read() {
int f = 1, r... | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
typedef long long ll;
template <class T> void byebye(T _rpl) {
cout << _rpl << endl;
exit(0);
}
int nextint() {
int x;
scanf("%d", &x);
return x;
}
ll nextll() {
ll x;
scanf("%lld", &x);
return x;
}
int read() {
int f = 1, r... | [
"literal.number.change",
"call.arguments.change"
] | 732,427 | 732,428 | u796167342 | cpp |
p02930 | #include <algorithm>
#include <iostream>
#include <stack>
#include <vector>
using namespace std;
typedef long long int ll;
int main() {
int n;
cin >> n;
vector<int> v(500, 0);
for (int i = 0; i < 500; i += 2) {
v[i] = 1;
}
for (int i = 1; i < 500; i += 4) {
v[i] = 2;
}
for (int i = 3; i < 500; ... | #include <algorithm>
#include <iostream>
#include <stack>
#include <vector>
using namespace std;
typedef long long int ll;
int main() {
int n;
cin >> n;
n--;
vector<int> v(500, 0);
for (int i = 0; i < 500; i += 2) {
v[i] = 1;
}
for (int i = 1; i < 500; i += 4) {
v[i] = 2;
}
for (int i = 3; i ... | [
"expression.unary.arithmetic.add"
] | 732,431 | 732,432 | u928536113 | cpp |
p02930 | #include <algorithm>
#include <array>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <time.h>
#include <unordered_map>
#in... | #include <algorithm>
#include <array>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <time.h>
#include <unordered_map>
#in... | [
"literal.number.change",
"control_flow.branch.if.condition.change",
"call.arguments.change"
] | 732,449 | 732,450 | u152129372 | cpp |
p02930 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; i++) {
for (int l = 0;; l++) {
if ((i ^ j) && 1 << l) {
if (j)
cout << ' ';
cout << l + 1;
break;
}
}
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
for (int l = 0;; l++) {
if ((i ^ j) & 1 << l) {
if (j)
cout << ' ';
cout << l + 1;
break;
}
}
... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 732,465 | 732,464 | u946322619 | cpp |
p02930 | #include <bits/stdc++.h>
using namespace std;
#define int long long
// #define double long double
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORR(i, a, b) for (int i = (a); i > (b); --i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOREACH(x... | #include <bits/stdc++.h>
using namespace std;
#define int long long
// #define double long double
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORR(i, a, b) for (int i = (a); i > (b); --i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOREACH(x... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 732,466 | 732,467 | u139031151 | cpp |
p02930 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
typedef long long LL;
ty... | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
typedef long long LL;
ty... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 732,468 | 732,469 | u004342119 | cpp |
p02930 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <ciso646>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <ciso646>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <... | [
"expression.operation.unary.arithmetic.remove"
] | 732,476 | 732,477 | u508571192 | cpp |
p02930 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define all(x) (x).begin(), (x).end()
const int mod = 1000000007, MAX = 200003, INF = 1 << 30;
int main() {
int N;
cin >> N;
N--;
int ans, maxi;
for (int i = 29; i >= 0; i--) {
if (N & (1 << i)) {
ans = i;
maxi = (1 << (i + ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define all(x) (x).begin(), (x).end()
const int mod = 1000000007, MAX = 200003, INF = 1 << 30;
int main() {
int N;
cin >> N;
N--;
int ans, maxi;
for (int i = 29; i >= 0; i--) {
if (N & (1 << i)) {
ans = i;
maxi = (1 << (i + ... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 732,480 | 732,481 | u133391510 | cpp |
p02930 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define all(x) (x).begin(), (x).end()
const int mod = 1000000007, MAX = 200003, INF = 1 << 30;
int main() {
int N;
cin >> N;
N--;
int ans, maxi;
for (int i = 29; i >= 0; i--) {
if (N & (1 << i)) {
ans = i;
maxi = (1 << (i + ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define all(x) (x).begin(), (x).end()
const int mod = 1000000007, MAX = 200003, INF = 1 << 30;
int main() {
int N;
cin >> N;
N--;
int ans, maxi;
for (int i = 29; i >= 0; i--) {
if (N & (1 << i)) {
ans = i;
maxi = (1 << (i + ... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"misc.off_by_one"
] | 732,482 | 732,481 | u133391510 | cpp |
p02930 | #define _GLIBCXX_DEBUG // TLEの原因になるので注意！！！！！！！！！！！
#include <bits/stdc++.h>
#include <cmath>
typedef long long ll;
using namespace std;
vector<int> arr;
stack<int> st;
queue<int> qu;
queue<pair<int, int>> qu2;
priority_queue<int> pq;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, n) for (int i = 1... | #define _GLIBCXX_DEBUG // TLEの原因になるので注意！！！！！！！！！！！
#include <bits/stdc++.h>
#include <cmath>
typedef long long ll;
using namespace std;
vector<int> arr;
stack<int> st;
queue<int> qu;
queue<pair<int, int>> qu2;
priority_queue<int> pq;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, n) for (int i = 1... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 732,493 | 732,494 | u300866293 | cpp |
p02930 | // warm heart, wagging tail,and a smile just for you!
//
// ▒█████▒▒
// ██████████▒
// ▒████████████▒
// ██████████████████
// ████████████████████▒
// ▒██████... | // warm heart, wagging tail,and a smile just for you!
//
// ▒█████▒▒
// ██████████▒
// ▒████████████▒
// ██████████████████
// ████████████████████▒
// ▒██████... | [
"expression.operation.binary.remove"
] | 732,495 | 732,496 | u239493918 | cpp |
p02930 | /**
* Created by hiramekun at 20:52 on 2019-08-24.
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef vector<ll> vl;
typedef vector<vl> vvl;
template <typename T> using pq = priority_queue<T>;
template <typename T> using minpq = priority_queue<T, vector<T>, greate... | /**
* Created by hiramekun at 20:52 on 2019-08-24.
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef vector<ll> vl;
typedef vector<vl> vvl;
template <typename T> using pq = priority_queue<T>;
template <typename T> using minpq = priority_queue<T, vector<T>, greate... | [
"control_flow.loop.for.initializer.change"
] | 732,504 | 732,505 | u136378781 | cpp |
p02930 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <ve... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <ve... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"io.output.change"
] | 732,516 | 732,515 | u386107860 | cpp |
p02931 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define MOD 1000000007
#define INF (1 << 29)
#define LINF (1LL << 60)
#define EPS (1e-10)
typedef long long Int;
typedef pa... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define MOD 1000000007
#define INF (1 << 29)
#define LINF (1LL << 60)
#define EPS (1e-10)
typedef long long Int;
typedef pa... | [
"assignment.value.change",
"identifier.change"
] | 732,521 | 732,522 | u299869545 | cpp |
p02932 | #include <bits/stdc++.h>
using namespace std;
#define all(a) a.begin(), a.end()
using ll = long long;
const int INF = 1 << 30;
const ll INFll = 1LL << 62;
const int mod = int(1e9) + 7;
// const int mod=998244353;
using P = pair<int, int>;
using Pl = pair<ll, ll>;
using ld = long double;
using V = vector<int>;
using Vl ... | #include <bits/stdc++.h>
using namespace std;
#define all(a) a.begin(), a.end()
using ll = long long;
const int INF = 1 << 30;
const ll INFll = 1LL << 62;
const int mod = int(1e9) + 7;
// const int mod=998244353;
using P = pair<int, int>;
using Pl = pair<ll, ll>;
using ld = long double;
using V = vector<int>;
using Vl ... | [
"variable_declaration.type.narrow.change",
"control_flow.loop.for.initializer.change",
"variable_declaration.type.change"
] | 732,523 | 732,524 | u525008368 | cpp |
p02932 | #include <bits/stdc++.h>
using namespace std;
#define all(a) a.begin(), a.end()
using ll = long long;
const int INF = 1 << 30;
const ll INFll = 1LL << 62;
const int mod = int(1e9) + 7;
// const int mod=998244353;
using P = pair<int, int>;
using Pl = pair<ll, ll>;
using ld = long double;
using V = vector<int>;
using Vl ... | #include <bits/stdc++.h>
using namespace std;
#define all(a) a.begin(), a.end()
using ll = long long;
const int INF = 1 << 30;
const ll INFll = 1LL << 62;
const int mod = int(1e9) + 7;
// const int mod=998244353;
using P = pair<int, int>;
using Pl = pair<ll, ll>;
using ld = long double;
using V = vector<int>;
using Vl ... | [
"literal.number.change",
"variable_declaration.value.change",
"variable_declaration.type.narrow.change",
"control_flow.loop.for.initializer.change",
"variable_declaration.type.change"
] | 732,525 | 732,524 | u525008368 | cpp |
p02932 | #include <cstdio>
#include <iostream>
using namespace std;
const int N = 600005;
const int MOD = 1000000007;
int n, m, L, R;
long long fac[N], inv[N];
long long ksm(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1)
res = res * a % MOD;
a = a * a % MOD, b >>= 1;
}
return res;
}
... | #include <cstdio>
#include <iostream>
using namespace std;
const int N = 600005;
const int MOD = 1000000007;
int n, m, L, R;
long long fac[N], inv[N];
long long ksm(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1)
res = res * a % MOD;
a = a * a % MOD, b >>= 1;
}
return res;
}
... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"assignment.change",
"expression.operation.binary.remove"
] | 732,526 | 732,527 | u648316846 | cpp |
p02932 | #include <cstdio>
#include <iostream>
using namespace std;
const int N = 600005;
const int MOD = 1000000007;
int n, m, L, R;
long long fac[N], inv[N];
long long ksm(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1)
res = res * a % MOD;
a = a * a % MOD, b >>= 1;
}
return res;
}
... | #include <cstdio>
#include <iostream>
using namespace std;
const int N = 600005;
const int MOD = 1000000007;
int n, m, L, R;
long long fac[N], inv[N];
long long ksm(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1)
res = res * a % MOD;
a = a * a % MOD, b >>= 1;
}
return res;
}
... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 732,526 | 732,528 | u648316846 | cpp |
p02932 | #include <iostream>
using namespace std;
long long mod = 1000000007;
long long fact[1 << 20], inv[1 << 20];
long long modpow(long long a, long long b, long long m) {
long long p = 1, q = a;
for (int i = 0; i < 33; i++) {
if ((b / (1LL << i)) % 2 == 1) {
p *= q;
p %= m;
}
q *= q;
q %= m... | #include <iostream>
using namespace std;
long long mod = 1000000007;
long long fact[1 << 20], inv[1 << 20];
long long modpow(long long a, long long b, long long m) {
long long p = 1, q = a;
for (int i = 0; i < 33; i++) {
if ((b / (1LL << i)) % 2 == 1) {
p *= q;
p %= m;
}
q *= q;
q %= m... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 732,529 | 732,530 | u504103417 | cpp |
p02932 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint ... | [
"literal.number.change",
"call.arguments.change",
"control_flow.loop.for.initializer.change",
"variable_declaration.type.change"
] | 732,531 | 732,532 | u923105140 | cpp |
p02932 | #include <bits/stdc++.h>
using namespace std;
template <int MAX> struct Combination {
vector<long long> _inv, _fac, _ifac;
const long long MOD;
Combination(long long mod)
: _inv(MAX + 1), _fac(MAX + 1), _ifac(MAX + 1), MOD(mod) {
init();
}
inline void init(long long mod = 0) { init_inv(), init_fac(... | #include <bits/stdc++.h>
using namespace std;
template <int MAX> struct Combination {
vector<long long> _inv, _fac, _ifac;
const long long MOD;
Combination(long long mod)
: _inv(MAX + 1), _fac(MAX + 1), _ifac(MAX + 1), MOD(mod) {
init();
}
inline void init(long long mod = 0) { init_inv(), init_fac(... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 732,533 | 732,534 | u521364030 | cpp |
p02932 | #include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, mod = 1e9 + 7;
typedef long long ll;
int n, m, l, r;
ll f[N], inv[N], invf[N];
ll C(int n, int m) { return f[n] * invf[n - m] % mod * invf[m] % mod; }
ll g(int x, int y, int k) {
int s = k - x * m;
ll res = 0;
for (int i = 0, f = 1; i * y <= s &... | #include <bits/stdc++.h>
using namespace std;
const int N = 6e5 + 5, mod = 1e9 + 7;
typedef long long ll;
int n, m, l, r;
ll f[N], inv[N], invf[N];
ll C(int n, int m) { return f[n] * invf[n - m] % mod * invf[m] % mod; }
ll g(int x, int y, int k) {
int s = k - x * m;
ll res = 0;
for (int i = 0, f = 1; i * y <= s &... | [
"literal.number.change",
"expression.operation.binary.change"
] | 732,537 | 732,538 | u676323984 | cpp |
p02932 | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
typedef long long ll;
const int N = 300010;
const int mod = 1e9 + 7;
int n, m, fact[N << 1], invf[N << 1];
int qpow(int x, int y) {
int out = 1;
while (y) {
if (y & 1)
out = (ll)out * x % mod;
x = (... | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
typedef long long ll;
const int N = 300010;
const int mod = 1e9 + 7;
int n, m, fact[N << 1], invf[N << 1];
int qpow(int x, int y) {
int out = 1;
while (y) {
if (y & 1)
out = (ll)out * x % mod;
x = (... | [
"assignment.change",
"control_flow.loop.for.initializer.change"
] | 732,539 | 732,540 | u872322009 | cpp |
p02932 | #include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 10;
const int P = 1e9 + 7;
#define fr(i, low, up, st) for (register int i = low; i <= up; i += st)
#define nfr(i, low, up, st) for (register int i = low; i >= up; i -= st)
#define size(a) a.size()
#define fill(a, b) memset(a, b, sizeof a)
int fact[N], i... | #include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 10;
const int P = 1e9 + 7;
#define fr(i, low, up, st) for (register int i = low; i <= up; i += st)
#define nfr(i, low, up, st) for (register int i = low; i >= up; i -= st)
#define size(a) a.size()
#define fill(a, b) memset(a, b, sizeof a)
int fact[N], i... | [
"control_flow.loop.for.condition.change"
] | 732,548 | 732,549 | u106671729 | cpp |
p02932 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <ciso646>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#in... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <ciso646>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#in... | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 732,550 | 732,551 | u294531924 | cpp |
p02932 | #include <algorithm>
#include <cstdio>
using namespace std;
typedef long long ll;
const int Maxn = 1e6;
const ll Mod = 1e9 + 7;
ll fac[Maxn + 5], inv_fac[Maxn + 5];
ll QuickPow(ll a, ll k) {
ll ret = 1;
while (k) {
if (k & 1)
ret = (ret * a) % Mod;
a = (a * a) % Mod;
k >>= 1;
}
return ret;
}... | #include <algorithm>
#include <cstdio>
using namespace std;
typedef long long ll;
const int Maxn = 1e6;
const ll Mod = 1e9 + 7;
ll fac[Maxn + 5], inv_fac[Maxn + 5];
ll QuickPow(ll a, ll k) {
ll ret = 1;
while (k) {
if (k & 1)
ret = (ret * a) % Mod;
a = (a * a) % Mod;
k >>= 1;
}
return ret;
}... | [
"control_flow.branch.if.condition.change"
] | 732,552 | 732,553 | u327598261 | cpp |
p02932 | #include <bits/stdc++.h>
using namespace std;
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define ms(s, n) memset(s, n, sizeof(s))
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORd(i, a, b) for (int i = (a)-1; i >= (b); --i)
#define FO... | #include <bits/stdc++.h>
using namespace std;
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define ms(s, n) memset(s, n, sizeof(s))
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORd(i, a, b) for (int i = (a)-1; i >= (b); --i)
#define FO... | [
"literal.number.change",
"call.arguments.change"
] | 732,556 | 732,557 | u264312457 | cpp |
p02933 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
char s[100];
scanf("%d%s", &n, s);
if (n <= 3200)
printf("%s\n", s);
else
printf("red\n");
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
char s[100];
scanf("%d%s", &n, s);
if (n >= 3200)
printf("%s\n", s);
else
printf("red\n");
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 732,560 | 732,561 | u854367220 | cpp |
p02933 | #include <bits/stdc++.h>
using namespace std;
//#define int long long
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
const ll mod = 1000000007;
const ll INF = mod * mod;
const int INF_N = 1e+9;
typedef pair<int, int> P;
// #define stop char nyaa;cin>>nyaa;
#define rep(i, n) for (int i =... | #include <bits/stdc++.h>
using namespace std;
//#define int long long
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
const ll mod = 1000000007;
const ll INF = mod * mod;
const int INF_N = 1e+9;
typedef pair<int, int> P;
// #define stop char nyaa;cin>>nyaa;
#define rep(i, n) for (int i =... | [
"literal.string.change",
"io.output.change"
] | 732,562 | 732,563 | u132371041 | cpp |
p02933 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A;
cin >> A;
string S;
cin >> S;
if (A < 3200) {
cout << S << endl;
} else {
cout << "red" << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int A;
cin >> A;
string S;
cin >> S;
if (A < 3200) {
cout << "red" << endl;
} else {
cout << S << endl;
}
}
| [
"control_flow.branch.else.add"
] | 732,569 | 732,570 | u187772564 | cpp |
p02933 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
using ll = long long;
int main() {
int a;
string s;
cin >> a >> s;
if (a >= 3200)
cout << "red" << endl;
else
cout << s << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
using ll = long long;
int main() {
int a;
string s;
cin >> a >> s;
if (a >= 3200)
cout << s << endl;
else
cout << "red" << endl;
return 0;
} | [
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add",
"control_flow.branch.else.remove"
] | 732,573 | 732,574 | u629603666 | cpp |
p02933 | #define _USE_MATH_DEFINES
#include <algorithm> //sort,min,max,count
#include <cmath> //sqrt,ceil,M_PI, pow
#include <cstdlib> //abs(int)
#include <deque> //deque
#include <iomanip> //setprecision
#include <ios> //fixed
#include <iostream> //cin, cout
#include <numeric> //gcd
#include <sstream> /... | #define _USE_MATH_DEFINES
#include <algorithm> //sort,min,max,count
#include <cmath> //sqrt,ceil,M_PI, pow
#include <cstdlib> //abs(int)
#include <deque> //deque
#include <iomanip> //setprecision
#include <ios> //fixed
#include <iostream> //cin, cout
#include <numeric> //gcd
#include <sstream> /... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 732,575 | 732,576 | u076251280 | cpp |
p02933 | #include <algorithm>
#include <climits>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
vector<int> g[200005];
int main() {
int ... | #include <algorithm>
#include <climits>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
vector<int> g[200005];
int main() {
int ... | [
"control_flow.branch.else.add"
] | 732,592 | 732,593 | u909373588 | cpp |
p02933 | #include <bits/stdc++.h>
using namespace std;
#define all(a) a.begin(), a.end()
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int a;
string s;
cin >> a >> s;
if (a > 3200) {
cout << s;
} else if (a < 3200) {
... | #include <bits/stdc++.h>
using namespace std;
#define all(a) a.begin(), a.end()
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int a;
string s;
cin >> a >> s;
if (a >= 3200) {
cout << s;
} else if (a < 3200) {... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 732,625 | 732,626 | u611594870 | cpp |
p02933 | #include <bits/stdc++.h>
#define rep(i, n) for (long long i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
int main() {
ll a;
string s;
cin >> a >> s;
if (a < 3200)
cout << "red" << endl;
else
cout << "pink" << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (long long i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
int main() {
ll a;
string s;
cin >> a >> s;
if (a < 3200)
cout << "red" << endl;
else
cout << s << endl;
return 0;
}
| [
"io.output.change"
] | 732,637 | 732,638 | u171400122 | cpp |
p02933 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a;
string s;
cin >> a >> s;
if (a >= 3200) {
cout << "red" << endl;
} else {
cout << s << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a;
string s;
cin >> a >> s;
if (a < 3200) {
cout << "red" << endl;
} else {
cout << s << endl;
}
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 732,647 | 732,648 | u758405447 | cpp |
p02933 | #include <bits/stdc++.h>
using namespace ::std;
#define all(x) (x).begin(), (x).end()
typedef long long ll;
typedef array<int, 3> tri;
typedef long double ld;
template <class T> istream &operator>>(istream &I, vector<T> &v) {
for (T &e : v)
I >> e;
return I;
}
template <class T> ostream &operator<<(ostream &... | #include <bits/stdc++.h>
using namespace ::std;
#define all(x) (x).begin(), (x).end()
typedef long long ll;
typedef array<int, 3> tri;
typedef long double ld;
template <class T> istream &operator>>(istream &I, vector<T> &v) {
for (T &e : v)
I >> e;
return I;
}
template <class T> ostream &operator<<(ostream &... | [
"identifier.change",
"io.output.change"
] | 732,651 | 732,652 | u093681822 | cpp |
p02933 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
if (n < 3200)
cout << "red";
else
cout << "pink";
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
if (n < 3200)
cout << "red";
else
cout << s;
} | [
"io.output.change"
] | 732,670 | 732,671 | u515638999 | cpp |
p02933 | #include <iostream>
using namespace std;
int main(void) {
int a;
string s;
cin >> a;
cin >> s;
if (a <= 3200) {
cout << "red" << endl;
}
else {
cout << s << endl;
}
} | #include <iostream>
using namespace std;
int main(void) {
int a;
string s;
cin >> a;
cin >> s;
if (a < 3200) {
cout << "red" << endl;
}
else {
cout << s << endl;
}
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 732,672 | 732,673 | u426670072 | cpp |
p02933 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
int main() {
int n;
char str[11];
scanf("%d%s", &n, &str);
if (n < ... | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
int main() {
int n;
char str[11];
scanf("%d%s", &n, &str);
if (n >=... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 732,685 | 732,686 | u283907492 | cpp |
p02933 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF 1LL << 62
#define inf 1000000007
int main() {
ll a, s;
cin >> a >> s;
if (a >= 3200) {
cout << s;
} else {
cout << "red";
}
// your code goes here
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF 1LL << 62
#define inf 1000000007
int main() {
ll a;
string s;
cin >> a >> s;
if (a >= 3200) {
cout << s;
} else {
cout << "red";
}
// your code goes here
return 0;
} | [] | 732,687 | 732,688 | u166378830 | cpp |
p02933 | #include <iostream>
#include <map>
using namespace std;
#define fin(ans) cout << (ans) << '\n'
int main() {
int a;
string s;
cin >> a;
cin >> s;
if (a <= 3200)
fin(s);
else
fin("red");
return 0;
} | #include <iostream>
#include <map>
using namespace std;
#define fin(ans) cout << (ans) << '\n'
int main() {
int a;
string s;
cin >> a;
cin >> s;
if (a >= 3200)
fin(s);
else
fin("red");
return 0;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 732,694 | 732,695 | u568426505 | cpp |
p02933 | #include <iostream>
using namespace std;
int main() {
int s;
int t;
cin >> s;
cin >> t;
if (3200 > s) {
cout << "red";
} else {
cout << t;
}
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int s;
string t;
cin >> s;
cin >> t;
if (3200 > s) {
cout << "red";
} else {
cout << t;
}
return 0;
}
| [
"variable_declaration.type.change"
] | 732,710 | 732,711 | u742481447 | cpp |
p02933 | #include <iostream>
using namespace std;
int main() {
int s;
int t;
cin >> s;
cin >> t;
if (3200 < s) {
cout << "red";
} else {
cout << "pink";
}
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int s;
string t;
cin >> s;
cin >> t;
if (3200 > s) {
cout << "red";
} else {
cout << t;
}
return 0;
}
| [
"variable_declaration.type.change",
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"io.output.change"
] | 732,712 | 732,711 | u742481447 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.