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 |
|---|---|---|---|---|---|---|---|
p03038 | #include <bits/stdc++.h>
#include <numeric>
#include <vector>
#define PI 3.14159265358979323846
#define MAXINF (1e18L)
#define INF (1e9L)
#define EPS (1e-9)
#define MOD ((ll)(1e9 + 7))
#define REP(i, n) for (int i = 0; i < int(n); ++i)
#define Rep(i, sta, n) for (int i = sta; i < n; i++)
#define RREP(i, n) for (int i =... | #include <bits/stdc++.h>
#include <numeric>
#include <vector>
#define PI 3.14159265358979323846
#define MAXINF (1e18L)
#define INF (1e9L)
#define EPS (1e-9)
#define MOD ((ll)(1e9 + 7))
#define REP(i, n) for (int i = 0; i < int(n); ++i)
#define Rep(i, sta, n) for (int i = sta; i < n; i++)
#define RREP(i, n) for (int i =... | [
"identifier.replace.add",
"literal.replace.remove",
"call.add"
] | 853,358 | 853,359 | u528720841 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
const int MAXn = 1e5 + 10;
typedef pair<int, int> pii;
long long res, sum, pref, goodsum;
int n, ar[MAXn], m;
vector<pii> vec;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> ar[i];
sum += ar[i... | #include <bits/stdc++.h>
using namespace std;
const int MAXn = 1e5 + 10;
typedef pair<int, int> pii;
long long res, sum, pref, goodsum;
int n, ar[MAXn], m;
vector<pii> vec;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> ar[i];
sum += ar[i... | [
"assignment.add"
] | 853,386 | 853,387 | u138661009 | cpp |
p03038 | using namespace std;
#include <bits/stdc++.h>
#define rep(i, s) for (int i = 0; i < s; ++i)
#define repr(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define all(v) (v.begin(), v.end())
#define EACH(i, s) \
for (__t... | using namespace std;
#include <bits/stdc++.h>
#define rep(i, s) for (int i = 0; i < s; ++i)
#define repr(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define all(v) (v.begin(), v.end())
#define EACH(i, s) \
for (__t... | [
"variable_declaration.add"
] | 853,400 | 853,401 | u535810324 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
struct node {
int ti, vi;
};
node no[maxn];
int n, m;
int a[maxn];
int sum;
bool cmp(node a, node b) { return a.vi > b.vi; }
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]);
sort(a + 1, a + n + 1);... | #include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
struct node {
int ti, vi;
};
node no[maxn];
int n, m;
int a[maxn];
long long sum;
bool cmp(node a, node b) { return a.vi > b.vi; }
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]);
sort(a + 1, a + n... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 853,412 | 853,413 | u660324536 | cpp |
p03038 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
ll N, M;
cin >> N >> M;
vector<pair<ll, ll>> Cards(N + M);
for (ll i = 0; i < N; i++) {
Cards[i].second = 1;
cin >> Cards[i].first;
}
for (ll j = 0; j < M; j++) {
cin >> Cards[j... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
ll N, M;
cin >> N >> M;
vector<pair<ll, ll>> Cards(N + M);
for (ll i = 0; i < N; i++) {
Cards[i].second = 1;
cin >> Cards[i].first;
}
for (ll j = 0; j < M; j++) {
cin >> Cards[j... | [
"assignment.change"
] | 853,431 | 853,432 | u904123392 | cpp |
p03038 | #include <bits/stdc++.h>
#define pb push_back
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define out(x) cout << x << endl;
#define all(x) (x).begin(), (x).end()
typedef long long ll;
using namespace std;
template <typename T> vector<T> v1init(int len) {
vecto... | #include <bits/stdc++.h>
#define pb push_back
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define out(x) cout << x << endl;
#define all(x) (x).begin(), (x).end()
typedef long long ll;
using namespace std;
template <typename T> vector<T> v1init(int len) {
vecto... | [
"expression.unary.arithmetic.add"
] | 853,433 | 853,434 | u923238225 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
vector<long long> a(n), b(m), c(m);
for (int i = 0; i < n; i++) {
cin >> a.at(i);
}
for (int i = 0; i < m; i++) {
cin >> b.at(i) >> c.at(i);
}
sort(a.begin(), a.end());
vector<pair<long long, long long>... | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
vector<long long> a(n), b(m), c(m);
for (int i = 0; i < n; i++) {
cin >> a.at(i);
}
for (int i = 0; i < m; i++) {
cin >> b.at(i) >> c.at(i);
}
sort(a.begin(), a.end());
vector<pair<long long, long long>... | [
"assignment.value.change",
"identifier.change",
"call.arguments.change"
] | 853,435 | 853,436 | u639024786 | cpp |
p03038 | #include <bits/stdc++.h>
#define INF 1e+18
#define ll long long
using namespace std;
signed main() {
int n, m, ans = 0, sum = 0;
map<int, int> mp;
cin >> n >> m;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
mp[a]++;
}
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
mp[b] +=... | #include <bits/stdc++.h>
#define INF 1e+18
#define int long long
using namespace std;
signed main() {
int n, m, ans = 0, sum = 0;
map<int, int> mp;
cin >> n >> m;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
mp[a]++;
}
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
mp[b] +... | [
"identifier.change"
] | 853,439 | 853,440 | u456611841 | cpp |
p03038 | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
map<int, int> mp;
for (int i = 0; i < n; i++) {
int aux;
cin >> aux;
mp[aux]++;
}
for (int i = 0; i < m; i++) {
int B... | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
map<int, int> mp;
for (int i = 0; i < n; i++) {
int aux;
cin >> aux;
mp[aux]++;
}
for (int i = 0; i < m; i++) {
int B... | [
"type_conversion.add"
] | 853,449 | 853,450 | u027395921 | cpp |
p03038 | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
map<int, int> mp;
for (int i = 0; i < n; i++) {
int aux;
cin >> aux;
mp[aux]++;
}
for (int i = 0; i < m; i++) {
int B... | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
map<int, int> mp;
for (int i = 0; i < n; i++) {
int aux;
cin >> aux;
mp[aux]++;
}
for (int i = 0; i < m; i++) {
int B... | [
"variable_declaration.type.widen.change",
"type_conversion.add"
] | 853,451 | 853,450 | u027395921 | cpp |
p03038 | #include <bits/stdc++.h>
#define mod 1000000007
#define rep(i, n) for (int i = 0; i < n; ++i)
using namespace std;
typedef long long ll;
const long long INF = 1LL << 60;
int main(void) {
int N, M, ans = 0;
cin >> N >> M;
vector<int> A(N);
vector<pair<int, int>> bc(M);
rep(i, N) cin >> A[i];
rep(i, ... | #include <bits/stdc++.h>
#define mod 1000000007
#define rep(i, n) for (int i = 0; i < n; ++i)
using namespace std;
typedef long long ll;
const long long INF = 1LL << 60;
int main(void) {
ll N, M, ans = 0;
cin >> N >> M;
vector<int> A(N);
vector<pair<int, int>> bc(M);
rep(i, N) cin >> A[i];
rep(i, M... | [
"variable_declaration.type.change"
] | 853,462 | 853,463 | u895536055 | cpp |
p03038 | #include <bits/stdc++.h> //C++の標準ライブラリを一行で一括でインクルードする
#include <math.h> //数学関数と数学定数を利用する
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
template <class T> void chmax(T &a, T b) {
if (a < b)
a = b;
}
template <class T> void chmin(T &a, T b) {
if (a > b)
a = b;
}
in... | #include <bits/stdc++.h> //C++の標準ライブラリを一行で一括でインクルードする
#include <math.h> //数学関数と数学定数を利用する
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
template <class T> void chmax(T &a, T b) {
if (a < b)
a = b;
}
template <class T> void chmin(T &a, T b) {
if (a > b)
a = b;
}
in... | [
"variable_declaration.type.change"
] | 853,482 | 853,483 | u014967455 | cpp |
p03038 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <vector>
#define rep(i, N) for (int i = 0; i < (int)N; i++)
using namespace std;
typedef long long ll;
const ll LLINF = 9223372036854775807;
const int INF = pow(2, 29);
const int MOD = 1000000007;
b... | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <vector>
#define rep(i, N) for (int i = 0; i < (int)N; i++)
using namespace std;
typedef long long ll;
const ll LLINF = 9223372036854775807;
const int INF = pow(2, 29);
const int MOD = 1000000007;
b... | [
"variable_declaration.type.change"
] | 853,486 | 853,485 | u680707192 | cpp |
p03038 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
priority_queue<pair<int, int>> Q;
rep(i, n) {
int a;
scanf("%d", &a);
Q.emplace(-a, 1);
}
rep(_, m) {
int b, c;
scanf("%d%d", &b, &c);
int b... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
priority_queue<pair<int, int>> Q;
rep(i, n) {
int a;
scanf("%d", &a);
Q.emplace(-a, 1);
}
rep(_, m) {
int b, c;
scanf("%d%d", &b, &c);
int b... | [
"identifier.change",
"call.arguments.change"
] | 853,487 | 853,488 | u781095600 | cpp |
p03038 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define LL long long
#define MOD (1000000007)
// 127
struct IntPair {
LL B, C;
};
int main() {
LL N, M;
scanf... | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define LL long long
#define MOD (1000000007)
// 127
struct IntPair {
LL B, C;
};
int main() {
LL N, M;
scanf... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 853,493 | 853,494 | u572472538 | cpp |
p03038 | #include <bits/stdc++.h>
#define MOD 1000000007
typedef long long int ll;
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<ll> a(N), c(M), d(N);
vector<int> b(M);
vector<pair<int, int>> pairs(M);
ll sum = 0;
ll ans = 0;
for (int i = 0; i < N; i++) {
cin >> a[i];
sum += a[i];
... | #include <bits/stdc++.h>
#define MOD 1000000007
typedef long long int ll;
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<ll> a(N), c(M), d(N);
vector<int> b(M);
vector<pair<ll, int>> pairs(M);
ll sum = 0;
ll ans = 0;
for (int i = 0; i < N; i++) {
cin >> a[i];
sum += a[i];
}... | [] | 853,514 | 853,515 | u942714396 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < n; i++)
typedef long long ll;
ll mod = 1000000007;
/*
N+sum(B)個ののカードをソートして大きいものN個をとる
*/
void solve() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> v;
rep(i, n) {
int a;
cin >> a;
v.emplace_back(make_pair(-a, 1))... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < n; i++)
typedef long long ll;
ll mod = 1000000007;
/*
N+sum(B)個ののカードをソートして大きいものN個をとる
*/
void solve() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> v;
rep(i, n) {
int a;
cin >> a;
v.emplace_back(make_pair(-a, 1))... | [
"expression.unary.arithmetic.add"
] | 853,524 | 853,525 | u272496669 | cpp |
p03038 | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef map<int, int> mii;
typedef map<char, int> mci;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vll;
typedef vector<pair<int, int>> vii;
typedef vector<char> vc;
typedef vecto... | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef map<int, int> mii;
typedef map<char, int> mci;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vll;
typedef vector<pair<int, int>> vii;
typedef vector<char> vc;
typedef vecto... | [
"control_flow.loop.for.condition.change",
"call.add",
"call.arguments.add"
] | 853,531 | 853,532 | u562206657 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
int main() {
int n, m;
cin >> n >> m;
vector<i64> v;
for (int i = 0; i < n; ++i) {
i64 a;
cin >> a;
v.push_back(a);
}
vector<pair<i64, i64>> op;
for (int i = 0; i < m; ++i) {
i64 b, c;
cin >> b >> c;
op.emplace_ba... | #include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
int main() {
int n, m;
cin >> n >> m;
vector<i64> v;
for (int i = 0; i < n; ++i) {
i64 a;
cin >> a;
v.push_back(a);
}
vector<pair<i64, i64>> op;
for (int i = 0; i < m; ++i) {
i64 b, c;
cin >> b >> c;
op.emplace_ba... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 853,538 | 853,539 | u823112986 | cpp |
p03038 | #include <algorithm>
#include <bitset>
#include <ciso646>
#include <cmath>
#include <complex>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#incl... | #include <algorithm>
#include <bitset>
#include <ciso646>
#include <cmath>
#include <complex>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#incl... | [
"expression.operation.binary.add"
] | 853,548 | 853,549 | u236127431 | cpp |
p03038 | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define REPr(i, n) for (int i = (n)-1; i >= 0; --i)
#define FORq(i, m, n) for (int i = (m); i <= (n); ++i)
#define FORqr(i, m, n) for (int i = (n); i >= (m); --i)
#define PB push_back
#define M... | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define REPr(i, n) for (int i = (n)-1; i >= 0; --i)
#define FORq(i, m, n) for (int i = (m); i <= (n); ++i)
#define FORqr(i, m, n) for (int i = (n); i >= (m); --i)
#define PB push_back
#define M... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 853,559 | 853,560 | u532894762 | cpp |
p03038 | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define REPr(i, n) for (int i = (n)-1; i >= 0; --i)
#define FORq(i, m, n) for (int i = (m); i <= (n); ++i)
#define FORqr(i, m, n) for (int i = (n); i >= (m); --i)
#define PB push_back
#define M... | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define REPr(i, n) for (int i = (n)-1; i >= 0; --i)
#define FORq(i, m, n) for (int i = (m); i <= (n); ++i)
#define FORqr(i, m, n) for (int i = (n); i >= (m); --i)
#define PB push_back
#define M... | [] | 853,561 | 853,560 | u532894762 | cpp |
p03038 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N);
vector<pair<int, int>> B_C(M);
for (int i = 0; i < N; i++)
cin >> A.at(i);
for (int i = 0; i < M; i++) {
... | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N);
vector<pair<int, int>> B_C(M);
for (int i = 0; i < N; i++)
cin >> A.at(i);
for (int i = 0; i < M; i++) {
... | [
"expression.operation.binary.change",
"control_flow.loop.for.condition.change",
"call.arguments.change"
] | 853,562 | 853,563 | u091454649 | cpp |
p03038 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <vector>
int main() {
int N, M;
std::cin >> N >> M;
std::vector<int> A(N), B(M), C(M);
for (int i = 0; i < N; ++i)
std::cin >> A[i];
for (int i = 0; i < M; ++i)
std::cin >> B[i] >> C[i];
std::vector<std::pair<int, ... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <vector>
int main() {
int N, M;
std::cin >> N >> M;
std::vector<long int> A(N), B(M), C(M);
for (int i = 0; i < N; ++i)
std::cin >> A[i];
for (int i = 0; i < M; ++i)
std::cin >> B[i] >> C[i];
std::vector<std::pair<... | [
"variable_declaration.type.widen.change"
] | 853,576 | 853,577 | u936600428 | cpp |
p03038 | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int n, m;
long long sum = 0;
cin >> n >> m;
int a[n];
pair<int, int> b[m];
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
for (int i = 0; i < m; i++) {
scanf("%d %d", &b[i].second, &b[i].first);
}
sort(a, a +... | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int n, m;
long long sum = 0;
cin >> n >> m;
int a[n];
pair<int, int> b[m];
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
for (int i = 0; i < m; i++) {
scanf("%d %d", &b[i].second, &b[i].first);
}
sort(a, a +... | [
"assignment.change"
] | 853,578 | 853,579 | u625436307 | cpp |
p03038 | #include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, l... | #include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, l... | [
"control_flow.loop.for.initializer.change",
"variable_declaration.type.change"
] | 853,589 | 853,590 | u194385557 | cpp |
p03038 | #include <algorithm>
#include <iostream>
#include <vector>
int main() {
std::vector<std::pair<int, int>> cards;
int n, m;
std::cin >> n >> m;
for (int i = 0; i < n; i++) {
int tmp;
std::cin >> tmp;
cards.push_back(std::pair<int, int>(tmp, 1));
}
for (int i = 0; i < m; i++) {
int b, c;
... | #include <algorithm>
#include <iostream>
#include <vector>
int main() {
std::vector<std::pair<int, int>> cards;
int n, m;
std::cin >> n >> m;
for (int i = 0; i < n; i++) {
int tmp;
std::cin >> tmp;
cards.push_back(std::pair<int, int>(tmp, 1));
}
for (int i = 0; i < m; i++) {
int b, c;
... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 853,600 | 853,601 | u775347320 | cpp |
p03038 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
const int INF = 999999999;
int main() {
int N, M;
cin >> N... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
const int INF = 999999999;
int main() {
int N, M;
cin >> N... | [
"variable_declaration.type.change"
] | 853,605 | 853,606 | u239023686 | cpp |
p03038 | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rrep(i, a, b) for (int i = a; i >= b; i--)
#define fore(i, a) for (auto &i : a)
#define all(x) (x).begin(), (x).end()
//#pragma GCC optimize ("-O3")
using namespace std;
void _main();
int main() {
cin.tie(0);
ios::sync_with_stdio(fals... | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rrep(i, a, b) for (int i = a; i >= b; i--)
#define fore(i, a) for (auto &i : a)
#define all(x) (x).begin(), (x).end()
//#pragma GCC optimize ("-O3")
using namespace std;
void _main();
int main() {
cin.tie(0);
ios::sync_with_stdio(fals... | [] | 853,612 | 853,613 | u141378465 | cpp |
p03038 | #include <algorithm>
#include <cmath>
#include <iostream>
typedef struct _pair {
long long int B;
long long int C;
} pair;
bool comC(pair &a, pair &b) { return a.C < b.C; }
int main() {
long long int N, M, A[100000], newA[100000], result = 0;
pair data[100000];
std::cin >> N >> M;
for (int i = 0; i < N; ... | #include <algorithm>
#include <cmath>
#include <iostream>
typedef struct _pair {
long long int B;
long long int C;
} pair;
bool comC(pair &a, pair &b) { return a.C < b.C; }
int main() {
long long int N, M, A[100000], newA[100000], result = 0;
pair data[100000];
std::cin >> N >> M;
for (int i = 0; i < N; ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 853,625 | 853,626 | u451529323 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
int n, m, a[N], z;
pair<int, int> v[N];
long long int sum = 0;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
v[i] = make_pair... | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
int n, m, a[N], z;
pair<int, int> v[N];
long long int sum = 0;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
v[i] = make_pair... | [
"control_flow.loop.condition.change",
"control_flow.loop.for.condition.change"
] | 853,627 | 853,628 | u221592478 | cpp |
p03038 | #include <algorithm>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <s... | #include <algorithm>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <s... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 853,640 | 853,641 | u432551953 | cpp |
p03038 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <iterator>
#include <list>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; ++i)
... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <iterator>
#include <list>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; ++i)
... | [
"control_flow.branch.if.add"
] | 853,648 | 853,647 | u848359007 | cpp |
p03038 | #include <bits/stdc++.h>
int n, m;
std::vector<int> vec, vec2;
std::vector<std::pair<int, int>> query;
int main() {
std::cin >> n >> m;
vec2.assign(n, 0);
for (int i = 0; i < n; i++) {
std::cin >> vec2[i];
}
query.assign(m, {0, 0});
for (int i = 0; i < m; i++) {
std::cin >> query[i].second >> quer... | #include <bits/stdc++.h>
int n, m;
std::vector<int> vec, vec2;
std::vector<std::pair<int, int>> query;
int main() {
std::cin >> n >> m;
vec2.assign(n, 0);
for (int i = 0; i < n; i++) {
std::cin >> vec2[i];
}
query.assign(m, {0, 0});
for (int i = 0; i < m; i++) {
std::cin >> query[i].second >> quer... | [
"assignment.change"
] | 853,654 | 853,655 | u537538698 | cpp |
p03038 | #include <bits/stdc++.h>
#define int long long
using namespace std;
// typedef
//------------------------------------------
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef vector<bool> VB;
typedef vector<PII> VP;
// REPEAT
//------------------------------... | #include <bits/stdc++.h>
#define int long long
using namespace std;
// typedef
//------------------------------------------
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef vector<bool> VB;
typedef vector<PII> VP;
// REPEAT
//------------------------------... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 853,664 | 853,665 | u055131803 | cpp |
p03038 | #include <algorithm>
#include <cstdio>
#include <iostream>
#define PII pair<ll, ll>
#define F first
#define S second
using namespace std;
typedef long long ll;
ll n, n2, m;
ll ans;
ll a[100005];
PII b[100005];
int main() {
scanf("%lld%lld", &n, &m);
n2 = n;
for (ll i = 0; i < n; i++) {
scanf("%lld", &a[i])... | #include <algorithm>
#include <cstdio>
#include <iostream>
#define PII pair<ll, ll>
#define F first
#define S second
using namespace std;
typedef long long ll;
ll n, n2, m;
ll ans;
ll a[100005];
PII b[100005];
int main() {
scanf("%lld%lld", &n, &m);
n2 = n;
for (ll i = 0; i < n; i++) {
scanf("%lld", &a[i])... | [
"expression.unary.arithmetic.add"
] | 853,668 | 853,669 | u307227472 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
#define For(i, n) for (long i = 0; i < (n); i++)
int main() {
long n, m, k = 0;
cin >> n >> m;
vector<long> A(n);
vector<pair<long, long>> BC(m);
vector<long> change;
For(i, n) { cin >> A.at(i); }
For(i, m) {
long b, c;
cin >> b >> c;
BC[i] = make... | #include <bits/stdc++.h>
using namespace std;
#define For(i, n) for (long i = 0; i < (n); i++)
int main() {
long n, m, k = 0;
cin >> n >> m;
vector<long> A(n);
vector<pair<long, long>> BC(m);
vector<long> change;
For(i, n) { cin >> A.at(i); }
For(i, m) {
long b, c;
cin >> b >> c;
BC[i] = make... | [
"control_flow.branch.if.condition.change"
] | 853,687 | 853,688 | u813174766 | cpp |
p03038 | #include <algorithm>
#include <iostream>
using namespace std;
int a[100006];
struct lin {
int num;
int value;
};
lin b[100006];
bool cmp(lin a, lin b) { return a.value > b.value; }
int main() {
int n;
int m;
cin >> n >> m;
long long sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i... | #include <algorithm>
#include <iostream>
using namespace std;
int a[100006];
struct lin {
int num;
int value;
};
lin b[100006];
bool cmp(lin a, lin b) { return a.value > b.value; }
int main() {
int n;
int m;
cin >> n >> m;
long long sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 853,691 | 853,692 | u359563380 | cpp |
p03038 | #include <algorithm>
#include <iostream>
using namespace std;
int a[100006];
struct lin {
int num;
int value;
};
lin b[100006];
bool cmp(lin a, lin b) { return a.value > b.value; }
int main() {
int n;
int m;
cin >> n >> m;
long long sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i... | #include <algorithm>
#include <iostream>
using namespace std;
int a[100006];
struct lin {
int num;
int value;
};
lin b[100006];
bool cmp(lin a, lin b) { return a.value > b.value; }
int main() {
int n;
int m;
cin >> n >> m;
long long sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 853,693 | 853,692 | u359563380 | cpp |
p03038 | #include <algorithm>
#include <array>
#include <cmath>
#include <complex>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
template <c... | #include <algorithm>
#include <array>
#include <cmath>
#include <complex>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
template <c... | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 853,696 | 853,697 | u199371251 | cpp |
p03038 | #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"
] | 853,700 | 853,701 | u375619974 | cpp |
p03038 | #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"
] | 853,702 | 853,701 | u375619974 | cpp |
p03038 | #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)
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<long long> a(n), b(m), c(m);
rep(i, n) cin >> a[i];
vector<pair<l... | #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)
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<long long> a(n), b(m), c(m);
rep(i, n) cin >> a[i];
vector<pair<l... | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"control_flow.branch.if.condition.change"
] | 853,703 | 853,704 | u130834452 | cpp |
p03038 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main(int argc, char const *argv[]) {
/*
cin>>x;
cout<<x<<endl;
*/
int a, b, c, i, j, k, l, n, m, ans = ... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main(int argc, char const *argv[]) {
/*
cin>>x;
cout<<x<<endl;
*/
int a, b, c, i, j, k, l, n, m, ans = ... | [
"type_conversion.add"
] | 853,720 | 853,721 | u785689316 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N);
vector<vector<int>> B(M + N, vector<int>(2));
for (int i = 0; i < N; i++) {
cin >> A.at(i);
}
for (int i = 0; i < M; i++) {
cin >> B.at(i).at(1) >> B.at(i).at(0);
}
for (int i = M; i < M + N; ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<long long> A(N);
vector<vector<long long>> B(M + N, vector<long long>(2));
for (int i = 0; i < N; i++) {
cin >> A.at(i);
}
for (int i = 0; i < M; i++) {
cin >> B.at(i).at(1) >> B.at(i).at(0);
}
for (int ... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 853,724 | 853,725 | u028061225 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
vector<pair<int, int>> b(m, pair<int, int>());
vector<long long> sum(n, 0);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
for (int i = 0; i < n; i++) {
if (i == 0)
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
vector<pair<int, int>> b(m, pair<int, int>());
vector<long long> sum(n, 0);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
for (int i = 0; i < n; i++) {
if (i == 0)
... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 853,726 | 853,727 | u280114218 | cpp |
p03038 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
const int M = 1e5 + 50;
int a[M] = {0};
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a, a + n);
vector<pair<int, int>> v;
for (int i = 0; i < m; i... | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
const int M = 1e5 + 50;
int a[M] = {0};
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a, a + n);
vector<pair<int, int>> v;
for (int i = 0; i < m; i... | [
"expression.unary.arithmetic.add"
] | 853,728 | 853,729 | u061597928 | cpp |
p03038 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
bool comp(const vector<ll> &a, const vector<ll> &b) { return a[1] > b[1]; }
int main() {
int N, M;
cin >> N >> M;
ll tmp, b, c, p;
vector<ll> A;
vector<vector<ll>> move;
for (int i = 0; i < N; i++) {
... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
bool comp(const vector<ll> &a, const vector<ll> &b) { return a[1] > b[1]; }
int main() {
int N, M;
cin >> N >> M;
ll tmp, b, c, p;
vector<ll> A;
vector<vector<ll>> move;
for (int i = 0; i < N; i++) {
... | [
"expression.operation.binary.remove"
] | 853,730 | 853,731 | u816580121 | cpp |
p03038 | /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author
*/
#include <fstream>
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define tr(container, it) \
for (auto it = containe... | /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author
*/
#include <fstream>
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define tr(container, it) \
for (auto it = containe... | [
"expression.operation.binary.remove"
] | 853,732 | 853,733 | u093219895 | cpp |
p03038 |
// include
//------------------------------------------
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
... |
// include
//------------------------------------------
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 853,734 | 853,735 | u874996917 | cpp |
p03038 | #include "bits/stdc++.h"
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(a) (a).begin(), (a).end()
#define LL long long
int n, m;
vector<LL> a;
vector<pair<int, LL>> v;
int main() {
cin >> n >> m;
REP(i, n) {
LL tmp;
cin >> tmp;
a.pu... | #include "bits/stdc++.h"
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(a) (a).begin(), (a).end()
#define LL long long
int n, m;
vector<LL> a;
vector<pair<int, LL>> v;
int main() {
cin >> n >> m;
REP(i, n) {
LL tmp;
cin >> tmp;
a.pu... | [
"call.arguments.add",
"call.arguments.change"
] | 853,736 | 853,737 | u190952243 | cpp |
p03038 | /*
ID: thanhvq1
LANG: C++14
PROB: namenum
*/
#pragma GCC optimize("O2")
#include <bits/stdc++.h>
#include <unistd.h>
using namespace std;
#define int long long
#define double long double
#define vec vector
#define vi vector<int>
#define FZ(n) memset((n), 0, sizeof(n))
#define FMO(n) memset((n), -1, sizeof(n))
#define ... | /*
ID: thanhvq1
LANG: C++14
PROB: namenum
*/
#pragma GCC optimize("O2")
#include <bits/stdc++.h>
#include <unistd.h>
using namespace std;
#define int long long
#define double long double
#define vec vector
#define vi vector<int>
#define FZ(n) memset((n), 0, sizeof(n))
#define FMO(n) memset((n), -1, sizeof(n))
#define ... | [
"call.remove"
] | 853,746 | 853,747 | u210484769 | cpp |
p03038 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <exception>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <vector>
using... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <exception>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <vector>
using... | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 853,770 | 853,771 | u103539599 | cpp |
p03038 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> a;
for (int i = 0; i < N; ++i) {
long int A;
cin >> A;
a.push_back(A);
}
sort(a.begin(), a.end());
re... | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> a;
for (int i = 0; i < N; ++i) {
long int A;
cin >> A;
a.push_back(A);
}
sort(a.begin(), a.end());
re... | [] | 853,772 | 853,773 | u041282550 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
const ll INF = LLONG_MAX;
int main() {
int n, m;
cin >> n >> m;
vector<ll> a(n);
vector<pair<ll, ll>> cb(m);
ll mi = INF;
for (int i = 0; i < n; i++) {
cin >> a[i];
mi = min(mi, a[i]);
}
for (int i = 0; ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
const ll INF = LLONG_MAX;
int main() {
int n, m;
cin >> n >> m;
vector<ll> a(n);
vector<pair<ll, ll>> cb(m);
ll mi = INF;
for (int i = 0; i < n; i++) {
cin >> a[i];
mi = min(mi, a[i]);
}
for (int i = 0; ... | [] | 853,788 | 853,789 | u850894780 | cpp |
p03038 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespace std;
int gcd(int n, int m) {
if (n == 0)
return m;
return gcd(m % n, n);
}
int main() {
int N, M;
cin >> N... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespace std;
int gcd(int n, int m) {
if (n == 0)
return m;
return gcd(m % n, n);
}
int main() {
int N, M;
cin >> N... | [
"misc.opposites",
"expression.operator.compare.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 853,790 | 853,791 | u671357638 | cpp |
p03038 | #include <algorithm>
#include <functional>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m;
long long ans = 0;
vector<pair<int, int>> pairs;
cin >> n >> m;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
pairs.push_back(make_pair(a, 1));
}
for (int i = 0;... | #include <algorithm>
#include <functional>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m;
long long ans = 0;
vector<pair<long long, long long>> pairs;
cin >> n >> m;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
pairs.push_back(make_pair(a, 1));
}
for... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 853,792 | 853,793 | u227764848 | cpp |
p03038 | #include <algorithm>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N), B(M), C(M);
map<int, int> m;
for (int i = 0; i < N; i++) {
cin >> A[i];
if (m.find(A[i]) == m.end())
m[A[i]] = 1;
else
... | #include <algorithm>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N), B(M), C(M);
map<ll, ll> m;
for (int i = 0; i < N; i++) {
cin >> A[i];
if (m.find(A[i]) == m.end())
m[A[i]] = 1;
else
... | [] | 853,802 | 853,803 | u024469792 | cpp |
p03038 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <queue>
#include <set>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
int main() {
bool flag = false;
long long int N, M, ans = 0, k = 0;
cin >> N >> M;
vector<long long int> A(N, 0);
vector<pair<long long int, l... | #include <algorithm>
#include <iostream>
#include <math.h>
#include <queue>
#include <set>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
int main() {
bool flag = false;
long long int N, M, ans = 0, k = 0;
cin >> N >> M;
vector<long long int> A(N, 0);
vector<pair<long long int, l... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 853,804 | 853,805 | u444349080 | cpp |
p03038 | #include <algorithm>
#include <array>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <limits>
#include <numeric>
#include <queue>
#include <regex>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
bool compare(const pair<long long, long lon... | #include <algorithm>
#include <array>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <limits>
#include <numeric>
#include <queue>
#include <regex>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
bool compare(const pair<long long, long lon... | [
"control_flow.branch.if.condition.change"
] | 853,818 | 853,819 | u576712004 | cpp |
p03038 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
typedef vector<pair<ll, ll>> Q;
typedef pair<int, int> P;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
const ll inf = 1e9 + ... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
typedef vector<pair<ll, ll>> Q;
typedef pair<ll, ll> P;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
const ll inf = 1e9 + 7;... | [
"control_flow.loop.condition.change"
] | 853,828 | 853,827 | u620242073 | cpp |
p03038 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define ll long long
#d... | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define ll long long
#d... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 853,835 | 853,836 | u118846704 | cpp |
p03038 | #include <bits/stdc++.h>
struct Node {
int value;
int cnt;
bool operator<(const Node &rhs) const { return value > rhs.value; }
};
const int maxn = 2e5 + 10;
int n, m;
long long sum;
Node p[maxn];
int main() {
std::cin >> n >> m;
for (int i = 1; i <= n; i++)
std::cin >> p[i].value, p[i].cnt = 1;
for (... | #include <bits/stdc++.h>
struct Node {
int value;
int cnt;
bool operator<(const Node &rhs) const { return value > rhs.value; }
};
const int maxn = 2e5 + 10;
int n, m;
long long sum;
Node p[maxn];
int main() {
std::cin >> n >> m;
for (int i = 1; i <= n; i++)
std::cin >> p[i].value, p[i].cnt = 1;
for (... | [
"assignment.change"
] | 853,839 | 853,840 | u578930989 | cpp |
p03038 | #include <bits/stdc++.h>
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define fu(i, r, t) for (int i = r; i... | #include <bits/stdc++.h>
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define fu(i, r, t) for (int i = r; i... | [
"control_flow.branch.if.condition.change"
] | 853,843 | 853,844 | u020160935 | cpp |
p03038 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <utility>
#include <vector>
#define INF 1e16
#define rep(i, n) for (int i = 0; i < n; i++)
#define NO cout << "NO" << endl;
#define YES cout << "YES" << endl;
#define No cout << "No" << endl;
#define Ye... | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <utility>
#include <vector>
#define INF 1e16
#define rep(i, n) for (int i = 0; i < n; i++)
#define NO cout << "NO" << endl;
#define YES cout << "YES" << endl;
#define No cout << "No" << endl;
#define Ye... | [
"control_flow.branch.if.condition.change",
"expression.operator.compare.change"
] | 853,847 | 853,848 | u297203024 | cpp |
p03038 | #include <algorithm>
#include <cctype>
#include <climits>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
// typedef pair<... | #include <algorithm>
#include <cctype>
#include <climits>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
// typedef pair<... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 853,859 | 853,860 | u559645647 | cpp |
p03038 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <regex>
#include <set>
#include <sstream>
#include <stac... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <regex>
#include <set>
#include <sstream>
#include <stac... | [
"variable_declaration.type.change",
"control_flow.loop.for.initializer.change"
] | 853,865 | 853,866 | u385617244 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
std::cin >> n >> m;
std::vector<long> a(n);
std::vector<pair<long, long>> b(m);
for (int i = 0; i < n; i++) {
/* code */
std::cin >> a[i];
}
for (int i = 0; i < m; i++) {
/* code */
std::cin >> b[i].second >> b[i].first;... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
std::cin >> n >> m;
std::vector<long> a(n);
std::vector<pair<long, long>> b(m);
for (int i = 0; i < n; i++) {
/* code */
std::cin >> a[i];
}
for (int i = 0; i < m; i++) {
/* code */
std::cin >> b[i].second >> b[i].first;... | [
"literal.number.type.widen.change"
] | 853,870 | 853,871 | u539011156 | cpp |
p03038 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int a[100002], s[100002];
struct cz {
int b, c;
} z[100002];
bool cmp(cz x, cz y) { return x.c > y.c; }
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++)
cin >> a[i];
sort(a + 1, a + n + 1);
int r = 0;
f... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int a[100002], s[100002];
struct cz {
int b, c;
} z[100002];
bool cmp(cz x, cz y) { return x.c > y.c; }
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++)
cin >> a[i];
sort(a + 1, a + n + 1);
int r = 0;
f... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 853,872 | 853,873 | u350561505 | cpp |
p03038 | #include <algorithm>
#include <iostream>
#include <vector>
int main() {
int n, m;
std::cin >> n >> m;
std::vector<int> a;
std::vector<std::pair<int, int>> bc;
for (int i = 0; i < n; i++) {
int temp;
std::cin >> temp;
a.push_back(temp);
}
for (int i = 0; i < m; i++) {
int b, c;
std::ci... | #include <algorithm>
#include <iostream>
#include <vector>
int main() {
int n, m;
std::cin >> n >> m;
std::vector<int> a;
std::vector<std::pair<int, int>> bc;
for (int i = 0; i < n; i++) {
int temp;
std::cin >> temp;
a.push_back(temp);
}
for (int i = 0; i < m; i++) {
int b, c;
std::ci... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 853,880 | 853,881 | u647903912 | cpp |
p03038 | #pragma region include
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define ALL(obj) (obj).begin(), (obj).end()
#define RALL(obj) (obj).rbegin(), (obj).rend()
#define REP(i, n) for (int i =... | #pragma region include
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define ALL(obj) (obj).begin(), (obj).end()
#define RALL(obj) (obj).rbegin(), (obj).rend()
#define REP(i, n) for (int i =... | [
"type_conversion.add"
] | 853,884 | 853,885 | u435935167 | cpp |
p03038 | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include ... | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include ... | [] | 853,890 | 853,891 | u054652697 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int64_t> A(N);
vector<int64_t> D;
struct map {
int b;
int64_t c;
};
vector<map> bc;
int64_t answer = 0;
for (int i = 0; i < N; i++) {
int a;
cin >> a;
A.at(i) = a;
}
sort(A.begin(), A.en... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int64_t> A(N);
vector<int64_t> D;
struct map {
int b;
int64_t c;
};
vector<map> bc;
int64_t answer = 0;
for (int i = 0; i < N; i++) {
int a;
cin >> a;
A.at(i) = a;
}
sort(A.begin(), A.en... | [
"misc.opposites",
"expression.operator.compare.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 853,894 | 853,895 | u412989489 | cpp |
p03038 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
typedef long long ll;
using namespace std;
int main() {
// input
int n, m, a, b, c;
cin >> n >> m;
vector<pair<ll, int>> cb;
rep(i, n) {
cin >> a;
cb.push_back(make_pair(a, 1));
}
rep(i, m) {
cin >> b >> c;
cb[i] = mak... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
typedef long long ll;
using namespace std;
int main() {
// input
int n, m, a, b, c;
cin >> n >> m;
vector<pair<ll, int>> cb;
rep(i, n) {
cin >> a;
cb.push_back(make_pair(a, 1));
}
rep(i, m) {
cin >> b >> c;
cb.push_bac... | [
"call.arguments.change"
] | 853,904 | 853,905 | u658655325 | cpp |
p03038 | #define _CRT_SECURE_NO_WARNINGS
#include "bits/stdc++.h"
#define INF 1e9
#define INFLL 1e18
#define EPS 1e-9
#define MOD 1000000007
#define REP(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define REP1(i, n) for (ll i = 1, i##_len = (n); i <= i##_len; ++i)
#define REPR(i, n) for (ll i = (n)-1; i >= 0; --i)
#de... | #define _CRT_SECURE_NO_WARNINGS
#include "bits/stdc++.h"
#define INF 1e9
#define INFLL 1e18
#define EPS 1e-9
#define MOD 1000000007
#define REP(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define REP1(i, n) for (ll i = 1, i##_len = (n); i <= i##_len; ++i)
#define REPR(i, n) for (ll i = (n)-1; i >= 0; --i)
#de... | [
"variable_declaration.type.narrow.change"
] | 853,906 | 853,907 | u388817534 | cpp |
p03038 | #include <algorithm>
#include <stdio.h>
int main() {
int N, M;
scanf("%d %d", &N, &M);
int *a = new int[N];
for (int i = 0; i < N; i++) {
scanf("%d", &a[i]);
}
int *b = new int[M];
int *c = new int[M];
for (int i = 0; i < M; i++) {
scanf("%d %d", &b[i], &c[i]);
}
int *max = new int[N];
... | #include <algorithm>
#include <stdio.h>
int main() {
int N, M;
scanf("%d %d", &N, &M);
int *a = new int[N];
for (int i = 0; i < N; i++) {
scanf("%d", &a[i]);
}
int *b = new int[M];
int *c = new int[M];
for (int i = 0; i < M; i++) {
scanf("%d %d", &b[i], &c[i]);
}
int *max = new int[N];
... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 853,910 | 853,911 | u617987447 | cpp |
p03038 | #include <algorithm>
#include <stdio.h>
int main() {
int N, M;
scanf("%d %d", &N, &M);
int *a = new int[N];
for (int i = 0; i < N; i++) {
scanf("%d", &a[i]);
}
int *b = new int[M];
int *c = new int[M];
for (int i = 0; i < M; i++) {
scanf("%d %d", &b[i], &c[i]);
}
int *max = new int[N];
... | #include <algorithm>
#include <stdio.h>
int main() {
int N, M;
scanf("%d %d", &N, &M);
int *a = new int[N];
for (int i = 0; i < N; i++) {
scanf("%d", &a[i]);
}
int *b = new int[M];
int *c = new int[M];
for (int i = 0; i < M; i++) {
scanf("%d %d", &b[i], &c[i]);
}
int *max = new int[N];
... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 853,912 | 853,911 | u617987447 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
// Your code here!
int n, m, u = 0, p = 0;
long long ans = 0;
cin >> n >> m;
vector<long> a(n);
vector<pair<long, int>> b(m);
for (int i = 0; i < n; i++) {
cin >> a.at(i);
}
for (int i = 0; i < m; i++) {
cin >> b.at(i).second >> b.... | #include <bits/stdc++.h>
using namespace std;
int main(void) {
// Your code here!
int n, m, u = 0, p = 0;
long long ans = 0;
cin >> n >> m;
vector<long> a(n);
vector<pair<long, int>> b(m);
for (int i = 0; i < n; i++) {
cin >> a.at(i);
}
for (int i = 0; i < m; i++) {
cin >> b.at(i).second >> b.... | [
"control_flow.break.add"
] | 853,913 | 853,914 | u112775098 | cpp |
p03038 | #include "bits/stdc++.h"
using namespace std;
void solve(void) {
int n, m;
cin >> n >> m;
vector<pair<long, long>> ps;
for (int i = 0; i < n; i++) {
long a;
ps.push_back({a, 1});
}
while (m--) {
long b, c;
cin >> b >> c;
ps.push_back({c, b});
}
sort(ps.rbegin(), ps.rend());
long ... | #include "bits/stdc++.h"
using namespace std;
void solve(void) {
int n, m;
cin >> n >> m;
vector<pair<long, long>> ps;
for (int i = 0; i < n; i++) {
long a;
cin >> a;
ps.push_back({a, 1});
}
while (m--) {
long b, c;
cin >> b >> c;
ps.push_back({c, b});
}
sort(ps.rbegin(), ps.re... | [] | 853,933 | 853,934 | u344412812 | cpp |
p03038 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
ll N, M;
cin >> N >> M;
ll A[N];
for (int i = 0; i < N; i++) {
cin >> A[i];
}
sort(A, A + sizeof(A) / sizeof(ll));
pair<ll, ll> v[M];
ll temp1, temp2;
for (int i = 0; i < M; i++) {
cin >> temp1;
cin >> temp2;
... | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
ll N, M;
cin >> N >> M;
ll A[N];
for (int i = 0; i < N; i++) {
cin >> A[i];
}
sort(A, A + sizeof(A) / sizeof(ll));
pair<ll, ll> v[M];
ll temp1, temp2;
for (int i = 0; i < M; i++) {
cin >> temp1;
cin >> temp2;
... | [
"expression.unary.arithmetic.remove"
] | 853,952 | 853,953 | u778347695 | cpp |
p03038 | #include <bits/stdc++.h>
#define int long long
using namespace std;
using LL = long long;
using P = pair<int, int>;
#define FOR(i, a, n) for (int i = (int)(a); i < (int)(n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define pb(a) push_back(a)
#define all(x) (x).begin(), (x).end()
const int INF = (int)1e9;
const LL INFL =... | #include <bits/stdc++.h>
#define int long long
using namespace std;
using LL = long long;
using P = pair<int, int>;
#define FOR(i, a, n) for (int i = (int)(a); i < (int)(n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define pb(a) push_back(a)
#define all(x) (x).begin(), (x).end()
const int INF = (int)1e9;
const LL INFL =... | [
"control_flow.loop.condition.change",
"control_flow.loop.for.condition.change"
] | 853,954 | 853,955 | u544732702 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
int main() {
ll count = 0;
ll N, M;
cin >> N >> M;
vector<ll> A(N);
vector<pair<ll, ll>> vec(M, pair<ll, ll>());
for (ll i = 0; i < N; i++)
cin >> A.at(i);
for (ll i = 0; i < M; i++)
cin >> vec.at(i).second >> vec.at(i).fir... | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
int main() {
ll count = 0;
ll N, M;
cin >> N >> M;
vector<ll> A(N);
vector<pair<ll, ll>> vec(M, pair<ll, ll>());
for (ll i = 0; i < N; i++)
cin >> A.at(i);
for (ll i = 0; i < M; i++)
cin >> vec.at(i).second >> vec.at(i).fir... | [
"control_flow.loop.for.condition.change"
] | 853,958 | 853,959 | u889812821 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
int main() {
ll count = 0;
ll N, M;
cin >> N >> M;
vector<ll> A(N);
vector<pair<ll, ll>> vec(M, pair<ll, ll>());
for (ll i = 0; i < N; i++)
cin >> A.at(i);
for (ll i = 0; i < M; i++)
cin >> vec.at(i).second >> vec.at(i).fir... | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
int main() {
ll count = 0;
ll N, M;
cin >> N >> M;
vector<ll> A(N);
vector<pair<ll, ll>> vec(M, pair<ll, ll>());
for (ll i = 0; i < N; i++)
cin >> A.at(i);
for (ll i = 0; i < M; i++)
cin >> vec.at(i).second >> vec.at(i).fir... | [
"control_flow.loop.for.condition.change"
] | 853,960 | 853,959 | u889812821 | cpp |
p03038 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string.h>
#include <vector>
#define REP(i, n) for (int i = 0; (i) < (n); ++(i))
#define FOR(i, n) for (int i = 1; (i) <= (n); ++(i))
#define dump(x... | #include <algorithm>
#include <cassert>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string.h>
#include <vector>
#define REP(i, n) for (int i = 0; (i) < (n); ++(i))
#define FOR(i, n) for (int i = 1; (i) <= (n); ++(i))
#define dump(x... | [
"control_flow.branch.if.condition.change"
] | 853,961 | 853,962 | u697232864 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
#define INT(a) scanf("%d", &a)
#define STR(a) scanf("%s", a)
#define DBL(a) scanf("%lf", &a)
#define LNG(a) scanf("%lld", &a)
#define PI acos(-1)
#define ff first
#define ss second
int b[100005], c[100005];
int main() {
int n, m;
cin >> n >> m;
vector<int> num;
for ... | #include <bits/stdc++.h>
using namespace std;
#define INT(a) scanf("%d", &a)
#define STR(a) scanf("%s", a)
#define DBL(a) scanf("%lf", &a)
#define LNG(a) scanf("%lld", &a)
#define PI acos(-1)
#define ff first
#define ss second
int b[100005], c[100005];
int main() {
int n, m;
cin >> n >> m;
vector<int> num;
for ... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 853,967 | 853,968 | u402651318 | cpp |
p03038 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define int long long
#define pie 3.141592653589793238462... | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define int long long
#define pie 3.141592653589793238462... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 853,971 | 853,970 | u277153875 | cpp |
p03038 | // Bismillahir rahmanir rahim
#include <bits/stdc++.h>
#define ll long long
#define eps 0.000000001
using namespace std;
int arr[100005];
bool cmp(pair<ll, ll> a, pair<ll, ll> b) {
if (a.second < b.second)
return a.second > b.second;
if (a.second == b.second)
return a.first > b.first;
}
int main() { // f... | // Bismillahir rahmanir rahim
#include <bits/stdc++.h>
#define ll long long
#define eps 0.000000001
using namespace std;
int arr[100005];
bool cmp(pair<ll, ll> a, pair<ll, ll> b) {
if (a.second < b.second)
return a.second > b.second;
if (a.second == b.second)
return a.first > b.first;
else
return tr... | [
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add",
"control_flow.return.add"
] | 853,978 | 853,979 | u841576231 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
#define INF 1000000007
#define LINF 1000000000000000007
typedef long long i64;
typedef pair<i64, i64> P;
i64 n, m, a[101010];
P p[101010];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
cin >> p[i]... | #include <bits/stdc++.h>
using namespace std;
#define INF 1000000007
#define LINF 1000000000000000007
typedef long long i64;
typedef pair<i64, i64> P;
i64 n, m, a[101010];
P p[101010];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
cin >> p[i]... | [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 853,984 | 853,985 | u414947284 | cpp |
p03038 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define mind(a, b) (a > b ? b : a)
#define ma... | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define mind(a, b) (a > b ? b : a)
#define ma... | [
"assignment.value.change"
] | 853,990 | 853,991 | u226155577 | cpp |
p03038 | /**
* Dont raise your voice, improve your argument.
* --Desmond Tutu
*/
#include <bits/stdc++.h>
using namespace std;
typedef unsigned int uint;
typedef long long ll;
#define fori(n) for (ll i = 0; i < (n); i++)
#define forn(i, n) for (ll i = 0; i < (n); i++)
#define forn3(i, x, n) for (ll i = (x); i < (n); i++)
... | /**
* Dont raise your voice, improve your argument.
* --Desmond Tutu
*/
#include <bits/stdc++.h>
using namespace std;
typedef unsigned int uint;
typedef long long ll;
#define fori(n) for (ll i = 0; i < (n); i++)
#define forn(i, n) for (ll i = 0; i < (n); i++)
#define forn3(i, x, n) for (ll i = (x); i < (n); i++)
... | [
"control_flow.loop.condition.change"
] | 853,994 | 853,995 | u014617387 | cpp |
p03038 | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define int long long
typedef pair<int, in... | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define int long long
typedef pair<int, in... | [
"assignment.add"
] | 853,998 | 853,999 | u384299515 | cpp |
p03038 | #include <algorithm>
#include <assert.h>
#include <cstring>
#include <iterator>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#pragma warning(disable : 4996)
typedef long long ll;
#define MIN(a, b) ((a) > (b) ... | #include <algorithm>
#include <assert.h>
#include <cstring>
#include <iterator>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#pragma warning(disable : 4996)
typedef long long ll;
#define MIN(a, b) ((a) > (b) ... | [
"type_conversion.add"
] | 854,012 | 854,013 | u209713918 | cpp |
p03038 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#inc... | #define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#inc... | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 854,022 | 854,023 | u112723190 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int i = 0; i < (int)N; i++)
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N, 0), B(M, 0), C(M, 0);
rep(i, N) cin >> A.at(i);
rep(i, M) cin >> B.at(i) >> C.at(i);
priority_queue<pair<int, int>> q;
rep(i, N) q.push(make_pair(A.at... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int i = 0; i < (int)N; i++)
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N, 0), B(M, 0), C(M, 0);
rep(i, N) cin >> A.at(i);
rep(i, M) cin >> B.at(i) >> C.at(i);
priority_queue<pair<int, int>> q;
rep(i, N) q.push(make_pair(A.at... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 854,072 | 854,073 | u768327203 | cpp |
p03038 | #include <algorithm>
#include <iostream>
#include <map>
#include <numeric>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
// for(int i = 0; i < n; i++) cout << a[i] << " ";
// ... | #include <algorithm>
#include <iostream>
#include <map>
#include <numeric>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
// for(int i = 0; i < n; i++) cout << a[i] << " ";
// ... | [
"variable_declaration.type.widen.change"
] | 854,078 | 854,079 | u927804708 | cpp |
p03038 | #include <algorithm>
#include <cstdio>
#include <vector>
int main() {
std::vector<std::pair<int, int>> vec;
int N, M, A, B, C;
scanf("%d %d", &N, &M);
for (int i = 0; i < N; i++) {
scanf("%d", &A);
vec.push_back(std::make_pair(A, 1));
}
for (int i = 0; i < M; i++) {
scanf("%d %d", &B, &C);
... | #include <algorithm>
#include <cstdio>
#include <vector>
int main() {
std::vector<std::pair<int, int>> vec;
int N, M, A, B, C;
scanf("%d %d", &N, &M);
for (int i = 0; i < N; i++) {
scanf("%d", &A);
vec.push_back(std::make_pair(A, 1));
}
for (int i = 0; i < M; i++) {
scanf("%d %d", &B, &C);
... | [
"type_conversion.add"
] | 854,104 | 854,105 | u023077142 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) rep(i, 0, n)
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> all;
REP(i, n) {
int a;
cin >> a;
all.push_back(make_pair(a, 1));
}
REP(i, m) {
int b, c;
cin ... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) rep(i, 0, n)
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> all;
REP(i, n) {
int a;
cin >> a;
all.push_back(make_pair(a, 1));
}
REP(i, m) {
int b, c;
cin ... | [
"variable_declaration.type.primitive.change"
] | 854,106 | 854,107 | u973991908 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, a, b) for (int i = (a); i >= (b); i--)
#define REP(i, n) rep(i, 0, n)
#define RREP(i, n) rrep(i, n, 0)
int main() {
int n, m;
cin >> n >> m;
// cout<<endl;
vector<pair<int, int>> all;
REP(i, n... | /*
*/
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, a, b) for (int i = (a); i >= (b); i--)
#define REP(i, n) rep(i, 0, n)
#define RREP(i, n) rrep(i, n, 0)
int main() {
int n, m;
cin >> n >> m;
// cout<<endl;
vector<pair<int, int>> all;
... | [
"variable_declaration.type.primitive.change"
] | 854,108 | 854,109 | u973991908 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> i_i;
typedef pair<ll, ll> l_l;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
// const ll mod = 1000000007;
int n, m;
ll a[100001], b[100001], c[100001];
l_l cb[100001];
ll ans;
int main() {
cin >> n >> m;
fo... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> i_i;
typedef pair<ll, ll> l_l;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
// const ll mod = 1000000007;
int n, m;
ll a[100001], b[100001], c[100001];
l_l cb[100001];
ll ans;
int main() {
cin >> n >> m;
fo... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 854,110 | 854,111 | u263858205 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> i_i;
typedef pair<ll, ll> l_l;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
// const ll mod = 1000000007;
int n, m;
ll a[100001], b[100001], c[100001];
l_l cb[100001];
ll ans;
int main() {
cin >> n >> m;
fo... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> i_i;
typedef pair<ll, ll> l_l;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
// const ll mod = 1000000007;
int n, m;
ll a[100001], b[100001], c[100001];
l_l cb[100001];
ll ans;
int main() {
cin >> n >> m;
fo... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 854,112 | 854,111 | u263858205 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.