problem_id stringlengths 6 6 | buggy_code stringlengths 8 526k | fixed_code stringlengths 12 526k | labels listlengths 0 15 ⌀ | buggy_submission_id int64 1 1.54M | fixed_submission_id int64 2 1.54M | user_id stringlengths 10 10 | language stringclasses 8
values |
|---|---|---|---|---|---|---|---|
p03221 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
t... | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
t... | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 1,018,432 | 1,018,433 | u355335354 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
using ll = long long;
int main() {
ll n, m, p[100011], y[100011];
cin >> n >> m;
vector<ll> pd[100001];
for (ll i = 0; i < m; i++) {
cin >> p[i] >> y[i];
pd[p[i]].push_back(y[i]);
}
f... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
using ll = long long;
int main() {
ll n, m, p[100011], y[100011];
cin >> n >> m;
vector<ll> pd[100001];
for (ll i = 0; i < m; i++) {
cin >> p[i] >> y[i];
pd[p[i]].push_back(y[i]);
}
f... | [
"expression.operation.binary.add"
] | 1,018,434 | 1,018,435 | u855186748 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
using ll = long long;
int main() {
ll n, m, p[1000], y[1000];
cin >> n >> m;
vector<ll> pd[100001];
for (ll i = 0; i < m; i++) {
cin >> p[i] >> y[i];
pd[p[i]].push_back(y[i]);
}
for (... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
using ll = long long;
int main() {
ll n, m, p[100011], y[100011];
cin >> n >> m;
vector<ll> pd[100001];
for (ll i = 0; i < m; i++) {
cin >> p[i] >> y[i];
pd[p[i]].push_back(y[i]);
}
f... | [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 1,018,436 | 1,018,435 | u855186748 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef pair<long long int, long long int> P;
typedef pair<P, long long int> PI;
vector<long long int> Pall[100001];
void solve() {
int N, M;
cin >> N ... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef pair<long long int, long long int> P;
typedef pair<P, long long int> PI;
vector<long long int> Pall[100001];
void solve() {
int N, M;
cin >> N ... | [
"expression.operation.binary.add"
] | 1,018,437 | 1,018,438 | u057619905 | cpp |
p03221 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
int main() {
int N, M;
cin >> N >> M;
int P[100001], Y[100001];
rep(i, M) cin >> P[i] >> Y[i];
vector<int> x[100001];
rep(i, M) x[P[i]].push... | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
int main() {
int N, M;
cin >> N >> M;
int P[100001], Y[100001];
rep(i, M) cin >> P[i] >> Y[i];
vector<int> x[100001];
rep(i, M) x[P[i]].push... | [
"identifier.change",
"call.arguments.change"
] | 1,018,458 | 1,018,459 | u347813515 | cpp |
p03221 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
// https://beta.atcoder.jp/contests/abc113/tasks/abc113_c
struct city {
int input_order;
int P;
int Y;
string id_first;
string id_second;
};
bool compare_P(const city &x, const city &y);
bool compare_Y(const c... | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
// https://beta.atcoder.jp/contests/abc113/tasks/abc113_c
struct city {
int input_order;
int P;
int Y;
string id_first;
string id_second;
};
bool compare_P(const city &x, const city &y);
bool compare_Y(const c... | [
"identifier.change",
"assignment.value.change",
"call.function.change",
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,018,479 | 1,018,480 | u333603042 | cpp |
p03221 | #include <algorithm>
#include <iomanip>
#include <ios>
#include <iostream>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int MOD = 1e9 + 7;
#define put(n) cout << (n) << endl
#define rep(i, N) for (int(i) = 0; (i) < (N); ++(i))
#define rrep(i, N) for (int(i) = (N - 1); (i... | #include <algorithm>
#include <iomanip>
#include <ios>
#include <iostream>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int MOD = 1e9 + 7;
#define put(n) cout << (n) << endl
#define rep(i, N) for (int(i) = 0; (i) < (N); ++(i))
#define rrep(i, N) for (int(i) = (N - 1); (i... | [] | 1,018,483 | 1,018,484 | u031178961 | cpp |
p03221 | #include <bits/stdc++.h>
typedef long long ll;
// #define int int_fast64_t
#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 INF 999999999
#define DEBUG(s) cout << s << endl
// typedef int_fast64_t int;
using namespac... | #include <bits/stdc++.h>
typedef long long ll;
// #define int int_fast64_t
#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 INF 999999999
#define DEBUG(s) cout << s << endl
// typedef int_fast64_t int;
using namespac... | [
"io.output.newline.add"
] | 1,018,489 | 1,018,490 | u731368968 | cpp |
p03221 | #include <stdio.h>
#include <stdlib.h>
typedef struct {
int p;
int y;
int i;
int n;
} city_t;
int sort1(const void *a, const void *b) {
if (((city_t *)a)->p != ((city_t *)b)->p) {
return ((city_t *)a)->p - ((city_t *)b)->p;
} else {
return ((city_t *)a)->y - ((city_t *)b)->y;
}
}
int sort2(cons... | #include <stdio.h>
#include <stdlib.h>
typedef struct {
int p;
int y;
int i;
int n;
} city_t;
int sort1(const void *a, const void *b) {
if (((city_t *)a)->p != ((city_t *)b)->p) {
return ((city_t *)a)->p - ((city_t *)b)->p;
} else {
return ((city_t *)a)->y - ((city_t *)b)->y;
}
}
int sort2(cons... | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 1,018,496 | 1,018,497 | u717659249 | cpp |
p03221 | #include <stdio.h>
#include <stdlib.h>
typedef struct {
int p;
int y;
int i;
int n;
} city_t;
int sort1(const void *a, const void *b) {
if (((city_t *)a)->p != ((city_t *)b)->p) {
return ((city_t *)a)->p - ((city_t *)b)->p;
} else {
return ((city_t *)a)->y - ((city_t *)b)->y;
}
}
int sort2(cons... | #include <stdio.h>
#include <stdlib.h>
typedef struct {
int p;
int y;
int i;
int n;
} city_t;
int sort1(const void *a, const void *b) {
if (((city_t *)a)->p != ((city_t *)b)->p) {
return ((city_t *)a)->p - ((city_t *)b)->p;
} else {
return ((city_t *)a)->y - ((city_t *)b)->y;
}
}
int sort2(cons... | [
"assignment.change",
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 1,018,498 | 1,018,497 | u717659249 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int p;
string y;
vector<pair<string, int>> empty;
vector<vector<pair<string, int>>> v(n, empty);
for (int i = 0; i < m; ++i) {
cin >> p >> y;
v[p - 1].push_back({y, i});
}
string x = "";
vector<string> ids(... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int p, y;
vector<pair<int, int>> empty;
vector<vector<pair<int, int>>> v(n, empty);
for (int i = 0; i < m; ++i) {
cin >> p >> y;
v[p - 1].push_back({y, i});
}
string x = "";
vector<string> ids(m, x);
for (... | [] | 1,018,506 | 1,018,507 | u925758711 | cpp |
p03221 | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
#define int long long
typedef long long lint;
// typedef pair<int,int> P;
const int INF = (int)1e9;
const int MOD = (int)1e9 + 7;
const double EPS = (double)1e-10;
const int dx[] = {-1, 0, 0, 1};
const int dy[] = {0, -1, 1, 0};
struct Accelerate_Ci... | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
#define int long long
typedef long long lint;
// typedef pair<int,int> P;
const int INF = (int)1e9;
const int MOD = (int)1e9 + 7;
const double EPS = (double)1e-10;
const int dx[] = {-1, 0, 0, 1};
const int dy[] = {0, -1, 1, 0};
struct Accelerate_Ci... | [] | 1,018,508 | 1,018,509 | u876978301 | cpp |
p03221 | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
#define int long long
typedef long long lint;
// typedef pair<int,int> P;
const int INF = (int)1e9;
const int MOD = (int)1e9 + 7;
const double EPS = (double)1e-10;
const int dx[] = {-1, 0, 0, 1};
const int dy[] = {0, -1, 1, 0};
struct Accelerate_Ci... | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
#define int long long
typedef long long lint;
// typedef pair<int,int> P;
const int INF = (int)1e9;
const int MOD = (int)1e9 + 7;
const double EPS = (double)1e-10;
const int dx[] = {-1, 0, 0, 1};
const int dy[] = {0, -1, 1, 0};
struct Accelerate_Ci... | [] | 1,018,510 | 1,018,511 | u876978301 | cpp |
p03221 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
#define all(x) x.begin(), x.end()
int main() {
int n, m;
cin >> n >> m;
vector<pair<pair<int, int>, int>> city(m);
vector<pair<int, int>> ans(m);
int y[n];
for (int ... | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
#define all(x) x.begin(), x.end()
int main() {
int n, m;
cin >> n >> m;
vector<pair<pair<int, int>, int>> city(m);
vector<pair<int, int>> ans(m);
int y[n];
for (int ... | [
"assignment.change"
] | 1,018,516 | 1,018,517 | u201234972 | cpp |
p03221 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
#define all(x) x.begin(), x.end()
int main() {
int n, m;
cin >> n >> m;
vector<pair<pair<int, int>, int>> city(m);
vector<pair<int, int>> ans(m);
int y[n];
for (int ... | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
#define all(x) x.begin(), x.end()
int main() {
int n, m;
cin >> n >> m;
vector<pair<pair<int, int>, int>> city(m);
vector<pair<int, int>> ans(m);
int y[n];
for (int ... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"assignment.change"
] | 1,018,518 | 1,018,517 | u201234972 | cpp |
p03221 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
#define all(x) x.begin(), x.end()
int main() {
int n, m;
cin >> n >> m;
vector<pair<pair<int, int>, int>> city(m);
vector<pair<int, int>> ans(m);
int y[m];
for (int ... | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
#define all(x) x.begin(), x.end()
int main() {
int n, m;
cin >> n >> m;
vector<pair<pair<int, int>, int>> city(m);
vector<pair<int, int>> ans(m);
int y[n];
for (int ... | [
"identifier.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"assignment.change"
] | 1,018,519 | 1,018,517 | u201234972 | cpp |
p03221 | #include <algorithm>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
bool cmp(pair<int, int> a, pair<int, int> b) { return a.first < b.first; }
int output(int i) {
if (i < 10) {
cout << "00000" << i;
} else if (i < 100) {
cout << "0000" ... | #include <algorithm>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
bool cmp(pair<int, int> a, pair<int, int> b) { return a.first < b.first; }
int output(int i) {
if (i < 10) {
cout << "00000" << i;
} else if (i < 100) {
cout << "0000" ... | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,018,535 | 1,018,536 | u791073783 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
#define all(x) (x).begin(), (x).end()
void solve() {
int n, m;
cin >> n >> m;
vector<int> p(m), y(m);
vector<vector<int>> v(n + 1);
for (int i = 0; i < m; i++) {
cin >> p[i] >> y[i];
v[p[i]].push_back(y[i]);
}
for (int i = 0; i < n; i++) {
// so... | #include <bits/stdc++.h>
using namespace std;
#define all(x) (x).begin(), (x).end()
void solve() {
int n, m;
cin >> n >> m;
vector<int> p(m), y(m);
vector<vector<int>> data(n + 1);
for (int i = 0; i < m; i++) {
cin >> p[i] >> y[i];
data[p[i]].push_back(y[i]);
}
for (int i = 0; i < n + 1; i++) {... | [
"variable_declaration.name.change",
"identifier.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"call.arguments.change"
] | 1,018,539 | 1,018,540 | u824332405 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
struct city {
int number;
int prefect;
int year;
int id;
};
void printid(int p, int id) {
cout << setfill('0') << right << setw(6) << p;
cout << setfill('0') << right << setw(6) << id << end... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
struct city {
int number;
int prefect;
int year;
int id;
};
void printid(int p, int id) {
cout << setfill('0') << right << setw(6) << p;
cout << setfill('0') << right << setw(6) << id << end... | [
"identifier.change",
"call.function.change"
] | 1,018,543 | 1,018,544 | u801807320 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
struct city {
int number;
int prefect;
long long year;
int id;
};
void printid(int p, int id) {
cout << setfill('0') << right << setw(6) << p;
cout << setfill('0') << right << setw(6) << id ... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
struct city {
int number;
int prefect;
int year;
int id;
};
void printid(int p, int id) {
cout << setfill('0') << right << setw(6) << p;
cout << setfill('0') << right << setw(6) << id << end... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.narrow.change",
"identifier.change",
"call.function.change"
] | 1,018,545 | 1,018,544 | u801807320 | cpp |
p03221 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> p(m);
vector<pair<long, int>> pairs(m);
vector<int> ccc(m);
long t;
for (int i = 0; i < m; i++) {
cin >> p[i] >> t;
pairs[i] = make_pair(t, i);
}
sort(pairs.begin(), pairs.end());
vector<int> ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> p(m);
vector<pair<long, int>> pairs(m);
vector<int> ccc(m);
long t;
for (int i = 0; i < m; i++) {
cin >> p[i] >> t;
pairs[i] = make_pair(t, i);
}
sort(pairs.begin(), pairs.end());
vector<int> c... | [] | 1,018,550 | 1,018,551 | u503170128 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<vector<pair<ll, ll>>> p(m, vector<pair<ll, ll>>(0));
vector<string> id(m);
for (int i = 0; i < m; i++) {
ll place, year;
cin >> place >> year;
... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<vector<pair<ll, ll>>> p(n, vector<pair<ll, ll>>(0));
vector<string> id(m);
for (int i = 0; i < m; i++) {
ll place, year;
cin >> place >> year;
... | [
"identifier.change",
"call.arguments.change"
] | 1,018,552 | 1,018,553 | u853947407 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, n;
cin >> n >> m;
vector<vector<pair<int, int>>> v(n);
for (int i = 0; i < m; i++) {
int p, y;
cin >> p >> y;
p--;
y--;
v[p].push_back(make_pair(y, i));
}
vector<pair<int, int>> ans(n);
for (int i = 0; i < n; i++) {
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, n;
cin >> n >> m;
vector<vector<pair<int, int>>> v(n);
for (int i = 0; i < m; i++) {
int p, y;
cin >> p >> y;
p--;
y--;
v[p].push_back(make_pair(y, i));
}
vector<pair<int, int>> ans(m);
for (int i = 0; i < n; i++) {
... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"literal.string.change",
"call.arguments.change",
"io.output.change",
"io.output.newline.add"
] | 1,018,555 | 1,018,556 | u640323045 | cpp |
p03221 | #include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
struct City {
int prefecture;
int year;
int x;
};
int main() {
int N, M;
cin >> N >> M;
vector<City> city(M);
map<int, map<int, int>> years;
for (int i = 1; i <= M; i++) {
int Pi, Yi;
ci... | #include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
struct City {
int prefecture;
int year;
int x;
};
int main() {
int N, M;
cin >> N >> M;
vector<City> city(M + 1);
map<int, map<int, int>> years;
for (int i = 1; i <= M; i++) {
int Pi, Yi;
... | [
"assignment.change"
] | 1,018,579 | 1,018,580 | u995102075 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
struct city {
int index;
int p;
int y;
char s[13];
};
bool asc_y(const city &left, const city &right) {
return left.p == right.p ? left.y < right.y : left.p < left.p;
}
bool asc_index(const city &left, const city &right) {
return left.index < right.index;
}
... | #include <bits/stdc++.h>
using namespace std;
struct city {
int index;
int p;
int y;
char s[13];
};
bool asc_y(const city &left, const city &right) {
return left.p == right.p ? left.y < right.y : left.p < right.p;
}
bool asc_index(const city &left, const city &right) {
return left.index < right.index;
}
... | [
"identifier.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 1,018,581 | 1,018,582 | u115086397 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
struct city {
int index;
int p;
int y;
char s[12];
};
bool asc_y(const city &left, const city &right) {
return left.p == right.p ? left.y < right.y : left.p < left.p;
}
bool asc_index(const city &left, const city &right) {
return left.index < right.index;
}
... | #include <bits/stdc++.h>
using namespace std;
struct city {
int index;
int p;
int y;
char s[13];
};
bool asc_y(const city &left, const city &right) {
return left.p == right.p ? left.y < right.y : left.p < right.p;
}
bool asc_index(const city &left, const city &right) {
return left.index < right.index;
}
... | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"identifier.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 1,018,584 | 1,018,582 | u115086397 | cpp |
p03221 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, x) for (__typeof(x) i = 0; i < x; i++)
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define sz(x) (int)((x).size())
#define all(x) (x).begin(), (x).end()
#define sci(x) ... |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, x) for (__typeof(x) i = 0; i < x; i++)
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define sz(x) (int)((x).size())
#define all(x) (x).begin(), (x).end()
#define sci(x) ... | [
"identifier.change",
"call.arguments.change"
] | 1,018,585 | 1,018,586 | u500451627 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <sstream>
#include <vector>
using ll = long long;
using namespace std;
int main() {
int N, M;
cin >> N >> M;
// vector<vector<int>> d(N, vector<int>(1000000000, -1));
vector<v... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <sstream>
#include <vector>
using ll = long long;
using namespace std;
int main() {
int N, M;
cin >> N >> M;
// vector<vector<int>> d(N, vector<int>(1000000000, -1));
vector<v... | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,018,589 | 1,018,590 | u750543944 | cpp |
p03221 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
struct A {
bool operator<(const A &a) const { return p != a.p ? p < a.p : y < a.y; }
int p, y, i;
};
int main() {
int n, m;
std::cin >> n >> m;
std::vector<A> a(m);
std::vector<A> r(m);
for (int i = 0; i < m; ++i) {
int p... | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
struct A {
bool operator<(const A &a) const { return p != a.p ? p < a.p : y < a.y; }
int p, y, i;
};
int main() {
int n, m;
std::cin >> n >> m;
std::vector<A> a(m);
std::vector<A> r(m);
for (int i = 0; i < m; ++i) {
int p... | [
"expression.operation.binary.add"
] | 1,018,591 | 1,018,592 | u352314733 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const int MOD = 1000000007;
const double EPS = 1e-9;
... | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const int MOD = 1000000007;
const double EPS = 1e-9;
... | [
"literal.string.change",
"call.arguments.change",
"io.output.change",
"io.output.newline.add"
] | 1,018,593 | 1,018,594 | u799021348 | cpp |
p03221 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define NMAX 110000
struct info {
int p;
int y;
int x;
};
int main(void) {
int n, m;
cin >> n >> m;
info py[NMAX];
for (int i = 0; i < m; i++) {
cin >> py[i].p >> py[i].y;
}
vector<int> mp[NMAX];
for (int i = 0; i < m; i++) {
... | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define NMAX 110000
struct info {
int p;
int y;
int x;
};
int main(void) {
int n, m;
cin >> n >> m;
info py[NMAX];
for (int i = 0; i < m; i++) {
cin >> py[i].p >> py[i].y;
}
vector<int> mp[NMAX];
for (int i = 0; i < m; i++) {
... | [
"call.arguments.change",
"call.arguments.add"
] | 1,018,595 | 1,018,596 | u330661451 | cpp |
p03221 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define NMAX 110000
struct info {
int p;
int y;
int x;
};
int main(void) {
int n, m;
cin >> n >> m;
info py[NMAX];
for (int i = 0; i < m; i++) {
cin >> py[i].p >> py[i].y;
}
vector<int> mp[NMAX];
for (int i = 0; i < m; i++) {
... | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define NMAX 110000
struct info {
int p;
int y;
int x;
};
int main(void) {
int n, m;
cin >> n >> m;
info py[NMAX];
for (int i = 0; i < m; i++) {
cin >> py[i].p >> py[i].y;
}
vector<int> mp[NMAX];
for (int i = 0; i < m; i++) {
... | [
"call.function.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,018,597 | 1,018,598 | u330661451 | cpp |
p03221 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define NMAX 110000
struct info {
int p;
unsigned int y;
int x;
};
int main(void) {
int n, m;
cin >> n >> m;
info py[NMAX];
for (int i = 0; i < m; i++) {
cin >> py[i].p >> py[i].y;
}
vector<int> mp[NMAX];
for (int i = 0; i < m;... | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define NMAX 110000
struct info {
int p;
int y;
int x;
};
int main(void) {
int n, m;
cin >> n >> m;
info py[NMAX];
for (int i = 0; i < m; i++) {
cin >> py[i].p >> py[i].y;
}
vector<int> mp[NMAX];
for (int i = 0; i < m; i++) {
... | [
"variable_declaration.type.narrow.change",
"call.function.change",
"control_flow.loop.for.condition.change"
] | 1,018,599 | 1,018,598 | u330661451 | cpp |
p03221 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define NMAX 110000
struct info {
int p;
int y;
int x;
};
int main(void) {
int n, m;
cin >> n >> m;
info py[NMAX];
for (int i = 0; i < m; i++) {
cin >> py[i].p >> py[i].y;
}
vector<int> mp[NMAX];
for (int i = 0; i < m; i++) {
... | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define NMAX 110000
struct info {
int p;
int y;
int x;
};
int main(void) {
int n, m;
cin >> n >> m;
info py[NMAX];
for (int i = 0; i < m; i++) {
cin >> py[i].p >> py[i].y;
}
vector<int> mp[NMAX];
for (int i = 0; i < m; i++) {
... | [
"call.function.change",
"control_flow.loop.for.condition.change"
] | 1,018,600 | 1,018,598 | u330661451 | cpp |
p03221 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define NMAX 110000
struct info {
int p;
int y;
int x;
};
int main(void) {
int n, m;
cin >> n >> m;
info py[NMAX];
for (int i = 0; i < m; i++) {
cin >> py[i].p >> py[i].y;
}
vector<int> mp[NMAX];
for (int i = 0; i < m; i++) {
... | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define NMAX 110000
struct info {
int p;
int y;
int x;
};
int main(void) {
int n, m;
cin >> n >> m;
info py[NMAX];
for (int i = 0; i < m; i++) {
cin >> py[i].p >> py[i].y;
}
vector<int> mp[NMAX];
for (int i = 0; i < m; i++) {
... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,018,597 | 1,018,601 | u330661451 | cpp |
p03221 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define NMAX 110000
struct info {
int p;
unsigned int y;
int x;
};
int main(void) {
int n, m;
cin >> n >> m;
info py[NMAX];
for (int i = 0; i < m; i++) {
cin >> py[i].p >> py[i].y;
}
vector<int> mp[NMAX];
for (int i = 0; i < m;... | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define NMAX 110000
struct info {
int p;
int y;
int x;
};
int main(void) {
int n, m;
cin >> n >> m;
info py[NMAX];
for (int i = 0; i < m; i++) {
cin >> py[i].p >> py[i].y;
}
vector<int> mp[NMAX];
for (int i = 0; i < m; i++) {
... | [
"variable_declaration.type.narrow.change",
"control_flow.loop.for.condition.change"
] | 1,018,599 | 1,018,601 | u330661451 | cpp |
p03221 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define NMAX 110000
struct info {
int p;
int y;
int x;
};
int main(void) {
int n, m;
cin >> n >> m;
info py[NMAX];
for (int i = 0; i < m; i++) {
cin >> py[i].p >> py[i].y;
}
vector<int> mp[NMAX];
for (int i = 0; i < m; i++) {
... | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define NMAX 110000
struct info {
int p;
int y;
int x;
};
int main(void) {
int n, m;
cin >> n >> m;
info py[NMAX];
for (int i = 0; i < m; i++) {
cin >> py[i].p >> py[i].y;
}
vector<int> mp[NMAX];
for (int i = 0; i < m; i++) {
... | [
"control_flow.loop.for.condition.change"
] | 1,018,600 | 1,018,601 | u330661451 | cpp |
p03221 | #include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <algorithm>
#include <array>
#include <cmath>
#include <cstring>
#include <iostream>
#include <numeric>
#include <string>
#include <utility>
#include <vector>
int gcd(int x, int y) {
x = std::abs(x);
y = std::abs(y);
int a = std::max(x, y), b = s... | #include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <algorithm>
#include <array>
#include <cmath>
#include <cstring>
#include <iostream>
#include <numeric>
#include <string>
#include <utility>
#include <vector>
int gcd(int x, int y) {
x = std::abs(x);
y = std::abs(y);
int a = std::max(x, y), b = s... | [
"identifier.change",
"expression.operation.binary.change"
] | 1,018,602 | 1,018,603 | u299647642 | cpp |
p03221 | // class point の練習（クラスの高度な実装）
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <queue>
#include <vector>
typedef long long llong;
using namespace std;
#define MAX 100010
struct city {
int P;
int num;
};
int main() {
int... | // class point の練習（クラスの高度な実装）
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <queue>
#include <vector>
typedef long long llong;
using namespace std;
#define MAX 100010
struct city {
int P;
int num;
};
int main() {
int... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,018,605 | 1,018,606 | u301893320 | cpp |
p03221 | // class point の練習（クラスの高度な実装）
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <queue>
#include <vector>
typedef long long llong;
using namespace std;
#define MAX 100
struct city {
int P;
int num;
};
int main() {
int N,... | // class point の練習（クラスの高度な実装）
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <queue>
#include <vector>
typedef long long llong;
using namespace std;
#define MAX 100010
struct city {
int P;
int num;
};
int main() {
int... | [
"preprocessor.define.value.change",
"literal.integer.change",
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,018,607 | 1,018,606 | u301893320 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<vector<int>> pre_year(100001);
vector<int> pre(100001);
vector<int> year(100001);
for (int i = 0; i < M; i++) {
cin >> pre[i] >> year[i];
pre_year[pre[i]].push_back(year[i]);
}
for (int i = 0; i < N; i+... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<vector<int>> pre_year(100001);
vector<int> pre(100001);
vector<int> year(100001);
for (int i = 0; i < M; i++) {
cin >> pre[i] >> year[i];
pre_year[pre[i]].push_back(year[i]);
}
for (int i = 1; i <= N; i... | [
"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"
] | 1,018,611 | 1,018,612 | u711340028 | cpp |
p03221 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <utility>
using namespace std;
struct shi {
int x;
int y;
int z;
};
int main() {
int N, M;
cin >> N >> M;
shi P[M];
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
P[i].x = a;
P[i].y = b;
P[i].z = i;
}
s... | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <utility>
using namespace std;
struct shi {
int x;
int y;
int z;
};
int main() {
int N, M;
cin >> N >> M;
shi P[M];
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
P[i].x = a;
P[i].y = b;
P[i].z = i;
}
s... | [
"literal.number.change",
"io.output.change"
] | 1,018,613 | 1,018,614 | u691174149 | cpp |
p03221 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <utility>
using namespace std;
struct shi {
int x;
int y;
int z;
};
int main() {
int N, M;
cin >> N >> M;
shi P[M];
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
P[i].x = a;
P[i].y = b;
P[i].z = i;
}
s... | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <utility>
using namespace std;
struct shi {
int x;
int y;
int z;
};
int main() {
int N, M;
cin >> N >> M;
shi P[M];
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
P[i].x = a;
P[i].y = b;
P[i].z = i;
}
s... | [
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 1,018,615 | 1,018,614 | u691174149 | cpp |
p03221 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <utility>
using namespace std;
struct shi {
int x;
int y;
int z;
};
int main() {
int N, M;
cin >> N >> M;
shi P[M];
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
P[i].x = a;
P[i].y = b;
P[i].z = i;
}
s... | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <utility>
using namespace std;
struct shi {
int x;
int y;
int z;
};
int main() {
int N, M;
cin >> N >> M;
shi P[M];
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
P[i].x = a;
P[i].y = b;
P[i].z = i;
}
s... | [
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change",
"literal.number.change",
"io.output.change"
] | 1,018,616 | 1,018,614 | u691174149 | cpp |
p03221 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <sstream>
#include <utility>
#include <vector>
using namespace std;
string getNumber4digit(int i) {
ostringstream oss;
oss << setfill('0') << setw(4) << i;
return oss.str();
}
string getNumber(int i, int j) {
return getN... | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <sstream>
#include <utility>
#include <vector>
using namespace std;
string getNumber6digit(int i) {
ostringstream oss;
oss << setfill('0') << setw(6) << i;
return oss.str();
}
string getNumber(int i, int j) {
return getN... | [
"identifier.change",
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"call.function.change",
"function.return_value.change"
] | 1,018,620 | 1,018,621 | u013936801 | cpp |
p03221 | #include <bits/stdc++.h>
#define FOR(i, begin, end) for (int i = (begin); i < (end); i++)
#define REP(i, n) FOR(i, 0, n)
#define IFOR(i, begin, end) for (int i = (end)-1; i >= (begin); i--)
#define IREP(i, n) IFOR(i, 0, n)
#define SORT(a) sort(a.begin(), a.end())
#define REVERSE(a) reverse(a.begin(), a.end())
#define L... | #include <bits/stdc++.h>
#define FOR(i, begin, end) for (int i = (begin); i < (end); i++)
#define REP(i, n) FOR(i, 0, n)
#define IFOR(i, begin, end) for (int i = (end)-1; i >= (begin); i--)
#define IREP(i, n) IFOR(i, 0, n)
#define SORT(a) sort(a.begin(), a.end())
#define REVERSE(a) reverse(a.begin(), a.end())
#define L... | [] | 1,018,633 | 1,018,634 | u434231045 | cpp |
p03221 | #include <algorithm>
#include <iostream>
#include <queue>
#include <utility>
#include <vector>
using namespace std;
#define Pair pair<int, int>
#define List pair<int, Pair>
int N, M;
int P[100010];
int Y[100010];
int ID[100010];
vector<List> lst;
bool compare(List x, List y) {
if (x.second.first == y.second.first... | #include <algorithm>
#include <iostream>
#include <queue>
#include <utility>
#include <vector>
using namespace std;
#define Pair pair<int, int>
#define List pair<int, Pair>
int N, M;
int P[100010];
int Y[100010];
int ID[100010];
vector<List> lst;
bool compare(List x, List y) {
if (x.second.first == y.second.first... | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 1,018,648 | 1,018,649 | u540433787 | cpp |
p03221 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <ios>
#include <iostream>
#include <limits.h>
#include <set>
#include <utility>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
typedef unsigned long ul;
typedef unsigned long long ull;
typedef long long ll;
using names... | #include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <ios>
#include <iostream>
#include <limits.h>
#include <set>
#include <utility>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
typedef unsigned long ul;
typedef unsigned long long ull;
typedef long long ll;
using names... | [
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,018,653 | 1,018,654 | u037703936 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<vector<int>> vvi(M + 1);
vector<int> P(M), Y(M);
for (int i = 0; i < M; i++) {
cin >> P[i] >> Y[i];
vvi[P[i]].push_back(Y[i]);
}
vector<map<int, int>> vm(M + 1);
for (int i = 0; i < M + 1; i++) {
s... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<vector<int>> vvi(N + 1);
vector<int> P(M), Y(M);
for (int i = 0; i < M; i++) {
cin >> P[i] >> Y[i];
vvi[P[i]].push_back(Y[i]);
}
vector<map<int, int>> vm(N + 1);
for (int i = 0; i < N + 1; i++) {
s... | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"control_flow.loop.for.condition.change"
] | 1,018,659 | 1,018,660 | u234435881 | cpp |
p03221 | #include <algorithm>
#include <iostream>
#include <limits>
#include <math.h>
#include <numeric>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define in... | #include <algorithm>
#include <iostream>
#include <limits>
#include <math.h>
#include <numeric>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define in... | [
"expression.unary.arithmetic.add"
] | 1,018,670 | 1,018,671 | u190907730 | cpp |
p03221 | #include <algorithm>
#include <iostream>
#include <limits>
#include <math.h>
#include <numeric>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define in... | #include <algorithm>
#include <iostream>
#include <limits>
#include <math.h>
#include <numeric>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define in... | [
"identifier.change",
"call.function.change",
"expression.unary.arithmetic.add"
] | 1,018,672 | 1,018,671 | u190907730 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int x, y;
cin >> x >> y;
vector<tuple<ll, ll, int>> z;
for (int a = 0; a < y; a++) {
ll p, q;
cin >> p >> q;
z.push_back(make_tuple(p, q, a));
}
sort(z.begin(), z.end());
int turn[99999];
int num[99999];
in... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int x, y;
cin >> x >> y;
vector<tuple<ll, ll, int>> z;
for (int a = 0; a < y; a++) {
ll p, q;
cin >> p >> q;
z.push_back(make_tuple(p, q, a));
}
sort(z.begin(), z.end());
int turn[99999];
int num[99999];
in... | [] | 1,018,675 | 1,018,676 | u036561304 | cpp |
p03221 | #include <algorithm>
#include <bits/stdc++.h>
#include <deque>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
//#define ll long long
#define MOD 1000000007
#define INF 214748364
using namespace std;
long long read() {
long long kk(0);
bool fh = true;
char ch = getchar();
wh... | #include <algorithm>
#include <bits/stdc++.h>
#include <deque>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
//#define ll long long
#define MOD 1000000007
#define INF 214748364
using namespace std;
long long read() {
long long kk(0);
bool fh = true;
char ch = getchar();
wh... | [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 1,018,677 | 1,018,678 | u439474750 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
int n, m;
int ans = 1, sum = 1;
struct edge {
int yi;
int pii;
int cnt;
int L;
int R;
} a[100001];
bool cmp(edge a, edge b) {
if (a.pii == b.pii)
return a.yi < b.yi;
return a.pii < b.pii;
}
bool cmp1(edge ... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
int n, m;
int ans = 1, sum = 1;
struct edge {
int yi;
int pii;
int cnt;
int L;
int R;
} a[100001];
bool cmp(edge a, edge b) {
if (a.pii == b.pii)
return a.yi < b.yi;
return a.pii < b.pii;
}
bool cmp1(edge ... | [
"expression.unary.arithmetic.add"
] | 1,018,685 | 1,018,686 | u766435766 | cpp |
p03221 | #include "algorithm"
#include "cmath"
#include "iostream"
#include "string"
#include "utility"
#include "vector"
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
void print_mine(ll id) {
int keta = 0;
ll id_ori = id;
while (id != 0) {
id /= 10;
keta++;
}
for (size_t i = 0; i < 12 ... | #include "algorithm"
#include "cmath"
#include "iostream"
#include "string"
#include "utility"
#include "vector"
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
void print_mine(ll id) {
int keta = 0;
ll id_ori = id;
while (id != 0) {
id /= 10;
keta++;
}
for (size_t i = 0; i < 12 ... | [
"literal.number.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 1,018,689 | 1,018,690 | u271986615 | cpp |
p03221 | #include <algorithm>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
struct City {
int index;
int prefecture;
long long year;
int num;
City(int input_index, int input_prefecture, long long input_year) {
index = input_index;... | #include <algorithm>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
struct City {
int index;
int prefecture;
long long year;
int num;
City(int input_index, int input_prefecture, long long input_year) {
index = input_index;... | [
"identifier.change",
"call.function.change"
] | 1,018,701 | 1,018,702 | u777853124 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
#define int long long
struct EDG {
long long x, y, num;
} a[100001];
bool operator<(EDG a, EDG b) {
if (a.x == b.x)
return a.y < b.y;
return a.x < b.x;
}
long long n, m, ans1[100001], ans2[100001], flag[100001], flg[100001];
#undef int
int main() {
#define int lon... | #include <bits/stdc++.h>
using namespace std;
#define int long long
struct EDG {
long long x, y, num;
} a[100001];
bool operator<(EDG a, EDG b) {
if (a.x == b.x)
return a.y < b.y;
return a.x < b.x;
}
long long n, m, ans1[100001], ans2[100001], flag[100001], flg[100001];
#undef int
int main() {
#define int lon... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 1,018,703 | 1,018,704 | u696083485 | cpp |
p03221 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
struct City {
int idx;
int Y;
int P;
int x;
};
bool comp(City i, City j) { return (i.P < j.P); }
bool comp_idx(City i, City j) { return (i.idx < j.idx); }
int main() {
// Yは全て異なる
int N, M;... | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
struct City {
int idx;
int Y;
int P;
int x;
};
bool comp(City i, City j) { return (i.Y < j.Y); }
bool comp_idx(City i, City j) { return (i.idx < j.idx); }
int main() {
// Yは全て異なる
int N, M;... | [
"function.return_value.change",
"expression.operation.binary.change"
] | 1,018,712 | 1,018,713 | u642210599 | cpp |
p03221 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
struct City {
int idx;
int Y;
int P;
int x;
};
bool comp(City i, City j) { return (i.P < j.P); }
bool comp_idx(City i, City j) { return (i.idx < j.idx); }
int main() {
// Yは全て異なる
int N, M;... | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
struct City {
int idx;
int Y;
int P;
int x;
};
bool comp(City i, City j) { return (i.Y < j.Y); }
bool comp_idx(City i, City j) { return (i.idx < j.idx); }
int main() {
// Yは全て異なる
int N, M;... | [
"function.return_value.change",
"expression.operation.binary.change",
"control_flow.loop.for.condition.change"
] | 1,018,714 | 1,018,713 | u642210599 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
using LL = long long;
int main() {
vector<vector<pair<LL, int>>> y(100005);
LL N, M;
cin >> N >> M;
for (int i = 1; i <= M; i++) {
LL P, Y;
cin >> P >> Y;
y[P].push_back({Y, i});
}
for (int i = 1; i < N; i++) {
sort(y[i].begin(), y[i].end());
}... | #include <bits/stdc++.h>
using namespace std;
using LL = long long;
int main() {
vector<vector<pair<LL, int>>> y(100005);
LL N, M;
cin >> N >> M;
for (int i = 1; i <= M; i++) {
LL P, Y;
cin >> P >> Y;
y[P].push_back({Y, i});
}
for (int i = 1; i <= N; i++) {
sort(y[i].begin(), y[i].end());
... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,018,715 | 1,018,716 | u296096665 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
int n, m;
int p[100001], y[100001];
vector<int> v[100001];
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
p[i] = a;
y[i] = b;
}
for (int i = 0; i < n; i++) {
... | #include <bits/stdc++.h>
using namespace std;
int n, m;
int p[100001], y[100001];
vector<int> v[100001];
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
p[i] = a;
y[i] = b;
}
for (int i = 0; i < 100001; i++)... | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,018,723 | 1,018,724 | u257960005 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <queue>
#include <string>
#include <utility>
#include <vector>
//#include <stack>
#include <climits>
#include <map>
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, n1, n2) for (int i = n1; i < n2; i++)
#define put(a) c... | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <queue>
#include <string>
#include <utility>
#include <vector>
//#include <stack>
#include <climits>
#include <map>
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, n1, n2) for (int i = n1; i < n2; i++)
#define put(a) c... | [
"identifier.change",
"call.arguments.change"
] | 1,018,732 | 1,018,733 | u030685402 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <queue>
#include <string>
#include <utility>
#include <vector>
//#include <stack>
#include <climits>
#include <map>
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, n1, n2) for (int i = n1; i < n2; i++)
#define put(a) c... | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <queue>
#include <string>
#include <utility>
#include <vector>
//#include <stack>
#include <climits>
#include <map>
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, n1, n2) for (int i = n1; i < n2; i++)
#define put(a) c... | [
"expression.operator.change",
"identifier.change",
"call.arguments.change"
] | 1,018,734 | 1,018,733 | u030685402 | cpp |
p03221 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
auto ys = vector<pair<int, pair<int, int>>>(m);
auto ps = vector<int>(n);
for (int i = 0; i < m; ++i) {
int p, y;
cin >> p >> y;
ys[i] = make_pair(y, make_pair(... | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
auto ys = vector<pair<int, pair<int, int>>>(m);
auto ps = vector<int>(m);
for (int i = 0; i < m; ++i) {
int p, y;
cin >> p >> y;
ys[i] = make_pair(y, make_pair(... | [
"identifier.change",
"call.arguments.change"
] | 1,018,737 | 1,018,738 | u303356821 | cpp |
p03221 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <istream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <... | #include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <istream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <... | [
"assignment.change"
] | 1,018,742 | 1,018,743 | u361767189 | cpp |
p03221 | // long time no ac
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define vll vector<ll>
#define vi vector<int>
#define rep(i, n) for (i = 0; i < n; i++)
#define repe(i, I1, I2) for (i = I1; i < I2; i++)
#define pb push_back
#define mp make_pair
#define endl '\n'
#define mod 1000000007
ll cd(l... | // long time no ac
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define vll vector<ll>
#define vi vector<int>
#define rep(i, n) for (i = 0; i < n; i++)
#define repe(i, I1, I2) for (i = I1; i < I2; i++)
#define pb push_back
#define mp make_pair
#define endl '\n'
#define mod 1000000007
ll cd(l... | [
"identifier.change",
"variable_declaration.array_dimensions.change"
] | 1,018,754 | 1,018,755 | u355198744 | cpp |
p03221 | #include <bits/stdc++.h>
#define st first
#define nd second
using namespace std;
typedef pair<int, int> PII;
typedef long long ll;
const int MXM = 1e5 + 10;
struct node {
int id;
int p, y;
} city[MXM];
bool cmp(node a, node b) {
if (a.p != b.p)
return a.p < b.p;
return a.y < b.y;
}
ll ans[MXM];
int ... | #include <bits/stdc++.h>
#define st first
#define nd second
using namespace std;
typedef pair<int, int> PII;
typedef long long ll;
const int MXM = 1e5 + 10;
struct node {
int id;
int p, y;
} city[MXM];
bool cmp(node a, node b) {
if (a.p != b.p)
return a.p < b.p;
return a.y < b.y;
}
ll ans[MXM];
int ... | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 1,018,765 | 1,018,766 | u818449738 | cpp |
p03221 | #include <algorithm>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define ll long long
#define ull unsigned long long
#define IN... | #include <algorithm>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define ll long long
#define ull unsigned long long
#define IN... | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,018,770 | 1,018,771 | u961611557 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
#define inf 1 << 30
#define llong long long
#define usd unsigned
#define pqueue priority_queue
#define mp make_pair
#define pb push_back
#define fn fill_n
#define P pair<int, int>
struct data {
int place;
int cost;
bool operator<(const data &ri) const { return cost... | #include <bits/stdc++.h>
using namespace std;
#define inf 1 << 30
#define llong long long
#define usd unsigned
#define pqueue priority_queue
#define mp make_pair
#define pb push_back
#define fn fill_n
#define P pair<int, int>
struct data {
int place;
int cost;
bool operator<(const data &ri) const { return cost... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,018,772 | 1,018,773 | u341957179 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
#define inf 2000000000
#define limit 10000000
int arr[100005];
vector<pair<pair<int, string>, pair<int, int>>> v;
struct op {
bool operator()(pair<pair<int, string>, pair<int, int>> a,
pair<pair<int, string>, pair<int, int>> b) {
return a.second.seco... | #include <bits/stdc++.h>
using namespace std;
#define inf 2000000000
#define limit 10000000
int arr[100005];
vector<pair<pair<int, string>, pair<int, int>>> v;
struct op {
bool operator()(pair<pair<int, string>, pair<int, int>> a,
pair<pair<int, string>, pair<int, int>> b) {
return a.second.seco... | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 1,018,778 | 1,018,779 | u281899258 | cpp |
p03222 | #include <bits/stdc++.h>
using namespace std;
/* typedef */
typedef long long ll;
typedef pair<int, int> pii;
/* constant */
const int INF = 1 << 30;
const ll LINF = 1LL << 50;
const int NIL = -1;
const int MAX = 10000;
const ll mod = 1000000007;
const double pi = 3.141592653589;
/* global variables */
int H, W, K;
vec... | #include <bits/stdc++.h>
using namespace std;
/* typedef */
typedef long long ll;
typedef pair<int, int> pii;
/* constant */
const int INF = 1 << 30;
const ll LINF = 1LL << 50;
const int NIL = -1;
const int MAX = 10000;
const ll mod = 1000000007;
const double pi = 3.141592653589;
/* global variables */
int H, W, K;
vec... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change",
"misc.off_by_one"
] | 1,018,783 | 1,018,784 | u603234915 | cpp |
p03222 | #include <bits/stdc++.h>
using namespace std;
/* typedef */
typedef long long ll;
typedef pair<int, int> pii;
/* constant */
const int INF = 1 << 30;
const ll LINF = 1LL << 50;
const int NIL = -1;
const int MAX = 10000;
const ll mod = 1000000007;
const double pi = 3.141592653589;
/* global variables */
int H, W, K;
vec... | #include <bits/stdc++.h>
using namespace std;
/* typedef */
typedef long long ll;
typedef pair<int, int> pii;
/* constant */
const int INF = 1 << 30;
const ll LINF = 1LL << 50;
const int NIL = -1;
const int MAX = 10000;
const ll mod = 1000000007;
const double pi = 3.141592653589;
/* global variables */
int H, W, K;
vec... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,018,785 | 1,018,784 | u603234915 | cpp |
p03222 | #include <bits/stdc++.h>
using namespace std;
/* typedef */
typedef long long ll;
typedef pair<int, int> pii;
/* constant */
const int INF = 1 << 30;
const ll LINF = 1LL << 50;
const int NIL = -1;
const int MAX = 10000;
const int mod = 1000000007;
const double pi = 3.141592653589;
/* struct for mod Calculation*/
struct... | #include <bits/stdc++.h>
using namespace std;
/* typedef */
typedef long long ll;
typedef pair<int, int> pii;
/* constant */
const int INF = 1 << 30;
const ll LINF = 1LL << 50;
const int NIL = -1;
const int MAX = 10000;
const int mod = 1000000007;
const double pi = 3.141592653589;
/* struct for mod Calculation*/
struct... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,018,786 | 1,018,787 | u603234915 | cpp |
p03222 | #include <bits/stdc++.h>
using namespace std;
/* typedef */
typedef long long ll;
typedef pair<int, int> pii;
/* constant */
const int INF = 1 << 30;
const ll LINF = 1LL << 50;
const int NIL = -1;
const int MAX = 10000;
const ll mod = 1000000007;
const double pi = 3.141592653589;
/* struct for mod Calculation*/
struct ... | #include <bits/stdc++.h>
using namespace std;
/* typedef */
typedef long long ll;
typedef pair<int, int> pii;
/* constant */
const int INF = 1 << 30;
const ll LINF = 1LL << 50;
const int NIL = -1;
const int MAX = 10000;
const int mod = 1000000007;
const double pi = 3.141592653589;
/* struct for mod Calculation*/
struct... | [
"variable_declaration.type.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,018,788 | 1,018,787 | u603234915 | cpp |
p03222 | #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 = (int)(s); i < (int)(n); i++)
typedef long long ll;
const ll MOD = 1e+9 + 7;
int main() {
int H, W, K, weight;
cin >> H >> W >> K;
vector<vector<ll>> dp(W + 2, vector<ll>(H + 1,... | #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 = (int)(s); i < (int)(n); i++)
typedef long long ll;
const ll MOD = 1e+9 + 7;
int main() {
int H, W, K, weight;
cin >> H >> W >> K;
vector<vector<ll>> dp(W + 2, vector<ll>(H + 1,... | [
"variable_declaration.type.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 1,018,799 | 1,018,800 | u115927976 | cpp |
p03222 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define sz(x) int(x.size())
typedef long long ll;
typedef pair<int, int> P;
const int mod = 1e9 + 7;
int dp[110][10];
int main() {
int h, w, k;
cin >> h >> w >> k;
dp[0][0] = 1;
rep(i, h) {
rep(j, w) {
rep... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define sz(x) int(x.size())
typedef long long ll;
typedef pair<int, int> P;
const int mod = 1e9 + 7;
int dp[110][10];
int main() {
int h, w, k;
cin >> h >> w >> k;
dp[0][0] = 1;
rep(i, h) {
rep(j, w) {
rep... | [
"control_flow.branch.if.condition.change"
] | 1,018,811 | 1,018,812 | u108540384 | cpp |
p03222 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
ll dp[16][9];
// dp[i][j]:上からiの高さまでの1から出発した時の数
ll h, w, k;
bool invalid(ll bit) {
for (ll i = 0; i < w - 1; ++i) {
if ((bit) & (1 << i) && (bit) & (1 << (i + 1))) {
// cout<<bit<<endl;
return true;
}
}
... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
ll dp[101][9];
// dp[i][j]:上からiの高さまでの1から出発した時の数
ll h, w, k;
bool invalid(ll bit) {
for (ll i = 0; i < w - 1; ++i) {
if ((bit) & (1 << i) && (bit) & (1 << (i + 1))) {
// cout<<bit<<endl;
return true;
}
}... | [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 1,018,818 | 1,018,819 | u184929210 | cpp |
p03222 | #include <cassert>
#include <iostream>
#include <vector>
using namespace std;
const int mod = 1000000007;
int main() {
int h, w, k;
cin >> h >> w >> k;
vector<vector<int>> dp(h + 1, vector<int>(w, 0));
dp[0][0] = 1;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
for (int k = 0; k < 1 ... | #include <cassert>
#include <iostream>
#include <vector>
using namespace std;
const int mod = 1000000007;
int main() {
int h, w, k;
cin >> h >> w >> k;
vector<vector<int>> dp(h + 1, vector<int>(w, 0));
dp[0][0] = 1;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
for (int k = 0; k < 1 ... | [
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"io.output.change"
] | 1,018,822 | 1,018,823 | u018713014 | cpp |
p03222 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define ALL(v) v.begin(), v.end()
#define pb push_back
#define eb emplace_back
#define mp make_pair
typedef long long ll;
typed... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define ALL(v) v.begin(), v.end()
#define pb push_back
#define eb emplace_back
#define mp make_pair
typedef long long ll;
typed... | [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 1,018,824 | 1,018,825 | u864667985 | cpp |
p03222 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#includ... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#includ... | [
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove"
] | 1,018,826 | 1,018,827 | u698883164 | cpp |
p03222 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vec... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vec... | [
"call.arguments.change",
"literal.number.change",
"expression.operation.binary.change"
] | 1,018,832 | 1,018,833 | u828388155 | cpp |
p03222 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
int main() {
int h, w, ... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
int main() {
int h, w, ... | [
"call.arguments.change",
"expression.operation.binary.change"
] | 1,018,834 | 1,018,835 | u828388155 | cpp |
p03222 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
int main() {
int h, w, ... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
int main() {
int h, w, ... | [
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 1,018,836 | 1,018,835 | u828388155 | cpp |
p03222 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
int main() {
int h, w, ... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
int main() {
int h, w, ... | [
"call.arguments.change",
"expression.operation.binary.change",
"literal.number.change"
] | 1,018,834 | 1,018,838 | u828388155 | cpp |
p03222 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
const int MOD = 1e9 + 7;
int H, W, K;
vector<int> fib;
ll ans;
void input() { cin >> H >> W >> K; }
int solve(int n) {
if (n < 0)
return 1;
return fib[n];
}
int main() {
input();
fib ... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
const int MOD = 1e9 + 7;
int H, W, K;
vector<int> fib;
ll ans;
void input() { cin >> H >> W >> K; }
int solve(int n) {
if (n < 0)
return 1;
return fib[n];
}
int main() {
input();
fib ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,018,841 | 1,018,842 | u671861352 | cpp |
p03222 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
const int MOD = 1e9 + 7;
int H, W, K;
vector<int> fib;
ll ans;
void input() { cin >> H >> W >> K; }
int solve(int n) {
if (n < 0)
return 1;
return fib[n];
}
int main() {
input();
fib ... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
const int MOD = 1e9 + 7;
int H, W, K;
vector<int> fib;
ll ans;
void input() { cin >> H >> W >> K; }
int solve(int n) {
if (n < 0)
return 1;
return fib[n];
}
int main() {
input();
fib ... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,018,843 | 1,018,842 | u671861352 | cpp |
p03222 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const ll MOD_CONST = 1000000007;
const ll BIG_NUM = 1000000000000000000;
int ... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const ll MOD_CONST = 1000000007;
const ll BIG_NUM = 1000000000000000000;
int ... | [
"call.arguments.change",
"literal.number.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change",
"control_flow.branch.if.replace.add",
"control_flow.branch.else_if.replace.remove",
"expression.operation.binary.remove"
] | 1,018,844 | 1,018,845 | u156778176 | cpp |
p03222 | #include <bits/stdc++.h>
//#include <boost/multiprecision/cpp_int.hpp>
#pragma GCC optimize("O3")
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPP(i, n) for (int i = 1; i <= n; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define EPS (1e-9)
#define INF (1e17)
#define PI (acos(-1))
// const double PI = aco... | #include <bits/stdc++.h>
//#include <boost/multiprecision/cpp_int.hpp>
#pragma GCC optimize("O3")
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPP(i, n) for (int i = 1; i <= n; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define EPS (1e-9)
#define INF (1e17)
#define PI (acos(-1))
// const double PI = aco... | [
"control_flow.loop.for.condition.change"
] | 1,018,851 | 1,018,852 | u222293734 | cpp |
p03222 | #include <algorithm>
#include <bitset>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <math.h>
#include <queue>
#include <string.h>
#include <vector>
using namespace std;
#define INF 11000
#define MOD 1000000007
typedef long long ll;
typedef pair<int, int> P;
ll dp[110][10], mul[10][2], s[10];
int ... | #include <algorithm>
#include <bitset>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <math.h>
#include <queue>
#include <string.h>
#include <vector>
using namespace std;
#define INF 11000
#define MOD 1000000007
typedef long long ll;
typedef pair<int, int> P;
ll dp[110][10], mul[10][2], s[10];
int ... | [
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 1,018,861 | 1,018,862 | u591914971 | cpp |
p03222 | #include <bits/stdc++.h>
#define PI acos(-1)
#define mp make_pair
#define pb push_back
#define all(a) (a).begin(), (a).end()
#define srt(a) sort(all(a))
#define mem(a, h) memset(a, (h), sizeof(a))
#define f first
#define s second
#define MOD 1000000007
#define MOD1 998244353
#define EPS 1e-9
#define fore(i, b, e) for (... | #include <bits/stdc++.h>
#define PI acos(-1)
#define mp make_pair
#define pb push_back
#define all(a) (a).begin(), (a).end()
#define srt(a) sort(all(a))
#define mem(a, h) memset(a, (h), sizeof(a))
#define f first
#define s second
#define MOD 1000000007
#define MOD1 998244353
#define EPS 1e-9
#define fore(i, b, e) for (... | [
"assignment.add"
] | 1,018,869 | 1,018,870 | u736250852 | cpp |
p03222 | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using vvl = vector<vl>;
const int INF = 1 << 28;
const ll MOD = 1'000'000'007;
template <class T> bool chmax(T &a, const T &b) ... | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using vvl = vector<vl>;
const int INF = 1 << 28;
const ll MOD = 1'000'000'007;
template <class T> bool chmax(T &a, const T &b) ... | [
"literal.number.change",
"call.arguments.change"
] | 1,018,881 | 1,018,882 | u756088996 | cpp |
p03222 | #include <bits/stdc++.h>
#define int long long
using namespace std;
const int MOD = pow(10, 9) + 7;
// const int MOD = 998244353;
// const int MOD = ;
int mod(int A, int M) { return (A % M + M) % M; }
const int INF = 1LL << 60;
const string ABC = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const string abc = "abcdefghijklmnopqrstuvw... | #include <bits/stdc++.h>
#define int long long
using namespace std;
const int MOD = pow(10, 9) + 7;
// const int MOD = 998244353;
// const int MOD = ;
int mod(int A, int M) { return (A % M + M) % M; }
const int INF = 1LL << 60;
const string ABC = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const string abc = "abcdefghijklmnopqrstuvw... | [
"literal.number.change",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 1,018,883 | 1,018,884 | u811472478 | cpp |
p03222 | #include <iostream>
using namespace std;
typedef long long ll;
ll mod = 1e9 + 7;
ll dp[10][10];
ll fib[20];
int main() {
ll h, w, k;
cin >> h >> w >> k;
fib[0] = 0, fib[1] = 1;
for (int i = 2; i < 20; i++) {
fib[i] = fib[i - 1] + fib[i - 2];
}
dp[0][1] = 1;
for (int i = 2; i <= w; i++)
dp[0][i]... | #include <iostream>
using namespace std;
typedef long long ll;
ll mod = 1e9 + 7;
ll dp[110][10];
ll fib[20];
int main() {
ll h, w, k;
cin >> h >> w >> k;
fib[0] = 0, fib[1] = 1;
for (int i = 2; i < 20; i++) {
fib[i] = fib[i - 1] + fib[i - 2];
}
dp[0][1] = 1;
for (int i = 2; i <= w; i++)
dp[0][i... | [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 1,018,889 | 1,018,890 | u179970156 | cpp |
p03222 | #include <bits/stdc++.h>
using namespace std;
#define ALL(obj) obj.begin(), obj.end()
#define pb(obj) push_back(obj)
#define REP(i, N) for (ll i = 0; i < N; i++)
const int MOD = 1000000007;
typedef long long ll;
const int MAX = 510000;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = f... | #include <bits/stdc++.h>
using namespace std;
#define ALL(obj) obj.begin(), obj.end()
#define pb(obj) push_back(obj)
#define REP(i, N) for (ll i = 0; i < N; i++)
const int MOD = 1000000007;
typedef long long ll;
const int MAX = 10;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1... | [
"literal.number.change",
"variable_declaration.value.change",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 1,018,895 | 1,018,896 | u892438699 | cpp |
p03222 | #include <bits/stdc++.h>
using namespace std;
#define ALL(obj) obj.begin(), obj.end()
#define pb(obj) push_back(obj)
#define REP(i, N) for (ll i = 0; i < N; i++)
const int MOD = 1000000007;
typedef long long ll;
const int MAX = 510000;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = f... | #include <bits/stdc++.h>
using namespace std;
#define ALL(obj) obj.begin(), obj.end()
#define pb(obj) push_back(obj)
#define REP(i, N) for (ll i = 0; i < N; i++)
const int MOD = 1000000007;
typedef long long ll;
const int MAX = 510000;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = f... | [
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 1,018,895 | 1,018,897 | u892438699 | cpp |
p03222 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
ll gcd(ll a, ll b) {
if (b == 0)... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
ll gcd(ll a, ll b) {
if (b == 0)... | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,018,904 | 1,018,905 | u187878098 | cpp |
p03222 | #include <iostream>
#include <vector>
#define ll long long
using namespace std;
ll combi(int n) {
if (n < 1)
return 1;
if (n == 1)
return 2;
if (n == 2)
return 3;
return combi(n - 1) + combi(n - 2);
}
int main() {
int h, w, k;
cin >> h >> w >> k;
vector<vector<ll>> down;
vector<vector<l... | #include <iostream>
#include <vector>
#define ll long long
using namespace std;
ll combi(int n) {
if (n < 1)
return 1;
if (n == 1)
return 2;
if (n == 2)
return 3;
return combi(n - 1) + combi(n - 2);
}
int main() {
int h, w, k;
cin >> h >> w >> k;
vector<vector<ll>> down;
vector<vector<l... | [
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,018,914 | 1,018,915 | u145078501 | cpp |
p03222 | #include <algorithm>
#include <iomanip>
#include <ios> // std::left, std::right
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#define REP(i, n) for (ll i = 0; i < (ll)n; i++)
#define INF 1000000000000000
using namespace std;
typedef long long ll;
typedef double db;
typedef string ... | #include <algorithm>
#include <iomanip>
#include <ios> // std::left, std::right
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#define REP(i, n) for (ll i = 0; i < (ll)n; i++)
#define INF 1000000000000000
using namespace std;
typedef long long ll;
typedef double db;
typedef string ... | [
"control_flow.branch.if.condition.change"
] | 1,018,916 | 1,018,917 | u824337972 | cpp |
p03222 | #include <algorithm>
#include <iomanip>
#include <ios> // std::left, std::right
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#define REP(i, n) for (ll i = 0; i < (ll)n; i++)
#define INF 1000000000000000
using namespace std;
typedef long long ll;
typedef double db;
typedef string ... | #include <algorithm>
#include <iomanip>
#include <ios> // std::left, std::right
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#define REP(i, n) for (ll i = 0; i < (ll)n; i++)
#define INF 1000000000000000
using namespace std;
typedef long long ll;
typedef double db;
typedef string ... | [
"control_flow.branch.if.condition.change"
] | 1,018,919 | 1,018,917 | u824337972 | cpp |
p03222 | /**
* https://misteer.hatenablog.com/entry/ABC113-D-quick
*/
// {{{ header
#include <bits/stdc++.h>
using namespace std;
using i8 = int8_t;
using u8 = uint8_t;
using i16 = int16_t;
using u16 = uint16_t;
using i32 = int32_t;
using u32 = uint32_t;
using i64 = int64_t;
using u64 = uint64_t;
using i128 = __int128_t;
us... | /**
* https://misteer.hatenablog.com/entry/ABC113-D-quick
*/
// {{{ header
#include <bits/stdc++.h>
using namespace std;
using i8 = int8_t;
using u8 = uint8_t;
using i16 = int16_t;
using u16 = uint16_t;
using i32 = int32_t;
using u32 = uint32_t;
using i64 = int64_t;
using u64 = uint64_t;
using i128 = __int128_t;
us... | [
"assignment.variable.change",
"identifier.change",
"call.arguments.change"
] | 1,018,920 | 1,018,921 | u254456372 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.