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 <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define whole(f, x, ...) \
([&](decltype((x)) whole) { \
return (f)(begin(whole), end(w... | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define whole(f, x, ...) \
([&](decltype((x)) whole) { \
return (f)(begin(whole), end(w... | [
"expression.operation.binary.add"
] | 1,017,881 | 1,017,882 | u369212307 | cpp |
p03221 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> P(n + 1);
vector<int> Y(n + 1);
vector<vector<int>> YS(n + 1);
for (int i = 0; i < m; i++) {
cin >> P[i] >> Y[i];
YS[P[i]].push_back(Y[i]);
}
for ... | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> P(m);
vector<int> Y(m);
vector<vector<int>> YS(n + 1);
for (int i = 0; i < m; i++) {
cin >> P[i] >> Y[i];
YS[P[i]].push_back(Y[i]);
}
for (int i =... | [
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 1,017,883 | 1,017,884 | u033627628 | cpp |
p03221 | #include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef int itn;
const ll LINF = 1e18;
const int... | #include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef int itn;
const ll LINF = 1e18;
const int... | [
"control_flow.branch.if.condition.change"
] | 1,017,887 | 1,017,888 | u776194115 | cpp |
p03221 | #include <bits/stdc++.h>
int main() {
int n, m;
std::cin >> n >> m;
std::vector<std::vector<int>> c(n + 1);
std::vector<std::pair<int, int>> o;
for (int i = 0; i < m; i++) {
int p, y;
std::cin >> p >> y;
o.emplace_back(p, y);
c[p].push_back(y);
}
for (int i = 0; i < n; i++) {
std::so... | #include <bits/stdc++.h>
int main() {
int n, m;
std::cin >> n >> m;
std::vector<std::vector<int>> c(n + 1);
std::vector<std::pair<int, int>> o;
for (int i = 0; i < m; i++) {
int p, y;
std::cin >> p >> y;
o.emplace_back(p, y);
c[p].push_back(y);
}
for (int i = 0; i < n + 1; i++) {
std... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 1,017,893 | 1,017,894 | u274139177 | cpp |
p03221 | #include <bits/stdc++.h>
using ll = long long;
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> p(n), y(n);
for (int i = 0; i < m; i++)
cin >> p[i] >> y[i];
vector<vector<int>> cor(n + 1); // cor[p[i]] = 県p[i]に属する市の誕生年の配列
for (int i = 0; i < m; i++)
cor[p[i]].push_back(y[i]);... | #include <bits/stdc++.h>
using ll = long long;
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> p(m), y(m);
for (int i = 0; i < m; i++)
cin >> p[i] >> y[i];
vector<vector<int>> cor(n + 1); // cor[p[i]] = 県p[i]に属する市の誕生年の配列
for (int i = 0; i < m; i++)
cor[p[i]].push_back(y[i]);... | [] | 1,017,909 | 1,017,910 | u394759653 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define repp(i, m, n) for (int(i) = (m); (i) < (n); (i)++)
#define repm(i, n) for (int(i) = (n); (i) >= 0; (i)--)
typedef long long lint;
int main() {
int N, M;
cin >> N >> M;
tuple<int, int, int, int> s[M];
rep(... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define repp(i, m, n) for (int(i) = (m); (i) < (n); (i)++)
#define repm(i, n) for (int(i) = (n); (i) >= 0; (i)--)
typedef long long lint;
int main() {
int N, M;
cin >> N >> M;
tuple<int, int, int, int> s[M];
rep(... | [
"expression.unary.arithmetic.add"
] | 1,017,926 | 1,017,927 | u768204022 | cpp |
p03221 | #include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define _LIBCPP_DEBUG 0
using namespace std;
#define ll long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define MOD (1000000007)
#define vi vector<int>
#define vvi vector<vi>
#define all(a) (a).begin(), (a).end()
template <class T> inline bool chmax(T &a, T b) {... | #include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define _LIBCPP_DEBUG 0
using namespace std;
#define ll long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define MOD (1000000007)
#define vi vector<int>
#define vvi vector<vi>
#define all(a) (a).begin(), (a).end()
template <class T> inline bool chmax(T &a, T b) {... | [
"call.arguments.change"
] | 1,017,929 | 1,017,930 | u354567428 | cpp |
p03221 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<tuple<int, int, int>> t(m);
rep(i, m) {
int p, y;
cin >> p >> y;
t[i] = make_tuple(p, y, i);
}
sort(t.begin(), t.end());
vector<tupl... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<tuple<int, int, int>> t(m);
rep(i, m) {
int p, y;
cin >> p >> y;
t[i] = make_tuple(p, y, i);
}
sort(t.begin(), t.end());
vector<tupl... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 1,017,933 | 1,017,934 | u374190629 | cpp |
p03221 | #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 reps(i, s, e) for (int i = s; i < e; i++)
#define inf 1e10
#define vsort(v) sort(v.begin(), v.end())
#define vsortr(v) sort(v.begin(), v.end(), greater<ll>())
#define sz(x) x.size()
#define cei... | #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 reps(i, s, e) for (int i = s; i < e; i++)
#define inf 1e10
#define vsort(v) sort(v.begin(), v.end())
#define vsortr(v) sort(v.begin(), v.end(), greater<ll>())
#define sz(x) x.size()
#define cei... | [
"expression.operation.binary.add"
] | 1,017,935 | 1,017,936 | u026620445 | cpp |
p03221 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
// ceil(a/b) (a + (b - 1))/ b
using namespace std;
#d... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
// ceil(a/b) (a + (b - 1))/ b
using namespace std;
#d... | [
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,017,940 | 1,017,941 | u950174376 | cpp |
p03221 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
// ceil(a/b) (a + (b - 1))/ b
using namespace std;
#d... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
// ceil(a/b) (a + (b - 1))/ b
using namespace std;
#d... | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,017,942 | 1,017,941 | u950174376 | cpp |
p03221 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef pair<P, int> PP;
int main() {
int N, M;
cin >> N >> M;
vector<PP> C(M);
for (int i = 0; i < M; i++) {
int p, y;
cin >> p >> y;
C[i] = PP(P(p, y), i);
}
sort(C.begin(), C.end());
... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef pair<P, int> PP;
int main() {
int N, M;
cin >> N >> M;
vector<PP> C(M);
for (int i = 0; i < M; i++) {
int p, y;
cin >> p >> y;
C[i] = PP(P(p, y), i);
}
sort(C.begin(), C.end());
... | [] | 1,017,954 | 1,017,955 | u188117876 | cpp |
p03221 | #include <bits/stdc++.h>
#include <iomanip> // std::setw(int), std::setfill(char)
#include <ios> // std::left, std::right
#include <stdio.h>
using namespace std;
#define inputInt(a) \
int a; ... | #include <bits/stdc++.h>
#include <iomanip> // std::setw(int), std::setfill(char)
#include <ios> // std::left, std::right
#include <stdio.h>
using namespace std;
#define inputInt(a) \
int a; ... | [
"misc.opposites",
"expression.operator.compare.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 1,017,966 | 1,017,967 | u135358384 | cpp |
p03221 | #include <algorithm>
#include <array>
#include <cmath>
#include <complex>
#include <cstring>
#include <deque>
#include <forward_list>
#include <fstream>
#include <iomanip>
#include <ios>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <st... | #include <algorithm>
#include <array>
#include <cmath>
#include <complex>
#include <cstring>
#include <deque>
#include <forward_list>
#include <fstream>
#include <iomanip>
#include <ios>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <st... | [] | 1,017,970 | 1,017,971 | u169580012 | cpp |
p03221 | #include <algorithm>
#include <array>
#include <cmath>
#include <complex>
#include <cstring>
#include <deque>
#include <forward_list>
#include <fstream>
#include <iomanip>
#include <ios>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <st... | #include <algorithm>
#include <array>
#include <cmath>
#include <complex>
#include <cstring>
#include <deque>
#include <forward_list>
#include <fstream>
#include <iomanip>
#include <ios>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <st... | [] | 1,017,972 | 1,017,971 | u169580012 | cpp |
p03221 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, n) for (int i = (int)(n); i >= 0; i--)
#define repm(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define repmr(i, m, n) for (int i = (int)(n); i >= (int)(m); i--)
#define all(x) (x).begin(), (x).end()
#define inf 2e9
#d... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, n) for (int i = (int)(n); i >= 0; i--)
#define repm(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define repmr(i, m, n) for (int i = (int)(n); i >= (int)(m); i--)
#define all(x) (x).begin(), (x).end()
#define inf 2e9
#d... | [
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 1,017,973 | 1,017,974 | u917101497 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;... | #include <algorithm>
#include <cmath>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;... | [] | 1,017,980 | 1,017,981 | u848433916 | cpp |
p03221 | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
ll a7 = 1000000007;
ll inf = 100000000000000000;
ll min(ll a, ll b) {
if (a < b)
return a;
return b;
}
ll max(ll a, ll b) {
if (a > b)
return a;
return b;
}
int main() {
ll n, m;
cin >> n >> m;
ll p[m], y[m];
vector<vector<pai... | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
ll a7 = 1000000007;
ll inf = 100000000000000000;
ll min(ll a, ll b) {
if (a < b)
return a;
return b;
}
ll max(ll a, ll b) {
if (a > b)
return a;
return b;
}
int main() {
ll n, m;
cin >> n >> m;
ll p[m], y[m];
vector<vector<pai... | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 1,017,994 | 1,017,995 | u541784678 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<tuple<int, int, int>> vec(M);
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
vec.at(i) = make_tuple(a, b, i);
}
sort(vec.begin(), vec.end());
int num = 0;
int x = get<0>(vec.at(0));
vector... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<tuple<int, int, int>> vec(M);
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
vec.at(i) = make_tuple(a, b, i);
}
sort(vec.begin(), vec.end());
int num = 0;
int x = get<0>(vec.at(0));
vector... | [
"literal.number.change",
"io.output.change"
] | 1,017,996 | 1,017,997 | u835534008 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
const auto MOD = 1000000007;
const int INF = 1e9;
const long long LINF = 1e18;
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef pair<int,... | #include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
const auto MOD = 1000000007;
const int INF = 1e9;
const long long LINF = 1e18;
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef pair<int,... | [
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,018,002 | 1,018,003 | u587724217 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define MM = 1000000000;
#define mod = MM + 7;
#define INF (ll)1e18
#define pi acos(-1.0)
#define MAX 100005
#define NIL -1
#define rep(i, n) for (int i = 0; i < n; i++)
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
int main() {
int n, m;
i... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define MM = 1000000000;
#define mod = MM + 7;
#define INF (ll)1e18
#define pi acos(-1.0)
#define MAX 100005
#define NIL -1
#define rep(i, n) for (int i = 0; i < n; i++)
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
int main() {
int n, m;
i... | [
"identifier.replace.remove",
"literal.replace.add",
"variable_declaration.array_dimensions.change"
] | 1,018,004 | 1,018,005 | u342051078 | cpp |
p03221 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
ll N, M;
cin >> N >> M;
vector<ll> P(M, 0);
vector<ll> Y(M, 0);
vector<vector<ll>> to(N);
for (ll i = 0; i < M; i++) {
cin >> P[i] >> Y[i];
}
f... | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
ll N, M;
cin >> N >> M;
vector<ll> P(M, 0);
vector<ll> Y(M, 0);
vector<vector<ll>> to(N + 1);
for (ll i = 0; i < M; i++) {
cin >> P[i] >> Y[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,008 | 1,018,009 | u904123392 | cpp |
p03221 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
ll N, M;
cin >> N >> M;
vector<ll> P(M, 0);
vector<ll> Y(M, 0);
vector<vector<ll>> to(N);
for (ll i = 0; i < M; i++) {
cin >> P[i] >> Y[i];
}
f... | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
ll N, M;
cin >> N >> M;
vector<ll> P(M, 0);
vector<ll> Y(M, 0);
vector<vector<ll>> to(N + 1);
for (ll i = 0; i < M; i++) {
cin >> P[i] >> Y[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",
"identifier.change"
] | 1,018,010 | 1,018,009 | u904123392 | cpp |
p03221 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> P(M);
vector<int> Y(M);
for (int i = 0; i < N; i++) {
cin >> P[i] >> Y[i];
P[i]--;
}
vector<vector<int>> val(N);
for (int i = ... | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> P(M);
vector<int> Y(M);
for (int i = 0; i < M; i++) {
cin >> P[i] >> Y[i];
P[i]--;
}
vector<vector<int>> val(N);
for (int i = ... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,018,011 | 1,018,012 | u904123392 | cpp |
p03221 | #include <bits/stdc++.h>
#define rep(i, a) for (int i = 0; i < int(a); ++i)
#define REP(i, a, b) for (int i = int(a); i < int(b); ++i)
#define pb push_back
#define mp make_pair
#define F first
#define S second
using ll = long long;
using itn = int;
using namespace std;
using Graph = vector<vector<int>>;
int GCD(int a, ... | #include <bits/stdc++.h>
#define rep(i, a) for (int i = 0; i < int(a); ++i)
#define REP(i, a, b) for (int i = int(a); i < int(b); ++i)
#define pb push_back
#define mp make_pair
#define F first
#define S second
using ll = long long;
using itn = int;
using namespace std;
using Graph = vector<vector<int>>;
int GCD(int a, ... | [
"expression.operation.binary.add"
] | 1,018,042 | 1,018,043 | u089885969 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using ll = long long;
using itn = int;
using namespace std;
int GCD(... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using ll = long long;
using itn = int;
using namespace std;
int GCD(... | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,018,044 | 1,018,045 | u089885969 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using ll = long long;
using itn = int;
using namespace std;
int GCD(... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using ll = long long;
using itn = int;
using namespace std;
int GCD(... | [
"identifier.replace.remove",
"literal.replace.add",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,018,046 | 1,018,045 | u089885969 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using ll = long long;
using itn = int;
using namespace std;
int GCD(... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using ll = long long;
using itn = int;
using namespace std;
int GCD(... | [
"identifier.replace.remove",
"literal.replace.add",
"variable_declaration.array_dimensions.change",
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,018,047 | 1,018,045 | u089885969 | cpp |
p03221 | #include <algorithm>
#include <chrono>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#i... | #include <algorithm>
#include <chrono>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#i... | [
"literal.number.change",
"io.output.change"
] | 1,018,061 | 1,018,062 | u376103660 | cpp |
p03221 | #include <algorithm>
#include <iostream>
#include <limits.h>
#include <queue>
#include <string>
#include <vector>
using namespace std;
#define rip(i, n) (int i = 0; i < (int)(n); i++)
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<pair<int, pair<int, int>>> da(m);
vector<int> p(m), y(m);
for
r... | #include <algorithm>
#include <iostream>
#include <limits.h>
#include <queue>
#include <string>
#include <vector>
using namespace std;
#define rip(i, n) (int i = 0; i < (int)(n); i++)
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<pair<int, pair<int, int>>> da(m);
vector<int> p(m), y(m);
for
r... | [
"expression.operation.unary.reference.add"
] | 1,018,069 | 1,018,070 | u057079894 | cpp |
p03221 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int N, M;
cin >> N >> M;
vector<int> P(M, 0), Y(M, 0);
vector<int> d[N + 1];
for (int i = 0; i < M; i++) {
cin >> P[i] >> Y[i];
d[P[i]].push_back(Y[i]);
}
for (i... | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int N, M;
cin >> N >> M;
vector<int> P(M, 0), Y(M, 0);
vector<int> d[N + 1];
for (int i = 0; i < M; i++) {
cin >> P[i] >> Y[i];
d[P[i]].push_back(Y[i]);
}
for (i... | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 1,018,071 | 1,018,072 | u547844563 | cpp |
p03221 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int N, M;
int P[100000], Y[100000];
vector<int> yd[100001];
cin >> N >> M;
for (int i = 0; i < M; i++) {
cin >> P[i] >> Y[i];
yd[P[i]].push_back(Y[i]);
}
for (in... | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int N, M;
int P[100000], Y[100000];
vector<int> yd[100001];
cin >> N >> M;
for (int i = 0; i < M; i++) {
cin >> P[i] >> Y[i];
yd[P[i]].push_back(Y[i]);
}
for (in... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,018,073 | 1,018,074 | u547844563 | cpp |
p03221 | #include <algorithm>
#include <bitset>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define repr(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) repr(i, 0, n)
#define INF 2e9
#define ... | #include <algorithm>
#include <bitset>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define repr(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) repr(i, 0, n)
#define INF 2e9
#define ... | [
"call.arguments.add"
] | 1,018,075 | 1,018,076 | u314008046 | cpp |
p03221 | #include <algorithm>
#include <bitset>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define repr(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) repr(i, 0, n)
#define INF 2e9
#define ... | #include <algorithm>
#include <bitset>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define repr(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) repr(i, 0, n)
#define INF 2e9
#define ... | [
"expression.operation.binary.add"
] | 1,018,077 | 1,018,076 | u314008046 | cpp |
p03221 | #include <algorithm>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#define rep(i, N) for (int i = 0; i < N, i++)
using namespace std;
typedef long long llong;
typedef unsigned long long ullong;
llong gcd(llong a, llong b) {
... | #include <algorithm>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#define rep(i, N) for (int i = 0; i < N, i++)
using namespace std;
typedef long long llong;
typedef unsigned long long ullong;
llong gcd(llong a, llong b) {
... | [
"expression.unary.arithmetic.add"
] | 1,018,089 | 1,018,090 | u740232619 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
int main() {
long n, m;
cin >> n >> m;
vector<long> p(m), y(m), count(n), id(m);
for (int i = 0; i < m; i++) {
cin >> p.at(i) >> y.at(i);
y.at(i) = 100000 * y.at(i) + i;
}
sort(y.begin(), y.end());
for (int i = 0; i < m; i++) {
long order = y.at(i... | #include <bits/stdc++.h>
using namespace std;
int main() {
long n, m;
cin >> n >> m;
vector<long> p(m), y(m), count(n + 1), id(m);
for (int i = 0; i < m; i++) {
cin >> p.at(i) >> y.at(i);
y.at(i) = 100000 * y.at(i) + i;
}
sort(y.begin(), y.end());
for (int i = 0; i < m; i++) {
long order = y.... | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 1,018,093 | 1,018,094 | u697658632 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
int main() {
long n, m;
cin >> n >> m;
vector<long> p(m), y(m), count(m), id(m);
for (int i = 0; i < m; i++) {
cin >> p.at(i) >> y.at(i);
y.at(i) = 100000 * y.at(i) + i;
}
sort(y.begin(), y.end());
for (int i = 0; i < m; i++) {
long order = y.at(i... | #include <bits/stdc++.h>
using namespace std;
int main() {
long n, m;
cin >> n >> m;
vector<long> p(m), y(m), count(n + 1), id(m);
for (int i = 0; i < m; i++) {
cin >> p.at(i) >> y.at(i);
y.at(i) = 100000 * y.at(i) + i;
}
sort(y.begin(), y.end());
for (int i = 0; i < m; i++) {
long order = y.... | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 1,018,095 | 1,018,094 | u697658632 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
int main() {
long n, m;
cin >> n >> m;
vector<long> p(m), y(m), count(m), id(m);
for (int i = 0; i < m; i++) {
cin >> p.at(i) >> y.at(i);
y.at(i) = 100000 * y.at(i) + i;
}
sort(y.begin(), y.end());
for (int i = 0; i < m; i++) {
long order = y.at(i... | #include <bits/stdc++.h>
using namespace std;
int main() {
long n, m;
cin >> n >> m;
vector<long> p(m), y(m), count(n + 1), id(m);
for (int i = 0; i < m; i++) {
cin >> p.at(i) >> y.at(i);
y.at(i) = 100000 * y.at(i) + i;
}
sort(y.begin(), y.end());
for (int i = 0; i < m; i++) {
long order = y.... | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 1,018,096 | 1,018,094 | u697658632 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
#define ONLINE_JUDGE
#define pb(a) push_back(a)
#define all(a) (a.begin(), a.end())
using ll = long long;
const int E5 = 1e5;
//////////// Solution /////////////////////////////////
int n, m;
void solve() {
scanf("%d %d", &n, &m);
map<int, char *> id;
map<int, v... | #include <bits/stdc++.h>
using namespace std;
#define ONLINE_JUDGE
#define pb(a) push_back(a)
#define all(a) (a.begin(), a.end())
using ll = long long;
const int E5 = 1e5;
//////////// Solution /////////////////////////////////
int n, m;
void solve() {
scanf("%d %d", &n, &m);
map<int, char *> id;
map<int, v... | [] | 1,018,097 | 1,018,098 | u361383723 | cpp |
p03221 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep1(i, n) for (int i = 1; i <= (n); ++i)
#define repi(i, a, b) for (int i = a; i <= (b); ++i)
#define rrep(i, n) for (int i = (n - 1); i >= 0; --i)
#define ALL(obj) (obj).begin(), (obj).end()
#define RALL(obj) (obj).rbegin(), (obj).rend()... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep1(i, n) for (int i = 1; i <= (n); ++i)
#define repi(i, a, b) for (int i = a; i <= (b); ++i)
#define rrep(i, n) for (int i = (n - 1); i >= 0; --i)
#define ALL(obj) (obj).begin(), (obj).end()
#define RALL(obj) (obj).rbegin(), (obj).rend()... | [
"assignment.change"
] | 1,018,111 | 1,018,112 | u281168735 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <map>
#include <numeric>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef long long ll;
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<ll> p(m), y(m);
vector<vector<ll>> v(n + 1);
... | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <map>
#include <numeric>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef long long ll;
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<ll> p(m), y(m);
vector<vector<ll>> v(n + 1);
... | [
"expression.operation.binary.add"
] | 1,018,113 | 1,018,114 | u130834452 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <map>
#include <numeric>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef long long ll;
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> p(m), y(m);
vector<vector<int>> v(n + 1)... | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <map>
#include <numeric>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef long long ll;
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<ll> p(m), y(m);
vector<vector<ll>> v(n + 1);
... | [
"expression.operation.binary.add"
] | 1,018,115 | 1,018,114 | u130834452 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef string str;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef map<str, int> mapsi;
typedef map<str, int>::iterator mapsitr;
typedef ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef string str;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef map<str, int> mapsi;
typedef map<str, int>::iterator mapsitr;
typedef ... | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,018,126 | 1,018,127 | u337775536 | cpp |
p03221 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
int p[m], y[m];
vector<int> yd[n + 1];
for (int i = 0; i < m; i++) {
cin >> p[i] >> y[i];
yd[p[i]].push_back(y[i]);
}
for... | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
int p[m], y[m];
vector<int> yd[n + 1];
for (int i = 0; i < m; i++) {
cin >> p[i] >> y[i];
yd[p[i]].push_back(y[i]);
}
for... | [
"expression.operation.binary.add"
] | 1,018,128 | 1,018,129 | u639032323 | cpp |
p03221 | #define _USE_MA_DEFINES
#include <bits/stdc++.h>
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define Rep(i, a, b) for (int i = a; i < b; i++)
#define REP(i, a, b) for (int i = a; i <= b; i++)
#define rev(i, n) for (int i = n - 1; i >= 0; i--)
#define vi vector<int>
#define vvi vector<vi>
#define... | #define _USE_MA_DEFINES
#include <bits/stdc++.h>
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define Rep(i, a, b) for (int i = a; i < b; i++)
#define REP(i, a, b) for (int i = a; i <= b; i++)
#define rev(i, n) for (int i = n - 1; i >= 0; i--)
#define vi vector<int>
#define vvi vector<vi>
#define... | [
"expression.operation.binary.add"
] | 1,018,134 | 1,018,135 | u128527648 | cpp |
p03221 | #define _USE_MA_DEFINES
#include <bits/stdc++.h>
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define Rep(i, a, b) for (int i = a; i < b; i++)
#define REP(i, a, b) for (int i = a; i <= b; i++)
#define rev(i, n) for (int i = n - 1; i >= 0; i--)
#define vi vector<int>
#define vvi vector<vi>
#define... | #define _USE_MA_DEFINES
#include <bits/stdc++.h>
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define Rep(i, a, b) for (int i = a; i < b; i++)
#define REP(i, a, b) for (int i = a; i <= b; i++)
#define rev(i, n) for (int i = n - 1; i >= 0; i--)
#define vi vector<int>
#define vvi vector<vi>
#define... | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 1,018,136 | 1,018,135 | u128527648 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
int main(int argc, const char *argv[]) {
int n, m;
cin >> n >> m;
vector<int> p(m), y(m);
vector<vector<int>> v(n);
v... | #include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
int main(int argc, const char *argv[]) {
int n, m;
cin >> n >> m;
vector<int> p(m), y(m);
vector<vector<int>> v(n);
v... | [
"assignment.change"
] | 1,018,139 | 1,018,140 | u769062455 | cpp |
p03221 | #include <algorithm>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <math.h>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const ll InF = 1e15;
int main() {
int N, M;
cin >> N >> M;
vector<pair<int, ll>> org... | #include <algorithm>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <math.h>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const ll InF = 1e15;
int main() {
int N, M;
cin >> N >> M;
vector<pair<int, ll>> org... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"control_flow.loop.for.condition.change"
] | 1,018,144 | 1,018,145 | u258183816 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N, M;
cin >> N >> M;
vector<int> P(N), Y(N);
vector<vector<int>> memo(N);
for (int i = 0; i < M; i++) {
cin >> P[i] >> Y[i];
P[i]--;
memo[P[i]].push_back(Y[i]);
}
for (int i = 0; i < N; i++)
sort(memo[i].b... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N, M;
cin >> N >> M;
vector<int> P(M), Y(M);
vector<vector<int>> memo(N);
for (int i = 0; i < M; i++) {
cin >> P[i] >> Y[i];
P[i]--;
memo[P[i]].push_back(Y[i]);
}
for (int i = 0; i < N; i++)
sort(memo[i].b... | [] | 1,018,146 | 1,018,147 | u083190434 | cpp |
p03221 | #include <algorithm>
#include <bitset>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define REP(i, b,... | #include <algorithm>
#include <bitset>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define REP(i, b,... | [
"expression.operation.binary.add"
] | 1,018,150 | 1,018,149 | u375619974 | cpp |
p03221 | #include <algorithm>
#include <bitset>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define REP(i, b,... | #include <algorithm>
#include <bitset>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define REP(i, b,... | [
"expression.operation.binary.add"
] | 1,018,151 | 1,018,149 | u375619974 | cpp |
p03221 | #define FOR(i, begin, end) for (int i = (begin); i < (end); i++)
#define REP(i, n) FOR(i, 0, n)
#define SORT(a) sort(a.begin(), a.end())
#define SORTD(a) sort(a.rbegin(), a.rend());
#define ll long long
#define INF 1000000000000000000
#define INT_MAX 2147483647
#include <algorithm>
#include <cmath>
#include <iomanip>
... | #define FOR(i, begin, end) for (int i = (begin); i < (end); i++)
#define REP(i, n) FOR(i, 0, n)
#define SORT(a) sort(a.begin(), a.end())
#define SORTD(a) sort(a.rbegin(), a.rend());
#define ll long long
#define INF 1000000000000000000
#define INT_MAX 2147483647
#include <algorithm>
#include <cmath>
#include <iomanip>
... | [
"expression.operation.binary.add"
] | 1,018,164 | 1,018,163 | u489197691 | cpp |
p03221 | #define FOR(i, begin, end) for (int i = (begin); i < (end); i++)
#define REP(i, n) FOR(i, 0, n)
#define SORT(a) sort(a.begin(), a.end())
#define SORTD(a) sort(a.rbegin(), a.rend());
#define ll long long
#define INF 1000000000000000000
#define INT_MAX 2147483647
#include <algorithm>
#include <cmath>
#include <iomanip>
... | #define FOR(i, begin, end) for (int i = (begin); i < (end); i++)
#define REP(i, n) FOR(i, 0, n)
#define SORT(a) sort(a.begin(), a.end())
#define SORTD(a) sort(a.rbegin(), a.rend());
#define ll long long
#define INF 1000000000000000000
#define INT_MAX 2147483647
#include <algorithm>
#include <cmath>
#include <iomanip>
... | [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 1,018,165 | 1,018,163 | u489197691 | cpp |
p03221 | #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int MOD = 1000000007;
int main() {
long long N, M;
cin >> N >> M;
vector<long long> P(M + 10), Y(M + 10);
vector<vector<long long>> d(M + 10);
for (long long i = 0; i < M; i++) {
ci... | #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int MOD = 1000000007;
int main() {
long long N, M;
cin >> N >> M;
vector<long long> P(M + 10), Y(M + 10);
vector<vector<long long>> d(N + 10);
for (long long i = 0; i < M; i++) {
ci... | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,018,172 | 1,018,173 | u500026208 | cpp |
p03221 | #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int MOD = 1000000007;
int main() {
long long N, M;
cin >> N >> M;
vector<long long> P(M + 10), Y(M + 10);
vector<vector<long long>> d(M + 10);
for (long long i = 0; i < M; i++) {
ci... | #include <algorithm>
#include <bits/stdc++.h>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int MOD = 1000000007;
int main() {
long long N, M;
cin >> N >> M;
vector<long long> P(M + 10), Y(M + 10);
vector<vector<long long>> d(N + 10);
for (long long i = 0; i ... | [
"import.add",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,018,172 | 1,018,175 | u500026208 | cpp |
p03221 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <tuple>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
tuple<int, int, int> tmp[m];
for (int i = 0; i < m; i++) {
int p, y;
cin >> p >> y;
tmp[i] = make_tuple(y, p, i);
}
sort(tmp, ... | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <tuple>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
tuple<int, int, int> tmp[m];
for (int i = 0; i < m; i++) {
int p, y;
cin >> p >> y;
tmp[i] = make_tuple(y, p, i);
}
sort(tmp, ... | [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 1,018,176 | 1,018,177 | u660341491 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// typedef pair<int,int> P;
// priority_queue<int> pque;
// priority_queue<int, vector<int>, greater<int>> pque;
ll INFL = 1000000000000000010; // 10^18 = 2^60
int INF = 2000000000; // 10^9
ll MOD = 1000000007;
int main(void) {
int N, M;
c... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// typedef pair<int,int> P;
// priority_queue<int> pque;
// priority_queue<int, vector<int>, greater<int>> pque;
ll INFL = 1000000000000000010; // 10^18 = 2^60
int INF = 2000000000; // 10^9
ll MOD = 1000000007;
int main(void) {
int N, M;
c... | [
"expression.operation.binary.add"
] | 1,018,192 | 1,018,193 | u633284019 | cpp |
p03221 | #include <bits/stdc++.h>
#define cinf(n, x, y) \
for (int i = 0; i < (n); i++) \
cin >> x[i] >> y[i];
typedef long long int ll;
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> p(m)... | #include <bits/stdc++.h>
#define cinf(n, x, y) \
for (int i = 0; i < (n); i++) \
cin >> x[i] >> y[i];
typedef long long int ll;
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> p(m)... | [
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,018,200 | 1,018,201 | u928536113 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
#define cc(x) cout << (x) << endl
#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 all(x) (x).begin(), (x).end()
typedef long long ll;
typedef vector<long long> vll;
template <typename T, typename U> in... | #include <bits/stdc++.h>
using namespace std;
#define cc(x) cout << (x) << endl
#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 all(x) (x).begin(), (x).end()
typedef long long ll;
typedef vector<long long> vll;
template <typename T, typename U> in... | [
"io.output.change",
"expression.operation.binary.remove"
] | 1,018,206 | 1,018,205 | u654470292 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
// 変数ダンプ先。coutかcerr
#define DUMPOUT cerr
// 提出時はコメントアウト
#define DEBUG_
// #define int long long // intで書いたけど心配なときにlong longに変換する
struct Fast {
Fast() {
std::cin.tie(0);
ios::sync_with_stdio(false);
}
} fast;
/* cpp template {{{ */
/* short */
#define pb pus... | #include <bits/stdc++.h>
using namespace std;
// 変数ダンプ先。coutかcerr
#define DUMPOUT cerr
// 提出時はコメントアウト
#define DEBUG_
// #define int long long // intで書いたけど心配なときにlong longに変換する
struct Fast {
Fast() {
std::cin.tie(0);
ios::sync_with_stdio(false);
}
} fast;
/* cpp template {{{ */
/* short */
#define pb pus... | [
"literal.number.change",
"io.output.change"
] | 1,018,207 | 1,018,208 | u545411641 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define fi first
#define se second
int out(int x) {
int count = 5, y = x;
while (x / 10 != 0) {
count--;
x /= 10;
}
for (int i = 0; i < count; i++) {
cout << '0';
}
cout << y;
}
int main() {
int n, m;
cin >> n >> m;
map<... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define fi first
#define se second
void out(int x) {
int count = 5, y = x;
while (x / 10 != 0) {
count--;
x /= 10;
}
for (int i = 0; i < count; i++) {
cout << '0';
}
cout << y;
}
int main() {
int n, m;
cin >> n >> m;
ma... | [
"function.return_type.change",
"call.arguments.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,018,217 | 1,018,218 | u317711717 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> P(M), Y(M);
vector<vector<int>> yd(N + 1, vector<int>());
for (int i = 0; i < M; ++i) {
cin >> P[i] >> Y[i];
yd[P[i]].push_back(Y[i]);
}
for (int i = 0; i < N; ++i) {
sort(yd[i].begin(), yd[i].en... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> P(M), Y(M);
vector<vector<int>> yd(N + 1, vector<int>());
for (int i = 0; i < M; ++i) {
cin >> P[i] >> Y[i];
yd[P[i]].push_back(Y[i]);
}
for (int i = 0; i <= N; ++i) {
sort(yd[i].begin(), yd[i].e... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,018,225 | 1,018,226 | u318727472 | cpp |
p03221 | #include <algorithm>
#include <cstdio>
#include <map>
#include <vector>
using namespace std;
int main() {
int n, m, p, y;
scanf("%d%d", &n, &m);
vector<vector<int>> c(n + 1);
vector<pair<int, int>> d(m);
for (int i = 0; i < m; ++i) {
scanf("%d%d", &p, &y);
c.at(p).push_back(y);
d.at(i) = {p, y};... | #include <algorithm>
#include <cstdio>
#include <map>
#include <vector>
using namespace std;
int main() {
int n, m, p, y;
scanf("%d%d", &n, &m);
vector<vector<int>> c(n + 1);
vector<pair<int, int>> d(m);
for (int i = 0; i < m; ++i) {
scanf("%d%d", &p, &y);
c.at(p).push_back(y);
d.at(i) = {p, y};... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,018,240 | 1,018,241 | u359025499 | cpp |
p03221 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string.h>
#include <vector>
typedef long long ll;
using namespace std;
ll Mod = 1e9 + 7;
int main() {
int N, M;
vector<int> tmp[N + 1];
int P[100000], Y[100000];
cin >> N >> M;
for (int i = 0; i < M; i++) {
cin >> P[i] >> Y[i];
tmp... | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string.h>
#include <vector>
typedef long long ll;
using namespace std;
ll Mod = 1e9 + 7;
int main() {
int N, M;
vector<int> tmp[100001];
int P[100000], Y[100000];
cin >> N >> M;
for (int i = 0; i < M; i++) {
cin >> P[i] >> Y[i];
tm... | [
"identifier.replace.remove",
"literal.replace.add",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 1,018,263 | 1,018,264 | u831873811 | cpp |
p03221 | #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
using namespace std;
#define sz(x) ((int)(x).size())
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define MEMSET(v, h) memset((v),... | #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
using namespace std;
#define sz(x) ((int)(x).size())
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define MEMSET(v, h) memset((v),... | [] | 1,018,290 | 1,018,291 | u135572611 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <list>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int N, M;
vector<int> P(100001), Y(100001);
vector<int> year[100001];
ci... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <list>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int N, M;
vector<int> P(100001), Y(100001);
vector<int> year[100001];
ci... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,018,296 | 1,018,297 | u034055199 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define eprintf(...) 42
#endif
#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 all(x) (x).begin(), (x).end()
#define foreach(u... | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define eprintf(...) 42
#endif
#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 all(x) (x).begin(), (x).end()
#define foreach(u... | [
"expression.operation.binary.add"
] | 1,018,302 | 1,018,303 | u057866967 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define eprintf(...) 42
#endif
#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 all(x) (x).begin(), (x).end()
#define foreach(u... | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define eprintf(...) 42
#endif
#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 all(x) (x).begin(), (x).end()
#define foreach(u... | [
"expression.operation.binary.add"
] | 1,018,304 | 1,018,303 | u057866967 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define eprintf(...) 42
#endif
#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 all(x) (x).begin(), (x).end()
#define foreach(u... | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define eprintf(...) 42
#endif
#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 all(x) (x).begin(), (x).end()
#define foreach(u... | [
"expression.operation.binary.add",
"type_conversion.add"
] | 1,018,305 | 1,018,303 | u057866967 | cpp |
p03221 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
int N, M;
int P[100000], Y[100000];
vector<int> yd[100001];
int main() {
scanf("% d % d ", &N, &M);
for (int i = 0; i < M; i++) {
scanf("% d % d ", &P[i], &Y[i]), yd[P[i]].push_back(Y[i]);
}
for (int i = 0;... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
int N, M;
int P[100000], Y[100000];
vector<int> yd[100001];
int main() {
scanf("%d %d", &N, &M);
for (int i = 0; i < M; i++) {
scanf("%d %d", &P[i], &Y[i]), yd[P[i]].push_back(Y[i]);
}
for (int i = 0; i < N... | [
"literal.string.change",
"call.arguments.change"
] | 1,018,308 | 1,018,309 | u710135612 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> P(M), Y(M);
for (int i = 0; i < M; i++)
cin >> P[i] >> Y[i];
vector<pair<pair<int, int>, int>> q(M);
for (int i = 0; i < M; i++) {
q[i] = make_pair(make_pair(P[i], Y[i]), i);
}
sort(q.begin(), q.end(... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> P(M), Y(M);
for (int i = 0; i < M; i++)
cin >> P[i] >> Y[i];
vector<pair<pair<int, int>, int>> q(M);
for (int i = 0; i < M; i++) {
q[i] = make_pair(make_pair(P[i], Y[i]), i);
}
sort(q.begin(), q.end(... | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 1,018,310 | 1,018,311 | u302870145 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
typedef unsigned int uint;
using namespace std;
int main() {
int N, M;
cin >> N >> M;
pair<pai... | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
typedef unsigned int uint;
using namespace std;
int main() {
int N, M;
cin >> N >> M;
pair<pai... | [
"identifier.change",
"variable_declaration.array_dimensions.change"
] | 1,018,319 | 1,018,320 | u492131209 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> yd(n + 1);
vector<int> p(n);
vector<int> y(n);
for (int i = 0; i < m; i++) {
cin >> p[i] >> y[i];
yd[p[i]].push_back(y[i]);
}
for (int i = 0; i < n; i++) {
sort(yd[i + 1].begin(), yd[i + ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> yd(n + 1);
vector<int> p(m);
vector<int> y(m);
for (int i = 0; i < m; i++) {
cin >> p[i] >> y[i];
yd[p[i]].push_back(y[i]);
}
for (int i = 0; i < n; i++) {
sort(yd[i + 1].begin(), yd[i + ... | [] | 1,018,333 | 1,018,334 | u410878763 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> yd(n + 1);
vector<int> p(n);
vector<int> y(n);
for (int i = 0; i < m; i++) {
cin >> p[i] >> y[i];
yd[p[i]].push_back(y[i]);
}
for (int i = 0; i < n; i++) {
sort(yd[i].begin(), yd[i].end()... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> yd(n + 1);
vector<int> p(m);
vector<int> y(m);
for (int i = 0; i < m; i++) {
cin >> p[i] >> y[i];
yd[p[i]].push_back(y[i]);
}
for (int i = 0; i < n; i++) {
sort(yd[i + 1].begin(), yd[i + ... | [
"expression.operation.binary.add"
] | 1,018,335 | 1,018,334 | u410878763 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
typedef long long lint;
#define FOR(i, o, n) for (auto i = (o); (i) < (n); ++(i))
#define REP(i, n) FOR(i, 0, n)
#define REPR(i, n) for (auto i = (n)-1; (i) >= 0; --i)
#define REPI(itr, v) for (auto itr = v.begin(); itr != v.end(); ++itr)
#define REPIR(itr, v) for (auto itr... | #include <bits/stdc++.h>
using namespace std;
typedef long long lint;
#define FOR(i, o, n) for (auto i = (o); (i) < (n); ++(i))
#define REP(i, n) FOR(i, 0, n)
#define REPR(i, n) for (auto i = (n)-1; (i) >= 0; --i)
#define REPI(itr, v) for (auto itr = v.begin(); itr != v.end(); ++itr)
#define REPIR(itr, v) for (auto itr... | [
"identifier.change",
"call.arguments.change"
] | 1,018,344 | 1,018,345 | u918808222 | cpp |
p03221 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> vp[100010];
for (int i = 0; i < m; i++) {
int p, y;
cin >> p >> y;
vp[p].push_back({y, i});
}
pair<int, int> ans[100010];
for (int i = 0; i <= n; i++) {
sort(vp... | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> vp[100010];
for (int i = 0; i < m; i++) {
int p, y;
cin >> p >> y;
vp[p].push_back({y, i});
}
pair<int, int> ans[100010];
for (int i = 0; i <= n; i++) {
sort(vp... | [
"assignment.change"
] | 1,018,348 | 1,018,349 | u479371430 | cpp |
p03221 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> vp[100010];
for (int i = 0; i < m; i++) {
int p, y;
cin >> p >> y;
vp[p].push_back({y, i});
}
pair<int, int> ans[100010];
for (int i = 0; i <= n; i++) {
sort(vp... | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> vp[100010];
for (int i = 0; i < m; i++) {
int p, y;
cin >> p >> y;
vp[p].push_back({y, i});
}
pair<int, int> ans[100010];
for (int i = 0; i <= n; i++) {
sort(vp... | [
"assignment.change",
"control_flow.loop.for.condition.change"
] | 1,018,350 | 1,018,349 | u479371430 | cpp |
p03221 | #include <bits/stdc++.h>
#define dum(x) cout << #x << '=' << x << endl
#define ll long long
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> vp[100000];
for (int i = 0; i < m; i++) {
int p, y;
cin >> p >> y;
vp[p].push_back({y, i});
}
pair<int, int> ans[100000... | #include <bits/stdc++.h>
#define dum(x) cout << #x << '=' << x << endl
#define ll long long
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> vp[100010];
for (int i = 0; i < m; i++) {
int p, y;
cin >> p >> y;
vp[p].push_back({y, i});
}
pair<int, int> ans[100010... | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,018,353 | 1,018,352 | u479371430 | cpp |
p03221 | #include <bits/stdc++.h>
//#define int long long
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define ALL(v) (v).begin(), (v).end()
#define PR pair<int, int>
#define ios() \
ios::sync_with_stdio(0)... | #include <bits/stdc++.h>
//#define int long long
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define ALL(v) (v).begin(), (v).end()
#define PR pair<int, int>
#define ios() \
ios::sync_with_stdio(0)... | [
"expression.operation.binary.add"
] | 1,018,356 | 1,018,357 | u904833081 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (long long int i = 0; i < n; ++i)
typedef long long int ll;
string encode(int i) {
string num = to_string(i);
while (num.size() < 6) {
num = '0' + num;
}
return num;
}
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> s(... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (long long int i = 0; i < n; ++i)
typedef long long int ll;
string encode(int i) {
string num = to_string(i);
while (num.size() < 6) {
num = '0' + num;
}
return num;
}
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> s(... | [
"expression.operation.binary.add"
] | 1,018,358 | 1,018,359 | u376817785 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
using int64 = int64_t;
#define int int64
vector<int> d[101010];
signed main() {
int n, m;
cin >> n >> m;
vector<int> p(m), y(m);
for (int i = 0; i < m; ++i) {
cin >> p[i] >> y[i];
d[p[i]].push_back(y[i]);
}
for (int i = 0; i < n; ++i) {
sort(d[i].b... | #include <bits/stdc++.h>
using namespace std;
using int64 = int64_t;
#define int int64
vector<int> d[101010];
signed main() {
int n, m;
cin >> n >> m;
vector<int> p(m), y(m);
for (int i = 0; i < m; ++i) {
cin >> p[i] >> y[i];
d[p[i]].push_back(y[i]);
}
for (int i = 0; i < 101010; ++i) {
sort(d... | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,018,366 | 1,018,367 | u258009780 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
using int64 = int64_t;
#define int int64
vector<int> d[101010];
signed main() {
int n, m;
cin >> n >> m;
vector<int> p(m), y(m);
for (int i = 0; i < m; ++i) {
cin >> p[i] >> y[i];
d[p[i]].push_back(y[i]);
}
for (int i = 0; i < m; ++i) {
sort(d[i].b... | #include <bits/stdc++.h>
using namespace std;
using int64 = int64_t;
#define int int64
vector<int> d[101010];
signed main() {
int n, m;
cin >> n >> m;
vector<int> p(m), y(m);
for (int i = 0; i < m; ++i) {
cin >> p[i] >> y[i];
d[p[i]].push_back(y[i]);
}
for (int i = 0; i < 101010; ++i) {
sort(d... | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 1,018,368 | 1,018,367 | u258009780 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
using int64 = int64_t;
#define int int64
vector<int> d[101010];
signed main() {
int n, m;
cin >> n >> m;
vector<int> p(m), y(m);
for (int i = 0; i < m; ++i) {
cin >> p[i] >> y[i];
d[p[i]].push_back(y[i]);
}
for (int i = 0; i < m; ++i) {
sort(d[i].b... | #include <bits/stdc++.h>
using namespace std;
using int64 = int64_t;
#define int int64
vector<int> d[101010];
signed main() {
int n, m;
cin >> n >> m;
vector<int> p(m), y(m);
for (int i = 0; i < m; ++i) {
cin >> p[i] >> y[i];
d[p[i]].push_back(y[i]);
}
for (int i = 0; i < 101010; ++i) {
sort(d... | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,018,369 | 1,018,367 | u258009780 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int p[m], y[m];
vector<int> yd[n + 1];
for (int i = 0; i < m; i++) {
cin >> p[i] >> y[i]; // pi and yi enter
yd[p[i]].push_back(y[i]); // 県ごとの配列に年を入れていく
}
for (int i = 1; i < n; i++) {
sort(yd[i].begin(),... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int p[m], y[m];
vector<int> yd[n + 1];
for (int i = 0; i < m; i++) {
cin >> p[i] >> y[i]; // pi and yi enter
yd[p[i]].push_back(y[i]); // 県ごとの配列に年を入れていく
}
for (int i = 1; i <= n; i++) {
sort(yd[i].begin()... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,018,375 | 1,018,376 | u280114218 | cpp |
p03221 | #include "bits/stdc++.h"
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (int i = int(a), i##_len = (b); i < i##_len; ++i)
#define BUGAVOID(x) x
#define rep(...) \
BUGAVOID(_overload3(__VA_ARGS__, r... | #include "bits/stdc++.h"
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (int i = int(a), i##_len = (b); i < i##_len; ++i)
#define BUGAVOID(x) x
#define rep(...) \
BUGAVOID(_overload3(__VA_ARGS__, r... | [
"call.arguments.add"
] | 1,018,384 | 1,018,385 | u751488284 | cpp |
p03221 | #include <cinttypes>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <limits>
#include <type_traits>
#include <vector>
/* FastIO by rsk0315 (last update: 2018/02/21 00:36) */
namespace FastIn {
static constexpr size_t BUF_SIZE = 1 << 17, INT_LEN = 24, FLT_LEN = ... | #include <cinttypes>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <limits>
#include <type_traits>
#include <vector>
/* FastIO by rsk0315 (last update: 2018/02/21 00:36) */
namespace FastIn {
static constexpr size_t BUF_SIZE = 1 << 17, INT_LEN = 24, FLT_LEN = ... | [] | 1,018,389 | 1,018,390 | u352499693 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll n, m;
cin >> n >> m;
ll p[m], y[m];
vector<ll> py[m * 2];
for (int i = 0; i < m; i++)
cin >> p[i] >> y[i];
for (int i = 0; i < m; i++)
py[p[i]].push_back(y[i]);
for (int i = 0; i < n; i++)
sort(py[i + 1].begin... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll n, m;
cin >> n >> m;
ll p[m], y[m];
vector<ll> py[n + 1];
for (int i = 0; i < m; i++)
cin >> p[i] >> y[i];
for (int i = 0; i < m; i++)
py[p[i]].push_back(y[i]);
for (int i = 0; i < n; i++)
sort(py[i + 1].begin... | [] | 1,018,393 | 1,018,394 | u876784108 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll n, m;
cin >> n >> m;
ll p[m], y[m];
vector<ll> py[m + 5];
for (int i = 0; i < m; i++)
cin >> p[i] >> y[i];
for (int i = 0; i < m; i++)
py[p[i]].push_back(y[i]);
for (int i = 0; i < n; i++)
sort(py[i + 1].begin... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll n, m;
cin >> n >> m;
ll p[m], y[m];
vector<ll> py[n + 1];
for (int i = 0; i < m; i++)
cin >> p[i] >> y[i];
for (int i = 0; i < m; i++)
py[p[i]].push_back(y[i]);
for (int i = 0; i < n; i++)
sort(py[i + 1].begin... | [
"identifier.change",
"expression.operation.binary.change",
"literal.number.change"
] | 1,018,395 | 1,018,394 | u876784108 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll n, m;
cin >> n >> m;
ll p[m], y[m];
vector<ll> py[m + 1];
for (int i = 0; i < m; i++)
cin >> p[i] >> y[i];
for (int i = 0; i < m; i++)
py[p[i]].push_back(y[i]);
for (int i = 0; i < n; i++)
sort(py[i + 1].begin... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll n, m;
cin >> n >> m;
ll p[m], y[m];
vector<ll> py[n + 1];
for (int i = 0; i < m; i++)
cin >> p[i] >> y[i];
for (int i = 0; i < m; i++)
py[p[i]].push_back(y[i]);
for (int i = 0; i < n; i++)
sort(py[i + 1].begin... | [
"identifier.change",
"expression.operation.binary.change"
] | 1,018,396 | 1,018,394 | u876784108 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll n, m;
cin >> n >> m;
ll p[m], y[m];
vector<ll> py[m];
for (int i = 0; i < m; i++)
cin >> p[i] >> y[i];
for (int i = 0; i < m; i++)
py[p[i]].push_back(y[i]);
for (int i = 0; i < n; i++)
sort(py[i + 1].begin(), ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll n, m;
cin >> n >> m;
ll p[m], y[m];
vector<ll> py[n + 1];
for (int i = 0; i < m; i++)
cin >> p[i] >> y[i];
for (int i = 0; i < m; i++)
py[p[i]].push_back(y[i]);
for (int i = 0; i < n; i++)
sort(py[i + 1].begin... | [
"variable_declaration.array_dimensions.change",
"expression.operation.binary.add"
] | 1,018,397 | 1,018,394 | u876784108 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll n, m;
cin >> n >> m;
ll p[m], y[m];
vector<ll> py[m];
for (int i = 0; i < m; i++)
cin >> p[i] >> y[i];
for (int i = 0; i < m; i++)
py[p[i]].push_back(y[i]);
for (int i = 0; i < n; i++)
sort(py[i + 1].begin(), ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll n, m;
cin >> n >> m;
ll p[m], y[m];
vector<ll> py[100001];
for (int i = 0; i < m; i++)
cin >> p[i] >> y[i];
for (int i = 0; i < m; i++)
py[p[i]].push_back(y[i]);
for (int i = 0; i < n; i++)
sort(py[i + 1].begi... | [
"identifier.replace.remove",
"literal.replace.add",
"variable_declaration.array_dimensions.change"
] | 1,018,397 | 1,018,398 | u876784108 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, m, n) for (int i = (m); i < (int)(n); i++)
#define rrep(i, m, n) for (int i = (int)(m); i >= (int)(n); i--)
#define vsort(v) sort(v.begin(), v.end());
#define rvsort(v) sort(v.begin(), v.end(), greater<int>());
#define YES cout << "YES" << endl
#define NO co... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, m, n) for (int i = (m); i < (int)(n); i++)
#define rrep(i, m, n) for (int i = (int)(m); i >= (int)(n); i--)
#define vsort(v) sort(v.begin(), v.end());
#define rvsort(v) sort(v.begin(), v.end(), greater<int>());
#define YES cout << "YES" << endl
#define NO co... | [
"identifier.change",
"call.arguments.change"
] | 1,018,405 | 1,018,406 | u192442087 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, m, n) for (int i = (m); i < (int)(n); i++)
#define rrep(i, m, n) for (int i = (int)(m); i >= (int)(n); i--)
#define vsort(v) sort(v.begin(), v.end());
#define rvsort(v) sort(v.begin(), v.end(), greater<int>());
#define YES cout << "YES" << endl
#define NO co... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, m, n) for (int i = (m); i < (int)(n); i++)
#define rrep(i, m, n) for (int i = (int)(m); i >= (int)(n); i--)
#define vsort(v) sort(v.begin(), v.end());
#define rvsort(v) sort(v.begin(), v.end(), greater<int>());
#define YES cout << "YES" << endl
#define NO co... | [
"identifier.change",
"call.arguments.change"
] | 1,018,407 | 1,018,406 | u192442087 | cpp |
p03221 | //$g++ -std=c++11 Template.cpp
//#include <bits/stdc++.h>
#include <algorithm>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include... | //$g++ -std=c++11 Template.cpp
//#include <bits/stdc++.h>
#include <algorithm>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include... | [
"expression.operation.binary.add"
] | 1,018,408 | 1,018,409 | u783861517 | cpp |
p03221 | #include <algorithm>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
class city {
public:
long long id;
long long P;
long long X;
long long Y;
city() {
id = 0;
P = 0;
X = 0;
Y = 0;
}
};
bool cmp_id(const city &a, const city &b) { return a.id < b.id; }
bool c... | #include <algorithm>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
class city {
public:
long long id;
long long P;
long long X;
long long Y;
city() {
id = 0;
P = 0;
X = 0;
Y = 0;
}
};
bool cmp_id(const city &a, const city &b) { return a.id < b.id; }
bool c... | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 1,018,410 | 1,018,411 | u255768548 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (signed i = 0; i < n; ++i)
#define str string
#define debg(a) cout << #a << ":" << a << endl;
#define print(a) cout << a << endl;
#define elif else if
int n, m;
int p[100010], y[100010];
vector<signed> v[100010];
signed main() {
cin >> n >> m;
r... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (signed i = 0; i < n; ++i)
#define str string
#define debg(a) cout << #a << ":" << a << endl;
#define print(a) cout << a << endl;
#define elif else if
int n, m;
int p[100010], y[100010];
vector<signed> v[100010];
signed main() {
cin >> n >> m;
r... | [
"expression.operation.binary.add"
] | 1,018,412 | 1,018,413 | u423624748 | cpp |
p03221 | #include <algorithm>
#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
int main(void) {
int N, M;
cin >> N >> M;
vector<int> P(M);
vector<int> Y(M);
vector<int> yd[100001];
for (int i = 0; i < M; i++) {
cin >> P[i] >> Y[i];
yd[P[i]].push_back(Y[i]... | #include <algorithm>
#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
int main(void) {
int N, M;
cin >> N >> M;
vector<int> P(M);
vector<int> Y(M);
vector<int> yd[100001];
for (int i = 0; i < M; i++) {
cin >> P[i] >> Y[i];
yd[P[i]].push_back(Y[i]... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"call.add",
"call.arguments.change"
] | 1,018,416 | 1,018,417 | u047102107 | cpp |
p03221 | #include <algorithm>
#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
int main(void) {
int N, M;
cin >> N >> M;
vector<int> P(M);
vector<int> Y(M);
vector<int> yd[100001];
for (int i = 0; i < M; i++) {
cin >> P[i] >> Y[i];
yd[P[i]].push_back(Y[i]... | #include <algorithm>
#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
int main(void) {
int N, M;
cin >> N >> M;
vector<int> P(M);
vector<int> Y(M);
vector<int> yd[100001];
for (int i = 0; i < M; i++) {
cin >> P[i] >> Y[i];
yd[P[i]].push_back(Y[i]... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"call.add",
"call.arguments.change",
"literal.number.change",
"io.output.change"
] | 1,018,418 | 1,018,417 | u047102107 | cpp |
p03221 |
#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#defin... |
#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#defin... | [
"assignment.change"
] | 1,018,419 | 1,018,420 | u471289663 | cpp |
p03221 | #include <algorithm>
#include <iomanip>
#include <ios>
#include <iostream>
#include <vector>
using namespace std;
int main(void) {
int N, M;
cin >> N >> M;
int P[100001], Y[100001];
vector<int> list[100001];
for (int i = 0; i < M; i++) {
cin >> P[i] >> Y[i];
list[P[i]].push_back(Y[i]);
}
for (in... | #include <algorithm>
#include <iomanip>
#include <ios>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int P[100001], Y[100001];
vector<int> list[100001];
for (int i = 0; i < M; i++) {
cin >> P[i] >> Y[i];
list[P[i]].push_back(Y[i]);
}
for (int i ... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,018,424 | 1,018,425 | u913836622 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.