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 |
|---|---|---|---|---|---|---|---|
p03040 | #include <bits/stdc++.h>
using namespace std;
using ll = int_fast64_t;
using ld = long double;
using pll = pair<ll, ll>;
using pld = pair<ld, ld>;
const ll INF = 1LL << 60;
void solve();
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
solve();
}
#define foreach(i, a) for... | #include <bits/stdc++.h>
using namespace std;
using ll = int_fast64_t;
using ld = long double;
using pll = pair<ll, ll>;
using pld = pair<ld, ld>;
const ll INF = 1LL << 60;
void solve();
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
solve();
}
#define foreach(i, a) for... | [
"control_flow.branch.if.condition.change"
] | 854,826 | 854,827 | u440566786 | cpp |
p03040 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
const ll MOD = 10000000... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
const ll MOD = 10000000... | [
"expression.operator.change"
] | 854,828 | 854,829 | u334624175 | cpp |
p03040 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
const ll MOD = 10000000... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
const ll MOD = 10000000... | [
"expression.operator.change",
"literal.string.change",
"io.output.change"
] | 854,830 | 854,829 | u334624175 | cpp |
p03040 | #include <bits/stdc++.h>
#define rep(i, n, m) for (int i = (n); i < (m); i++)
#define rrep(i, n, m) for (int i = (n)-1; i >= (m); i--)
using namespace std;
using ll = long long;
int main() {
int q;
ll b_sum = 0;
cin >> q;
vector<ll> a_list;
priority_queue<ll, vector<ll>, greater<ll>> left_que;
priority_qu... | #include <bits/stdc++.h>
#define rep(i, n, m) for (int i = (n); i < (m); i++)
#define rrep(i, n, m) for (int i = (n)-1; i >= (m); i--)
using namespace std;
using ll = long long;
int main() {
int q;
ll b_sum = 0;
cin >> q;
vector<ll> a_list;
priority_queue<ll, vector<ll>, less<ll>> left_que;
priority_queue... | [] | 854,831 | 854,832 | u052247353 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
const ll INF = 1LL << 60;
const int INF32 = 1 << 29;
const int MOD = 1000000007;
// const int MOD = 998244353;
// Lib
//
struct FloatingMedian {
priority_queue<ll> zen;
priority_queue<ll, vector<ll>, greater<ll>> kou;
... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
const ll INF = 1LL << 60;
const int INF32 = 1 << 29;
const int MOD = 1000000007;
// const int MOD = 998244353;
// Lib
//
struct FloatingMedian {
priority_queue<ll> zen;
priority_queue<ll, vector<ll>, greater<ll>> kou;
... | [
"variable_declaration.type.narrow.change",
"identifier.change",
"call.arguments.change"
] | 854,833 | 854,834 | u335667012 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
int main() {
int Q;
cin >> Q;
i64 mid = 0, left_sum = 0, right_sum = 0, b_sum = 0;
priority_queue<i64> left;
priority_queue<i64, vector<i64>, greater<i64>> right;
i64 q, a, b;
cin >> q >> a >> b;
b_sum += b;
mid = a;
bool flag = tr... | #include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
int main() {
int Q;
cin >> Q;
i64 mid = 0, left_sum = 0, right_sum = 0, b_sum = 0;
priority_queue<i64> left;
priority_queue<i64, vector<i64>, greater<i64>> right;
i64 q, a, b;
cin >> q >> a >> b;
b_sum += b;
mid = a;
bool flag = tr... | [
"expression.operation.binary.add"
] | 854,835 | 854,836 | u823112986 | cpp |
p03040 | #include <bits/stdc++.h>
namespace BST {
template <typename T> struct Node {
Node *lch, *rch;
T val;
T pri;
T sum;
int cnt;
Node() {}
Node(T val, T pri)
: lch(nullptr), rch(nullptr), val(val), pri(pri), sum(val), cnt(1) {}
};
template <typename T> struct NodePool {
std::vector<Node<T>> v;
std... | #include <bits/stdc++.h>
namespace BST {
template <typename T> struct Node {
Node *lch, *rch;
T val;
T pri;
T sum;
int cnt;
Node() {}
Node(T val, T pri)
: lch(nullptr), rch(nullptr), val(val), pri(pri), sum(val), cnt(1) {}
};
template <typename T> struct NodePool {
std::vector<Node<T>> v;
std... | [] | 854,839 | 854,840 | u876875284 | cpp |
p03040 | #include <algorithm>
#include <bitset>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>
#define range(i, r) for (int i = 0; i < r; i++)
#define ranges(i, l, r) for (int i = l; i < r; i++)
#define vv(a, b, c, d) vector<vector<d>>(a, ... | #include <algorithm>
#include <bitset>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>
#define range(i, r) for (int i = 0; i < r; i++)
#define ranges(i, l, r) for (int i = l; i < r; i++)
#define vv(a, b, c, d) vector<vector<d>>(a, ... | [
"call.arguments.change"
] | 854,846 | 854,847 | u816587940 | cpp |
p03040 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = (0); i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int Q;
cin >> Q;
ll sm = 0;
priority_queue<ll> mpq;
priority_queue<ll, vector<ll>, greater<ll>> ppq;
ll msm = 0;
ll psm = 0;... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = (0); i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int Q;
cin >> Q;
ll sm = 0;
priority_queue<ll> mpq;
priority_queue<ll, vector<ll>, greater<ll>> ppq;
ll msm = 0;
ll psm = 0;... | [
"call.function.change",
"assignment.variable.change",
"identifier.change",
"expression.operation.binary.change"
] | 854,852 | 854,853 | u755830696 | cpp |
p03040 | #include <iostream>
#include <set>
using namespace std;
int main() {
int q;
cin >> q;
long A = 0, B = 0;
multiset<int> ls, rs;
while (q--) {
int flag;
cin >> flag;
flag--;
if (flag) {
cout << *ls.rbegin() << ' ' << A + B << endl;
} else {
int a, b;
cin >> a >> b;
... | #include <iostream>
#include <set>
using namespace std;
int main() {
int q;
cin >> q;
long A = 0, B = 0;
multiset<int> ls, rs;
while (q--) {
int flag;
cin >> flag;
flag--;
if (flag) {
cout << *ls.rbegin() << ' ' << A + B << endl;
} else {
int a, b;
cin >> a >> b;
... | [
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 854,854 | 854,855 | u687548330 | cpp |
p03040 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <iterator>
#include <map>
#include <set>
#include <vector>
#define llint long long int
int main(void) {
int q;
std::cin >> q;
std::multiset<llint> lower;
std::multiset<llint> upper;
llint center = 1e12;
llint a_distance = 0;
llint b_tot... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <iterator>
#include <map>
#include <set>
#include <vector>
#define llint long long int
int main(void) {
int q;
std::cin >> q;
std::multiset<llint> lower;
std::multiset<llint> upper;
llint center = 1e12;
llint a_distance = 0;
llint b_tot... | [
"expression.operation.binary.remove",
"assignment.change"
] | 854,857 | 854,858 | u679906187 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
int q, t, a, b;
ll ans;
priority_queue<int> low;
priority_queue<int, vector<int>, greater<int>> high;
int main() {
scanf("%d%d%d%d", &q, &t, &a, &b);
ans += b;
low.push(a);
for (int i = 0; i < q; i++) {
scanf("%d", &t);
if (t == 1)... | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
int q, t, a, b;
ll ans;
priority_queue<int> low;
priority_queue<int, vector<int>, greater<int>> high;
int main() {
scanf("%d%d%d%d", &q, &t, &a, &b);
ans += b;
low.push(a);
for (int i = 0; i < q - 1; i++) {
scanf("%d", &t);
if (t =... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 854,861 | 854,862 | u309985845 | cpp |
p03040 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII... | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 854,863 | 854,864 | u007610006 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
#define LL long long
#define N 200010
multiset<int> p, q;
multiset<int>::iterator it1, it2;
int main() {
int i, j, k, t, x, y, d;
LL ans, s, s1, s2;
scanf("%d", &t);
s = 0;
s1 = 0;
s2 = 0;
d = 0;
while (t--) {
scanf("%d", &k);
if (k == 1) {
sca... | #include <bits/stdc++.h>
using namespace std;
#define LL long long
#define N 200010
multiset<int> p, q;
multiset<int>::iterator it1, it2;
int main() {
int i, j, k, t, x, y, d;
LL ans, s, s1, s2;
scanf("%d", &t);
s = 0;
s1 = 0;
s2 = 0;
d = 0;
while (t--) {
scanf("%d", &k);
if (k == 1) {
sca... | [
"call.function.change"
] | 854,865 | 854,866 | u189237887 | cpp |
p03040 | #include <cstdio>
#include <set>
int main() {
int q;
scanf("%d", &q);
long long b_sum = 0;
int n = 0;
std::multiset<int> l, r;
long long l_sum, r_sum;
int median = 0;
for (int i = 0; i < q; i++) {
int t;
scanf("%d", &t);
if (t == 1) {
int a, b;
scanf("%d %d", &a, &b);
b_su... | #include <cstdio>
#include <set>
int main() {
int q;
scanf("%d", &q);
long long b_sum = 0;
int n = 0;
std::multiset<int> l, r;
long long l_sum = 0, r_sum = 0;
int median = 0;
for (int i = 0; i < q; i++) {
int t;
scanf("%d", &t);
if (t == 1) {
int a, b;
scanf("%d %d", &a, &b);
... | [
"variable_declaration.value.change"
] | 854,867 | 854,868 | u138454574 | cpp |
p03040 | #include <algorithm>
#include <cstdlib>
#include <stdio.h>
#include <vector>
using namespace std;
int main(void) {
// Your code here!
long Q;
scanf("%ld", &Q);
std::vector<long> A{0};
long x;
scanf("%ld", &x);
scanf("%ld", &A[0]);
long B;
scanf("%ld", &B);
long min = 0;
long l = 1;
for (long i =... | #include <algorithm>
#include <cstdlib>
#include <stdio.h>
#include <vector>
using namespace std;
int main(void) {
// Your code here!
long Q;
scanf("%ld", &Q);
std::vector<long> A{0};
long x;
scanf("%ld", &x);
scanf("%ld", &A[0]);
long B;
scanf("%ld", &B);
long min = 0;
long l = 1;
for (long i =... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 854,876 | 854,877 | u377265351 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
// repetition
#define FOR(i, a, b) for (ll i = (a); i < (b); ++i)
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
// container util
#define all(x) (x).begin(), (x).end()
// typedef
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<ll... | #include <bits/stdc++.h>
using namespace std;
// repetition
#define FOR(i, a, b) for (ll i = (a); i < (b); ++i)
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
// container util
#define all(x) (x).begin(), (x).end()
// typedef
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<ll... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"call.add"
] | 854,878 | 854,879 | u336011173 | cpp |
p03040 | #include <cmath>
#include <functional>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
typedef long long ll;
int Q;
ll B = 0;
priority_queue<ll> ls;
priority_queue<ll, vector<ll>, greater<ll>> rs;
ll ans = 0;
ll anspos = 0;
int main() {
cin >> Q;
for (int i = 0; i < Q; i++) {
i... | #include <cmath>
#include <functional>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
typedef long long ll;
int Q;
ll B = 0;
priority_queue<ll> ls;
priority_queue<ll, vector<ll>, greater<ll>> rs;
ll ans = 0;
ll anspos = 0;
int main() {
cin >> Q;
for (int i = 0; i < Q; i++) {
i... | [
"assignment.value.change",
"identifier.change"
] | 854,894 | 854,895 | u107077805 | cpp |
p03040 | #include <cmath>
#include <functional>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
typedef long long ll;
int Q;
ll B = 0;
priority_queue<ll> ls;
priority_queue<ll, vector<ll>, greater<ll>> rs;
ll ans = 0;
ll anspos = 0;
int main() {
cin >> Q;
for (int i = 0; i < Q; i++) {
i... | #include <cmath>
#include <functional>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
typedef long long ll;
int Q;
ll B = 0;
priority_queue<ll> ls;
priority_queue<ll, vector<ll>, greater<ll>> rs;
ll ans = 0;
ll anspos = 0;
int main() {
cin >> Q;
for (int i = 0; i < Q; i++) {
i... | [
"assignment.add"
] | 854,896 | 854,895 | u107077805 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define fi first
#define se second
#define pb push_back
#define all(v) (v).begin(), (v).end()
ll mod = 1000000007;
ll INF = 1000000099;
signed main() {
ll q, ans = 0;
cin >> q;
ll b = 0;
bool f = true;
ll mid = 0, mit = 0, l = 0, r = 0;
;
... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define fi first
#define se second
#define pb push_back
#define all(v) (v).begin(), (v).end()
ll mod = 1000000007;
ll INF = 1000000099;
signed main() {
ll q, ans = 0;
cin >> q;
ll b = 0;
bool f = true;
ll mid = 0, mit = 0, l = 0, r = 0;
;
... | [] | 854,904 | 854,905 | u317711717 | cpp |
p03040 | #include <set>
#include <stdio.h>
using namespace std;
int main() {
int qq;
scanf("%d", &qq);
qq--;
int tf, xf, sampahf;
scanf("%d %d %d", &tf, &xf, &sampahf);
multiset<int> left, right;
long long val = 0, left_sum = xf, right_sum = 0, b = sampahf;
left.insert(xf);
while (qq--) {
int t;
scanf... | #include <set>
#include <stdio.h>
using namespace std;
int main() {
int qq;
scanf("%d", &qq);
qq--;
int tf, xf, sampahf;
scanf("%d %d %d", &tf, &xf, &sampahf);
multiset<int> left, right;
long long val = 0, left_sum = xf, right_sum = 0, b = sampahf;
left.insert(xf);
while (qq--) {
int t;
scanf... | [
"assignment.value.change",
"identifier.change"
] | 854,908 | 854,909 | u153798346 | cpp |
p03040 | #include <set>
#include <stdio.h>
using namespace std;
int main() {
int qq;
scanf("%d", &qq);
qq--;
int tf, xf, sampahf;
scanf("%d %d %d", &tf, &xf, &sampahf);
multiset<int> left, right;
long long val = 0, left_sum = xf, right_sum = 0, b = sampahf;
left.insert(xf);
while (qq--) {
int t;
scanf... | #include <set>
#include <stdio.h>
using namespace std;
int main() {
int qq;
scanf("%d", &qq);
qq--;
int tf, xf, sampahf;
scanf("%d %d %d", &tf, &xf, &sampahf);
multiset<int> left, right;
long long val = 0, left_sum = xf, right_sum = 0, b = sampahf;
left.insert(xf);
while (qq--) {
int t;
scanf... | [
"call.function.change",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"identifier.change"
] | 854,910 | 854,909 | u153798346 | cpp |
p03040 | //
// main.cpp
// absolute minima
//
// Created by Dong Truong on 5/28/19.
// Copyright © 2019 Dong Truong. All rights reserved.
//
#include <fstream>
#include <iostream>
#include <queue>
#include <stdio.h>
using namespace std;
#define maxn 1000001
int q, kq;
priority_queue<int, vector<int>, greater<int>> r;
pri... | //
// main.cpp
// absolute minima
//
// Created by Dong Truong on 5/28/19.
// Copyright © 2019 Dong Truong. All rights reserved.
//
#include <fstream>
#include <iostream>
#include <queue>
#include <stdio.h>
using namespace std;
#define maxn 1000001
int q;
int64_t kq;
priority_queue<int, vector<int>, greater<int>... | [
"variable_declaration.type.change"
] | 854,913 | 854,914 | u293313826 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
priority_queue<long long, vector<long long>, greater<long long>> q2; //后半部分
priority_queue<long long, vector<long long>, less<long long>> q1; //前半部分
long long sum1, sum2; // qian hou
int main() {
long long sum1 = 0, sum2 = 0;
... | #include <bits/stdc++.h>
using namespace std;
priority_queue<long long, vector<long long>, greater<long long>> q2; //后半部分
priority_queue<long long, vector<long long>, less<long long>> q1; //前半部分
long long sum1, sum2; // qian hou
int main() {
long long sum1 = 0, sum2 = 0;
... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"identifier.change"
] | 854,915 | 854,916 | u818518063 | cpp |
p03040 | #include <algorithm>
#include <cassert>
#include <cstdint>
#include <cstdio>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
template <class Tp, class BinaryOperation1, class BinaryOperation2>
class segment_tree {
public:
using binary_operation... | #include <algorithm>
#include <cassert>
#include <cstdint>
#include <cstdio>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
template <class Tp, class BinaryOperation1, class BinaryOperation2>
class segment_tree {
public:
using binary_operation... | [] | 854,920 | 854,921 | u352499693 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-')
f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - 48;
ch = getchar();
}
return x * f;
}
int main() {
i... | #include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-')
f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - 48;
ch = getchar();
}
return x * f;
}
int main() {
i... | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 854,922 | 854,923 | u855248478 | cpp |
p03040 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
constexpr ll MOD = 1000000007LL;
int main(void) {
ll b;
multiset<ll> a1, a2;
int Q;
cin >> Q;
ll ans = 0LL;
for (int ... | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
constexpr ll MOD = 1000000007LL;
int main(void) {
ll b = 0LL;
multiset<ll> a1, a2;
int Q;
cin >> Q;
ll ans = 0LL;
for... | [
"variable_declaration.value.change"
] | 854,926 | 854,927 | u677149117 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
#define se second
#define fi first
#define mk(a, b) make_pair(a, b)
typedef pair<int, int> pii;
typedef long long ll;
int N;
set<pii> st;
set<pii>::iterator ite;
ll A, B = 0;
int main() {
cin >> N;
for (int i = 1; i <= N; i++) {
int k;
cin >> k;
if (k ==... | #include <bits/stdc++.h>
using namespace std;
#define se second
#define fi first
#define mk(a, b) make_pair(a, b)
typedef pair<int, int> pii;
typedef long long ll;
int N;
set<pii> st;
set<pii>::iterator ite;
ll A, B = 0;
int main() {
cin >> N;
for (int i = 1; i <= N; i++) {
int k;
cin >> k;
if (k ==... | [
"expression.operator.change"
] | 854,932 | 854,933 | u205655980 | cpp |
p03040 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
class segtree {
public:
int depth; //セグ木の深さ(最上部が0）
int size;
vector<int> node; //セグ木本体
//コンストラクタ
segtree(int n) {... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
class segtree {
public:
int depth; //セグ木の深さ(最上部が0）
int size;
vector<int> node; //セグ木本体
//コンストラクタ
segtree(int n) {... | [
"variable_declaration.type.change"
] | 854,934 | 854,935 | u863507492 | cpp |
p03040 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
class segtree {
public:
int depth; //セグ木の深さ(最上部が0）
int size;
vector<int> node; //セグ木本体
//コンストラクタ
segtree(int n) {... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
class segtree {
public:
int depth; //セグ木の深さ(最上部が0）
int size;
vector<int> node; //セグ木本体
//コンストラクタ
segtree(int n) {... | [
"variable_declaration.type.change"
] | 854,936 | 854,935 | u863507492 | cpp |
p03040 | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string... | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string... | [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 854,937 | 854,938 | u862095327 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll Q, a, b, j, x = -1, acnt = 0, bcnt = 0;
cin >> Q;
multiset<ll> qr;
auto mid = qr.end();
for (ll i = 0; i < Q; i++) {
cin >> j;
if (j - 2) {
x++;
cin >> a >> b;
bcnt += b;
qr.insert(a);
if ... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll Q, a, b, j, x = -1, acnt = 0, bcnt = 0;
cin >> Q;
multiset<ll> qr;
auto mid = qr.end();
for (ll i = 0; i < Q; i++) {
cin >> j;
if (j - 2) {
x++;
cin >> a >> b;
bcnt += b;
qr.insert(a);
if ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 854,941 | 854,940 | u045811375 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll Q, a, b, j, x = -1, acnt = 0, bcnt = 0;
cin >> Q;
multiset<ll> qr;
auto mid = qr.end();
for (ll i = 0; i < Q; i++) {
cin >> j;
if (j - 2) {
x++;
cin >> a >> b;
bcnt += b;
qr.insert(a);
if ... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll Q, a, b, j, x = -1, acnt = 0, bcnt = 0;
cin >> Q;
multiset<ll> qr;
auto mid = qr.end();
for (ll i = 0; i < Q; i++) {
cin >> j;
if (j - 2) {
x++;
cin >> a >> b;
bcnt += b;
qr.insert(a);
if ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 854,942 | 854,940 | u045811375 | cpp |
p03040 |
//#pragma GCC optimize ("-O3")
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
... |
//#pragma GCC optimize ("-O3")
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
... | [
"assignment.variable.change",
"identifier.change"
] | 854,945 | 854,946 | u304121198 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vll = vector<ll>;
using vvi = vector<vector<int>>;
using vvl = vector<vector<ll>>;
class BIT {
public:
int n;
vector<int> bit;
BIT(int n_) {
n = 1;
while (n < n_) {
n <<= 1;
}
bit.resize(n +... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vll = vector<ll>;
using vvi = vector<vector<int>>;
using vvl = vector<vector<ll>>;
class BIT {
public:
int n;
vector<int> bit;
BIT(int n_) {
n = 1;
while (n < n_) {
n <<= 1;
}
bit.resize(n +... | [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change",
"assignment.variable.change"
] | 854,949 | 854,950 | u656572785 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e5 + 5;
int q, ans1, tot = 0, hs[N];
ll sum, s, sum1, sum2, si1, si2, t[N * 4], si[N * 4];
int opt[N], x[N], y[N];
void fix(int l, int r, int k, int x) {
if (l == r) {
t[k] += hs[l];
si[k]++;
return;
}
int m = l + r >> ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e5 + 5;
int q, ans1, tot = 0, hs[N];
ll sum, s, sum1, sum2, si1, si2, t[N * 4], si[N * 4];
int opt[N], x[N], y[N];
void fix(int l, int r, int k, int x) {
if (l == r) {
t[k] += hs[l];
si[k]++;
return;
}
int m = l + r >> ... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 854,951 | 854,952 | u676323984 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n)-1; i >= 0; i--)
typedef long long LL;
int N;
LL MOD = 1e9 + 7;
vector<int> v;
pr... | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n)-1; i >= 0; i--)
typedef long long LL;
int N;
LL MOD = 1e9 + 7;
vector<int> v;
pr... | [
"identifier.change"
] | 854,953 | 854,954 | u723297297 | cpp |
p03040 | // Created by sz
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int q;
using ll = long long;
ll sum1 = 0, sum2 = 0;
priority_queue<int, vector<int>, greater<int>>
min_heap; // keeps larger than median
priority_queue<int> max_heap; // keeps smaller than median
void add(int a... | // Created by sz
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int q;
using ll = long long;
ll sum1 = 0, sum2 = 0;
priority_queue<int, vector<int>, greater<int>>
min_heap; // keeps larger than median
priority_queue<int> max_heap; // keeps smaller than median
void add(int a... | [
"variable_declaration.value.change"
] | 854,963 | 854,964 | u041075929 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
#define li long long int
#define rep(i, to) for (li i = 0; i < ((li)(to)); i++)
#define repp(i, start, to) for (li i = (li)(start); i < ((li)(to)); i++)
#define pb push_back
#define sz(v) ((li)(v).size())
#define bgn(v) ((v).begin())
#define eend(v) ((v).end())
#define all... | #include <bits/stdc++.h>
using namespace std;
#define li long long int
#define rep(i, to) for (li i = 0; i < ((li)(to)); i++)
#define repp(i, start, to) for (li i = (li)(start); i < ((li)(to)); i++)
#define pb push_back
#define sz(v) ((li)(v).size())
#define bgn(v) ((v).begin())
#define eend(v) ((v).end())
#define all... | [
"control_flow.branch.if.condition.change"
] | 854,969 | 854,970 | u962966398 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1e18;
int main() {
int q;
cin >> q;
ll s0 = 0, s1 = 0;
priority_queue<ll> left;
priority_queue<ll, vector<ll>, greater<>> right;
left.push(-INF);
right.push(INF);
for (int i = 0; i < q; i++) {
int que;
cin >> q... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1e18;
int main() {
int q;
cin >> q;
ll s0 = 0, s1 = 0;
priority_queue<ll> left;
priority_queue<ll, vector<ll>, greater<>> right;
left.push(-INF);
right.push(INF);
for (int i = 0; i < q; i++) {
int que;
cin >> q... | [
"call.arguments.add",
"call.add",
"call.arguments.change"
] | 854,978 | 854,979 | u853947407 | cpp |
p03040 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#pragma region
using namespace std;
#define FOR(i, r, n) fo... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#pragma region
using namespace std;
#define FOR(i, r, n) fo... | [
"misc.opposites",
"control_flow.branch.if.condition.change"
] | 854,982 | 854,983 | u215122692 | cpp |
p03040 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < (n); i++)
#define INF ((long long)1e18)
#define MOD ((int)1e9 + 7)
#define endl "\n"
#define yn(f) ((f) ? ... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < (n); i++)
#define INF ((long long)1e18)
#define MOD ((int)1e9 + 7)
#define endl "\n"
#define yn(f) ((f) ? ... | [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 854,984 | 854,985 | u233393801 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
typedef pair<ll, P> P3;
typedef pair<P, P> PP;
const ll MOD = ll(1e9) + 7;
const int IINF = INT_MAX;
const ll LLINF = LLONG_MAX;
const int MAX_N = int(1e5 + 5);
const double EPS = 1e-6;
const int ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
typedef pair<ll, P> P3;
typedef pair<P, P> PP;
const ll MOD = ll(1e9) + 7;
const int IINF = INT_MAX;
const ll LLINF = LLONG_MAX;
const int MAX_N = int(1e5 + 5);
const double EPS = 1e-6;
const int ... | [
"identifier.change",
"call.arguments.change",
"io.output.change",
"call.add"
] | 854,991 | 854,990 | u271063202 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define start_routine() int begtime = clock();
#def... | #include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define start_routine() int begtime = clock();
#def... | [] | 854,996 | 854,997 | u851993789 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
int Q;
int main() {
set<pii> st;
ll sumb = 0;
ll funa = 0;
pii cent = pii(0, 0);
cin >> Q;
for (int q = 0; q < Q; q++) {
int num, a, b;
cin >> num;
if (num == 1) {
cin >> a >> b;
sumb ... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
int Q;
int main() {
set<pii> st;
ll sumb = 0;
ll funa = 0;
pii cent = pii(0, 0);
cin >> Q;
for (int q = 0; q < Q; q++) {
int num, a, b;
cin >> num;
if (num == 1) {
cin >> a >> b;
sumb ... | [
"expression.operator.change"
] | 855,004 | 855,005 | u489053642 | cpp |
p03040 | #if 1
#include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define int long lon... | #if 1
#include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define int long lon... | [
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove"
] | 855,009 | 855,010 | u154068540 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
int main() {
int Q;
cin >> Q;
long long ans = 0;
int a = 0;
vector<long long> ans1;
vector<long long> ans2;
priority_queue<long long> que1;
priority_queue<long long, vector<long long>, greater<long long>> que2;
for (int q = 0; q < Q; q++) {
int c;
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int Q;
cin >> Q;
long long ans = 0;
int a = 0;
vector<long long> ans1;
vector<long long> ans2;
priority_queue<long long> que1;
priority_queue<long long, vector<long long>, greater<long long>> que2;
for (int q = 0; q < Q; q++) {
int c;
... | [
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove"
] | 855,015 | 855,016 | u573082373 | cpp |
p03040 | #include <bits/stdc++.h>
#define ll long long
#define fornum(A, B, C) for (A = B; A < C; A++)
#define mp make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
using namespace std;
/////////////////////////////////////////////////////
#define INF 1e15
ll Q;
ll f, x, xa, bb, al, ah;
ll i, j, k, l;
vector<ll> a... | #include <bits/stdc++.h>
#define ll long long
#define fornum(A, B, C) for (A = B; A < C; A++)
#define mp make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
using namespace std;
/////////////////////////////////////////////////////
#define INF 1e15
ll Q;
ll f, x, xa, bb, al, ah;
ll i, j, k, l;
vector<ll> a... | [
"expression.operation.binary.remove",
"assignment.change"
] | 855,017 | 855,018 | u259396003 | cpp |
p03040 | #include <algorithm>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include... | #include <algorithm>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include... | [
"call.remove",
"identifier.change",
"call.add"
] | 855,029 | 855,030 | u628047647 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<pii, int> ppii;
typedef pair<int, pii> pipi;
typedef pair<ll, ll> pll;
typedef pair<ll, pll> plpl;
typedef tuple<ll, ll, ll> tl;
ll mod = 1000000007;
ll mod2 = 998244353;
ll inf = 1000000000000000000;
#define r... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<pii, int> ppii;
typedef pair<int, pii> pipi;
typedef pair<ll, ll> pll;
typedef pair<ll, pll> plpl;
typedef tuple<ll, ll, ll> tl;
ll mod = 1000000007;
ll mod2 = 998244353;
ll inf = 1000000000000000000;
#define r... | [] | 855,034 | 855,035 | u357265888 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<pii, int> ppii;
typedef pair<int, pii> pipi;
typedef pair<ll, ll> pll;
typedef pair<ll, pll> plpl;
typedef tuple<ll, ll, ll> tl;
ll mod = 1000000007;
ll mod2 = 998244353;
ll inf = 1000000000000000000;
#define r... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<pii, int> ppii;
typedef pair<int, pii> pipi;
typedef pair<ll, ll> pll;
typedef pair<ll, pll> plpl;
typedef tuple<ll, ll, ll> tl;
ll mod = 1000000007;
ll mod2 = 998244353;
ll inf = 1000000000000000000;
#define r... | [
"identifier.change",
"call.arguments.change",
"assignment.value.change"
] | 855,036 | 855,035 | u357265888 | cpp |
p03039 | #include <iostream>
#include <stdio.h>
#include <unordered_map>
#include <vector>
using namespace std;
using namespace std;
long long mod = 1e9 + 7;
long long GetValue(long long n, long long m) {
long long ans = 0;
for (long long i = 1; i < n; i++) {
ans = (ans + i * (n - i)) % mod;
}
ans = ans * (m * m) %... | #include <iostream>
#include <stdio.h>
#include <unordered_map>
#include <vector>
using namespace std;
using namespace std;
long long mod = 1e9 + 7;
long long GetValue(long long n, long long m) {
long long ans = 0;
for (long long i = 1; i < n; i++) {
ans = (ans + i * (n - i)) % mod;
}
ans = ans * (m * m) %... | [
"function.return_value.change",
"assignment.change"
] | 855,041 | 855,042 | u647903912 | cpp |
p03039 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define VV vector
#define pb push_back
#define bitc __builtin_popcountl
#define m_p make_pair
#define inf 1000000000000000000ll
#define MAXN 1000001
#define eps 0.0000000001
#define fastio ... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define VV vector
#define pb push_back
#define bitc __builtin_popcountl
#define m_p make_pair
#define inf 1000000000000000000ll
#define MAXN 1000001
#define eps 0.0000000001
#define fastio ... | [
"assignment.add"
] | 855,047 | 855,048 | u883546077 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
f = -1;
c = getchar();
}
while ('0' <= c && c <= '9') {
x = (x << 3) + (x << 1) + c - '0';
c = getchar();
}
return x * f;
}
int m;
long long sum... | #include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
f = -1;
c = getchar();
}
while ('0' <= c && c <= '9') {
x = (x << 3) + (x << 1) + c - '0';
c = getchar();
}
return x * f;
}
int m;
long long sum... | [
"identifier.change",
"control_flow.branch.if.condition.change",
"control_flow.branch.while.replace.add",
"control_flow.loop.if.replace.remove",
"expression.operation.binary.remove"
] | 855,055 | 855,054 | u522606865 | cpp |
p03040 | #include <bits/stdc++.h>
#define F first
#define S second
using namespace std;
using ll = long long;
typedef pair<int, int> P;
const ll Mod = 1000000007;
int main() {
int Q;
cin >> Q;
multiset<ll> Set;
int _1, aa, bb;
cin >> _1 >> aa >> bb;
ll bsum = bb;
ll asum = 0;
Set.insert(aa);
auto itr = Set.beg... | #include <bits/stdc++.h>
#define F first
#define S second
using namespace std;
using ll = long long;
typedef pair<int, int> P;
const ll Mod = 1000000007;
int main() {
int Q;
cin >> Q;
multiset<ll> Set;
int _1, aa, bb;
cin >> _1 >> aa >> bb;
ll bsum = bb;
ll asum = 0;
Set.insert(aa);
auto itr = Set.beg... | [
"identifier.change"
] | 855,057 | 855,058 | u083494782 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
#define all(a) a.begin(), a.end()
using ll = long long;
const int INF = 1 << 30;
const ll INFll = 1LL << 62;
const int mod = int(1e9) + 7;
// const int mod=998244353;
using P = pair<int, int>;
using Pl = pair<ll, ll>;
using ld = long double;
using V = vector<int>;
using Vl ... | #include <bits/stdc++.h>
using namespace std;
#define all(a) a.begin(), a.end()
using ll = long long;
const int INF = 1 << 30;
const ll INFll = 1LL << 62;
const int mod = int(1e9) + 7;
// const int mod=998244353;
using P = pair<int, int>;
using Pl = pair<ll, ll>;
using ld = long double;
using V = vector<int>;
using Vl ... | [
"control_flow.branch.else.remove",
"expression.unary.arithmetic.remove"
] | 855,061 | 855,062 | u525008368 | cpp |
p03040 | #include <bits/stdc++.h>
//#include "atcoder/all"
typedef long long int ll;
using namespace std;
// using namespace atcoder;
multiset<ll> msl;
multiset<ll> msr;
int main() {
int q;
cin >> q;
ll sumb = 0;
ll suma = 0;
bool valid = true; // medがvalidか
ll c1, a1, b1;
cin >> c1 >> a1 >> b1;
sumb += b1;
ll... | #include <bits/stdc++.h>
//#include "atcoder/all"
typedef long long int ll;
using namespace std;
// using namespace atcoder;
multiset<ll> msl;
multiset<ll> msr;
int main() {
int q;
cin >> q;
ll sumb = 0;
ll suma = 0;
bool valid = true; // medがvalidか
ll c1, a1, b1;
cin >> c1 >> a1 >> b1;
sumb += b1;
ll... | [
"assignment.value.change",
"identifier.change"
] | 855,065 | 855,066 | u540315049 | cpp |
p03040 | #include <bits/stdc++.h>
//#include "atcoder/all"
typedef long long int ll;
using namespace std;
// using namespace atcoder;
multiset<ll> msl;
multiset<ll> msr;
int main() {
int q;
cin >> q;
ll sumb = 0;
ll suma = 0;
bool valid = true; // medがvalidか
int c1, a1, b1;
cin >> c1 >> a1 >> b1;
sumb += b1;
i... | #include <bits/stdc++.h>
//#include "atcoder/all"
typedef long long int ll;
using namespace std;
// using namespace atcoder;
multiset<ll> msl;
multiset<ll> msr;
int main() {
int q;
cin >> q;
ll sumb = 0;
ll suma = 0;
bool valid = true; // medがvalidか
ll c1, a1, b1;
cin >> c1 >> a1 >> b1;
sumb += b1;
ll... | [
"variable_declaration.type.change",
"assignment.value.change",
"identifier.change"
] | 855,067 | 855,066 | u540315049 | cpp |
p03040 | #include <bits/stdc++.h>
// #include <atcoder/all>
using namespace std;
// using namespace atcoder;
#define rp(i, k, n) for (int i = k; i < n; i++)
using ll = long long;
using ld = double;
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <clas... | #include <bits/stdc++.h>
// #include <atcoder/all>
using namespace std;
// using namespace atcoder;
#define rp(i, k, n) for (int i = k; i < n; i++)
using ll = long long;
using ld = double;
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <clas... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"call.function.change"
] | 855,070 | 855,071 | u575653048 | cpp |
p03040 | #include <algorithm>
#include <array>
#include <bitset>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdint.h>
#include <string>
#include <tim... | #include <algorithm>
#include <array>
#include <bitset>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdint.h>
#include <string>
#include <tim... | [
"call.arguments.change"
] | 855,074 | 855,075 | u539145601 | cpp |
p03040 | #pragma GCC optimize("Ofast")
#define _USE_MATH_DEFINES
#include "bits/stdc++.h"
using namespace std;
using u8 = uint8_t;
using u16 = uint16_t;
using u32 = uint32_t;
using u64 = uint64_t;
using i8 = int8_t;
using i16 = int16_t;
using i32 = int32_t;
using i64 = int64_t;
constexpr char newl = '\n';
constexpr double ep... | #pragma GCC optimize("Ofast")
#define _USE_MATH_DEFINES
#include "bits/stdc++.h"
using namespace std;
using u8 = uint8_t;
using u16 = uint16_t;
using u32 = uint32_t;
using u64 = uint64_t;
using i8 = int8_t;
using i16 = int16_t;
using i32 = int32_t;
using i64 = int64_t;
constexpr char newl = '\n';
constexpr double ep... | [
"assignment.change",
"expression.operator.change"
] | 855,087 | 855,088 | u211255607 | cpp |
p03040 | #pragma GCC optimize("Ofast")
#define _USE_MATH_DEFINES
#include "bits/stdc++.h"
using namespace std;
using u8 = uint8_t;
using u16 = uint16_t;
using u32 = uint32_t;
using u64 = uint64_t;
using i8 = int8_t;
using i16 = int16_t;
using i32 = int32_t;
using i64 = int64_t;
constexpr char newl = '\n';
constexpr double ep... | #pragma GCC optimize("Ofast")
#define _USE_MATH_DEFINES
#include "bits/stdc++.h"
using namespace std;
using u8 = uint8_t;
using u16 = uint16_t;
using u32 = uint32_t;
using u64 = uint64_t;
using i8 = int8_t;
using i16 = int16_t;
using i32 = int32_t;
using i64 = int64_t;
constexpr char newl = '\n';
constexpr double ep... | [
"variable_declaration.type.change",
"assignment.change",
"expression.operator.change"
] | 855,089 | 855,088 | u211255607 | cpp |
p03040 | #include <algorithm>
#include <bits/stdc++.h>
#include <cassert>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#includ... | #include <algorithm>
#include <bits/stdc++.h>
#include <cassert>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#includ... | [
"expression.operation.binary.remove"
] | 855,090 | 855,091 | u767543103 | cpp |
p03040 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include... | [
"assignment.value.change",
"assignment.change"
] | 855,094 | 855,095 | u190018920 | cpp |
p03040 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include... | [
"assignment.value.change",
"assignment.change"
] | 855,096 | 855,095 | u190018920 | cpp |
p03040 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include... | [
"type_conversion.add"
] | 855,094 | 855,097 | u190018920 | cpp |
p03040 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include... | [
"type_conversion.add"
] | 855,096 | 855,097 | u190018920 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
int Q;
priority_queue<int> q_right;
priority_queue<int, vector<int>, greater<int>> q_left;
int f = 1;
long long cum = 0;
void add() {
int a, b;
cin >> a >> b;
cum += (long long)b;
if (f) { //最初だけは両方にaをpushしておく
q_left.push(a);
q_right.push(a);
f = 0;
... | #include <bits/stdc++.h>
using namespace std;
int Q;
priority_queue<int> q_left;
priority_queue<int, vector<int>, greater<int>> q_right;
int f = 1;
long long cum = 0;
void add() {
int a, b;
cin >> a >> b;
cum += (long long)b;
if (f) { //最初だけは両方にaをpushしておく
q_left.push(a);
q_right.push(a);
f = 0;
... | [
"identifier.change"
] | 855,098 | 855,099 | u426397594 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
typedef vector<vector<int>> vv;
typedef pair<int, int> P;
// input
int Q;
int n;
ll asum, bsum, midsum;
multiset<int> s;
multiset<int>::iterator itr;
void input() { cin >> Q; }
void param_init() ... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
typedef vector<vector<int>> vv;
typedef pair<int, int> P;
// input
int Q;
ll n;
ll asum, bsum, midsum;
multiset<ll> s;
multiset<ll>::iterator itr;
void input() { cin >> Q; }
void param_init() {
... | [
"variable_declaration.type.change"
] | 855,102 | 855,103 | u671861352 | cpp |
p03040 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <ctime>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <tuple>
#include <vect... | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <ctime>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <tuple>
#include <vect... | [
"identifier.change"
] | 855,104 | 855,105 | u275934251 | cpp |
p03040 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <ctime>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <tuple>
#include <vect... | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <ctime>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <tuple>
#include <vect... | [
"identifier.change"
] | 855,106 | 855,105 | u275934251 | cpp |
p03040 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define chmax(a, b) a = max(a, b);
#define chmin(a, b) a = min(a, b);
using namespace std;
using ll = long long;
using P = pair<int, int>;
// Binary Indexed Tree (Fenwick Tree)
// https://youtu.be/lyHk98daDJo?t=7960
template <typename T> struct B... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define chmax(a, b) a = max(a, b);
#define chmin(a, b) a = min(a, b);
using namespace std;
using ll = long long;
using P = pair<int, int>;
// Binary Indexed Tree (Fenwick Tree)
// https://youtu.be/lyHk98daDJo?t=7960
template <typename T> struct B... | [] | 855,112 | 855,113 | u539692012 | cpp |
p03040 | //#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define PI 3.14159265359
using namespace std;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define bit(n, k) (((ll)n >> (ll)k) & 1) /*nのk bit目*/
const long long INF = 1e+18 + 1;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef p... | //#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define PI 3.14159265359
using namespace std;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define bit(n, k) (((ll)n >> (ll)k) & 1) /*nのk bit目*/
const long long INF = 1e+18 + 1;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef p... | [
"type_conversion.add"
] | 855,123 | 855,124 | u614128939 | cpp |
p03040 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define ll long long
#define ull unsigned long long
#define db long double
#define pb push_back
#define ppb pop_back
#define F first
#define S second
#define mp make_p... | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define ll long long
#define ull unsigned long long
#define db long double
#define pb push_back
#define ppb pop_back
#define F first
#define S second
#define mp make_p... | [] | 855,125 | 855,126 | u322084037 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
constexpr long mod = 1000000007;
priority_queue<long> q1, q2;
long c() {
if (!q1.size() && !q2.size())
return 0;
if (!q2.size())
return q1.top();
if (!q1.size())
return -q2.top();
long a = q1.top(), b = -q2.top();
long m = q1.size(), n = q2.size();
... | #include <bits/stdc++.h>
using namespace std;
constexpr long mod = 1000000007;
priority_queue<long> q1, q2;
long c() {
if (!q1.size() && !q2.size())
return 0;
if (!q2.size())
return q1.top();
if (!q1.size())
return -q2.top();
long a = q1.top(), b = -q2.top();
long m = q1.size(), n = q2.size();
... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"io.output.change"
] | 855,129 | 855,130 | u056944756 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define all(v) v.begin(), v.end()
typedef long long ll;
typedef pair<ll, ll> P;
typedef vector<ll> vec;
typedef vector<vec> mat;
const int MAX_N = 200000;
int bit[MAX_N + 1] = {0}, n;
int sum(int i) {
int s = 0;
while (i > 0)... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define all(v) v.begin(), v.end()
typedef long long ll;
typedef pair<ll, ll> P;
typedef vector<ll> vec;
typedef vector<vec> mat;
const int MAX_N = 200000;
int bit[MAX_N + 1] = {0}, n;
int sum(int i) {
int s = 0;
while (i > 0)... | [
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 855,131 | 855,132 | u441296840 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i, n) for (int i = 0; i < int(n); i++)
#define FOR(i, m, n) for (int i = int(m); i < int(n); i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define VI vector<int>
#define VP vector<pair<int, int>>
#define VPP vector<pair<int, pair<int, ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i, n) for (int i = 0; i < int(n); i++)
#define FOR(i, m, n) for (int i = int(m); i < int(n); i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define VI vector<int>
#define VP vector<pair<int, int>>
#define VPP vector<pair<int, pair<int, ... | [
"literal.number.change",
"control_flow.branch.if.condition.change",
"identifier.change"
] | 855,139 | 855,140 | u856232850 | cpp |
p03040 | #include <cmath>
#include <iostream>
#include <set>
using namespace std;
int main() {
int Q;
cin >> Q;
multiset<int> S;
long sum_l = 0, sum_r = 0, sum_b = 0;
int q, a, b;
cin >> q >> a >> b;
S.insert(a);
sum_b += b;
auto it = S.begin();
for (int i = 1; i < Q; i++) {
cin >> q;
if (q == 1) {
... | #include <cmath>
#include <iostream>
#include <set>
using namespace std;
int main() {
int Q;
cin >> Q;
multiset<int> S;
long sum_l = 0, sum_r = 0, sum_b = 0;
int q, a, b;
cin >> q >> a >> b;
S.insert(a);
sum_b += b;
auto it = S.begin();
for (int i = 1; i < Q; i++) {
cin >> q;
if (q == 1) {
... | [
"expression.operation.binary.add"
] | 855,141 | 855,142 | u521712919 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define rep2(i, x, n) for (int i = x, i##_len = (n); i < i##_len; ++i)
#define all(n) begin(n), end(n)
using ll = long long;
using P = pair<int, int>;
using vi = vector<int>;
using vl = vector<ll>;
using vs ... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define rep2(i, x, n) for (int i = x, i##_len = (n); i < i##_len; ++i)
#define all(n) begin(n), end(n)
using ll = long long;
using P = pair<int, int>;
using vi = vector<int>;
using vl = vector<ll>;
using vs ... | [
"variable_declaration.type.change"
] | 855,147 | 855,148 | u134678977 | cpp |
p03040 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#define _overload3(_1, _2, _3, name, ...) name
... | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#define _overload3(_1, _2, _3, name, ...) name
... | [
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 855,161 | 855,162 | u892687772 | cpp |
p03040 | #include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define MOD 1000003
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define... | #include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define MOD 1000003
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define... | [
"expression.operator.change"
] | 855,163 | 855,164 | u712993629 | cpp |
p03040 | #include <bits/stdc++.h>
#define rep(i, n) for (long long i = 0; i < (n); i++)
using namespace std;
using P = pair<long long, long long>;
typedef unsigned long long ull;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <cla... | #include <bits/stdc++.h>
#define rep(i, n) for (long long i = 0; i < (n); i++)
using namespace std;
using P = pair<long long, long long>;
typedef unsigned long long ull;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <cla... | [
"variable_declaration.type.change",
"identifier.change",
"call.arguments.change",
"assignment.value.change"
] | 855,165 | 855,166 | u371149954 | cpp |
p03040 | #include <bits/stdc++.h>
#define ALL(v) std::begin(v), std::end(v)
using lint = long long;
using ld = long double;
int main() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
std::cout.setf(std::ios_base::fixed);
std::cout.precision(15);
lint q;
std::cin >> q;
std::multiset<lint> left, righ... | #include <bits/stdc++.h>
#define ALL(v) std::begin(v), std::end(v)
using lint = long long;
using ld = long double;
int main() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
std::cout.setf(std::ios_base::fixed);
std::cout.precision(15);
lint q;
std::cin >> q;
std::multiset<lint> left, righ... | [
"call.function.change",
"expression.operation.binary.change"
] | 855,171 | 855,172 | u846041485 | cpp |
p03040 | #include <bits/stdc++.h>
#define be(v) (v).begin(), (v).end()
#define pb(q) push_back(q)
typedef long long ll;
using namespace std;
const ll mod = 1000000007;
#define doublecout(a) cout << fixed << setprecision(10) << a << endl;
vector<vector<int>> v(1000);
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_std... | #include <bits/stdc++.h>
#define be(v) (v).begin(), (v).end()
#define pb(q) push_back(q)
typedef long long ll;
using namespace std;
const ll mod = 1000000007;
#define doublecout(a) cout << fixed << setprecision(10) << a << endl;
vector<vector<int>> v(1000);
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_std... | [
"misc.opposites",
"control_flow.branch.if.condition.change"
] | 855,173 | 855,174 | u192903163 | cpp |
p03040 | #include <bits/stdc++.h>
#define be(v) (v).begin(), (v).end()
#define pb(q) push_back(q)
typedef long long ll;
using namespace std;
const ll mod = 1000000007;
#define doublecout(a) cout << fixed << setprecision(10) << a << endl;
vector<vector<int>> v(1000);
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_std... | #include <bits/stdc++.h>
#define be(v) (v).begin(), (v).end()
#define pb(q) push_back(q)
typedef long long ll;
using namespace std;
const ll mod = 1000000007;
#define doublecout(a) cout << fixed << setprecision(10) << a << endl;
vector<vector<int>> v(1000);
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_std... | [
"misc.opposites",
"control_flow.branch.if.condition.change",
"call.arguments.change"
] | 855,175 | 855,174 | u192903163 | cpp |
p03040 | #include <bits/stdc++.h>
#define be(v) (v).begin(), (v).end()
#define pb(q) push_back(q)
typedef long long ll;
using namespace std;
const ll mod = 1000000007;
#define doublecout(a) cout << fixed << setprecision(10) << a << endl;
vector<vector<int>> v(1000);
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_std... | #include <bits/stdc++.h>
#define be(v) (v).begin(), (v).end()
#define pb(q) push_back(q)
typedef long long ll;
using namespace std;
const ll mod = 1000000007;
#define doublecout(a) cout << fixed << setprecision(10) << a << endl;
vector<vector<int>> v(1000);
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_std... | [
"misc.opposites",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 855,176 | 855,174 | u192903163 | cpp |
p03041 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
string s;
cin >> n >> k >> s;
s[k - 1] -= 32;
cout << s << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
string s;
cin >> n >> k >> s;
s[k - 1] += 32;
cout << s << endl;
} | [
"expression.operator.change"
] | 855,187 | 855,188 | u225777148 | cpp |
p03041 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
string s;
cin >> n >> k >> s;
s.at(k) = s.at(k) - ('A' - 'a');
cout << s << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
string s;
cin >> n >> k >> s;
s.at(k - 1) = s.at(k - 1) - ('A' - 'a');
cout << s << endl;
} | [
"assignment.change"
] | 855,198 | 855,199 | u668010224 | cpp |
p03041 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int N, K;
cin >> N >> K;
string S;
cin >> S;
S[K - 1] = S[K - 1] - ' ';
cout << S << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int N, K;
cin >> N >> K;
string S;
cin >> S;
S[K - 1] = S[K - 1] + ' ';
cout << S << endl;
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 855,224 | 855,225 | u018916376 | cpp |
p03041 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
char s = S.at(K - 1);
s += 32;
S.at(K - 1) = 's';
cout << S << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
char s = S.at(K - 1);
s += 32;
S.at(K - 1) = s;
cout << S << endl;
}
| [] | 855,226 | 855,227 | u279848598 | cpp |
p03041 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
string S;
cin >> N >> K;
cin >> S;
S.at(K) = tolower(S.at(K - 1));
cout << S << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
string S;
cin >> N >> K;
cin >> S;
S.at(K - 1) = tolower(S.at(K - 1));
cout << S << endl;
}
| [
"assignment.change"
] | 855,245 | 855,246 | u223555291 | cpp |
p03041 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
string S;
cin >> N >> K >> S;
if (S[K - 1] = 'A') {
S[K - 1] = 'a';
} else if (S[K - 1] = 'B') {
S[K - 1] = 'b';
} else {
S[K - 1] = 'c';
}
cout << S << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
string S;
cin >> N >> K >> S;
if (S[K - 1] == 'A') {
S[K - 1] = 'a';
} else if (S[K - 1] == 'B') {
S[K - 1] = 'b';
} else {
S[K - 1] = 'c';
}
cout << S << endl;
} | [
"expression.operation.compare.replace.add",
"assignment.replace.remove",
"misc.typo"
] | 855,249 | 855,250 | u740002394 | cpp |
p03041 | // HEADER FILES AND NAMESPACES
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template <t... | // HEADER FILES AND NAMESPACES
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template <t... | [
"assignment.change"
] | 855,253 | 855,254 | u729073980 | cpp |
p03041 | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int n, k;
cin >> n >> k >> s;
string b = "ABC";
string l = "abc";
for (int i = 0; i < 3; i++) {
if (s.at(k - 1) == b.at(i)) {
s.at(k - 1) = l.at(i);
}
break;
}
cout << s << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int n, k;
cin >> n >> k >> s;
string b = "ABC";
string l = "abc";
for (int i = 0; i < 3; i++) {
if (s.at(k - 1) == b.at(i)) {
s.at(k - 1) = l.at(i);
}
}
cout << s << endl;
} | [] | 855,255 | 855,256 | u694766284 | cpp |
p03041 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
string s;
cin >> n >> k >> s;
if (s.at(k - 1) = 'A') {
s.at(k - 1) = 'a';
} else if (s.at(k - 1) = 'B') {
s.at(k - 1) = 'b';
} else {
s.at(k - 1) = 'c';
}
cout << s;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
string s;
cin >> n >> k >> s;
if (s.at(k - 1) == 'A') {
s.at(k - 1) = 'a';
} else if (s.at(k - 1) == 'B') {
s.at(k - 1) = 'b';
} else {
s.at(k - 1) = 'c';
}
cout << s;
} | [
"expression.operation.compare.replace.add",
"assignment.replace.remove",
"misc.typo"
] | 855,282 | 855,283 | u166378830 | cpp |
p03041 | //#include<bits/stdc++.h>
#include <iostream>
using namespace std;
typedef long long ll;
const int N = 200005;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
string s;
cin >> s;
s[k] = tolower(s[k]);
cout << s;
return 0;
}
| //#include<bits/stdc++.h>
#include <iostream>
using namespace std;
typedef long long ll;
const int N = 200005;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
string s;
cin >> s;
s[k - 1] = tolower(s[k - 1]);
cout << s;
return 0;
}
| [
"assignment.change"
] | 855,290 | 855,291 | u023228586 | cpp |
p03041 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
using Graph = vector<vector<ll>>;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep2(i, m, n) for (ll i = m; i < (ll)(n); i++)
#define rrep(i, n, m) for (ll i = n; i >= (ll)(m); i--)
const int dx[4] = {1, 0, -1, 0... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
using Graph = vector<vector<ll>>;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep2(i, m, n) for (ll i = m; i < (ll)(n); i++)
#define rrep(i, n, m) for (ll i = n; i >= (ll)(m); i--)
const int dx[4] = {1, 0, -1, 0... | [
"expression.operation.binary.add"
] | 855,315 | 855,316 | u891847179 | cpp |
p03041 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
string s;
cin >> a >> b >> s;
b--;
if (s.at(b) == 'A') {
s.at(b) = 'a';
}
else if (s.at(b - 1) == 'B') {
s.at(b) = 'b';
}
else if (s.at(b) == 'C') {
s.at(b) = 'c';
}
cout << s << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
string s;
cin >> a >> b >> s;
b--;
if (s.at(b) == 'A') {
s.at(b) = 'a';
}
else if (s.at(b) == 'B') {
s.at(b) = 'b';
}
else if (s.at(b) == 'C') {
s.at(b) = 'c';
}
cout << s << endl;
}
| [
"expression.operation.binary.remove"
] | 855,317 | 855,318 | u751515087 | cpp |
p03041 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
string s;
cin >> a >> b >> s;
if (s.at(b) == 'A') {
s.at(b) = 'a';
}
else if (s.at(b) == 'B') {
s.at(b) = 'b';
}
else if (s.at(b) == 'C') {
s.at(b) = 'c';
}
cout << s << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
string s;
cin >> a >> b >> s;
b--;
if (s.at(b) == 'A') {
s.at(b) = 'a';
}
else if (s.at(b) == 'B') {
s.at(b) = 'b';
}
else if (s.at(b) == 'C') {
s.at(b) = 'c';
}
cout << s << endl;
}
| [
"expression.unary.arithmetic.add"
] | 855,319 | 855,318 | u751515087 | cpp |
p03041 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define fi first
#define se second
#define sz(x) ((int)(x).size())
using ll = long long;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define MOD 1000000007
c... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define fi first
#define se second
#define sz(x) ((int)(x).size())
using ll = long long;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define MOD 1000000007
c... | [] | 855,322 | 855,323 | u406237526 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.