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 |
|---|---|---|---|---|---|---|---|
p03685 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#define debug_value(x) \
cerr << "line" << __LINE__ << ":<" << __func__ << ">:" << #x << "=" << x \
<< endl;... | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#define debug_value(x) \
cerr << "line" << __LINE__ << ":<" << __func__ << ">:" << #x << "=" << x \
<< endl;... | [
"identifier.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 1,358,567 | 1,358,568 | u693133807 | cpp |
p03685 | #include "bits/stdc++.h"
using namespace std;
int r, c, n;
bool on_boundary(int x, int y) {
return (x == 0 or x == r or y == 0 or y == c);
}
int enc(int x, int y) {
if (x == 0)
return y;
if (y == c)
return c + x;
if (x == r)
return 2 * c + r - y;
return 2 * c + 2 * r - x;
}
int main() {
cin >> r... | #include "bits/stdc++.h"
using namespace std;
int r, c, n;
bool on_boundary(int x, int y) {
return (x == 0 or x == r or y == 0 or y == c);
}
int enc(int x, int y) {
if (x == 0)
return y;
if (y == c)
return c + x;
if (x == r)
return 2 * c + r - y;
return 2 * c + 2 * r - x;
}
int main() {
cin >> r... | [] | 1,358,569 | 1,358,570 | u875407613 | cpp |
p03685 | #include <bits/stdc++.h>
using namespace std;
bool attached(int x1, int y1, int x2, int y2, int R, int C) {
return (x1 == 0 || x1 == R || y1 == 0 || y1 == R) &&
(x2 == 0 || x2 == R || y2 == 0 || y2 == C);
}
int main() {
int R, C, N;
cin >> R >> C >> N;
priority_queue<pair<int, int>> pq;
vector<in... | #include <bits/stdc++.h>
using namespace std;
bool attached(int x1, int y1, int x2, int y2, int R, int C) {
return (x1 == 0 || x1 == R || y1 == 0 || y1 == C) &&
(x2 == 0 || x2 == R || y2 == 0 || y2 == C);
}
int main() {
int R, C, N;
cin >> R >> C >> N;
priority_queue<pair<int, int>> pq;
vector<in... | [
"identifier.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 1,358,579 | 1,358,580 | u788717734 | cpp |
p03685 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
... | [
"expression.operation.binary.remove"
] | 1,358,583 | 1,358,584 | u275797573 | cpp |
p03685 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
... | [
"expression.operation.binary.remove",
"identifier.change",
"call.function.change",
"call.arguments.change"
] | 1,358,585 | 1,358,584 | u275797573 | cpp |
p03685 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <... | [
"expression.operation.binary.remove"
] | 1,358,586 | 1,358,587 | u017271745 | cpp |
p03685 | #include <bits/stdc++.h>
#define ll long long
#define ull unsigned ll
#define vi vector<ll>
#define vvi vector<vi>
#define all(x) x.begin(), x.end()
#define pb push_back
#define mp make_pair
#define ld long double
#define pii pair<ll, ll>
#define mt make_tuple
#define mn(a, b) a = min(a, b)
#define mx(a, b) a = max(a,... | #include <bits/stdc++.h>
#define ll long long
#define ull unsigned ll
#define vi vector<ll>
#define vvi vector<vi>
#define all(x) x.begin(), x.end()
#define pb push_back
#define mp make_pair
#define ld long double
#define pii pair<ll, ll>
#define mt make_tuple
#define mn(a, b) a = min(a, b)
#define mx(a, b) a = max(a,... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 1,358,590 | 1,358,591 | u386123959 | cpp |
p03685 | #include <algorithm>
#include <iostream>
#include <stack>
#include <vector>
using namespace std;
int main() {
int R, C, N;
while (cin >> R >> C >> N) {
vector<pair<int, int>> vp;
for (int i = 0; i < N; i++) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
if ((x1 % R == 0 || y2 % C == ... | #include <algorithm>
#include <iostream>
#include <stack>
#include <vector>
using namespace std;
int main() {
int R, C, N;
while (cin >> R >> C >> N) {
vector<pair<int, int>> vp;
for (int i = 0; i < N; i++) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
if ((x1 % R == 0 || y1 % C == ... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 1,358,592 | 1,358,593 | u002023395 | cpp |
p03685 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <fstream>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
typedef long long ... | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <fstream>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
typedef long long ... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 1,358,594 | 1,358,595 | u242679311 | cpp |
p03685 | #include <bits/stdc++.h>
#define fi first
#define se second
const int N = 200200;
const int mod = 1e9 + 7;
using namespace std;
int r, c, n;
int g[N];
bool good(int x, int y) {
if (x != 0 && x != r && y != 0 && y != c)
return false;
return true;
}
vector<pair<int, int>> A, B, C, D;
void add(int x, int y,... | #include <bits/stdc++.h>
#define fi first
#define se second
const int N = 200200;
const int mod = 1e9 + 7;
using namespace std;
int r, c, n;
int g[N];
bool good(int x, int y) {
if (x != 0 && x != r && y != 0 && y != c)
return false;
return true;
}
vector<pair<int, int>> A, B, C, D;
void add(int x, int y,... | [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.branch.if.condition.change",
"expression.operation.unary.add",
"call.arguments.change",
"identifier.replace.remove",
"literal.replace.add",
"expression.operation.unary.arithmetic.remove"
] | 1,358,596 | 1,358,597 | u941977569 | cpp |
p03685 | #pragma region template
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
using vld = vector<l... | #pragma region template
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
using vld = vector<l... | [
"function.return_value.change",
"expression.operation.binary.change"
] | 1,358,598 | 1,358,599 | u116670634 | cpp |
p03685 | #include <bits/stdc++.h>
#define cinf(n, x) \
for (int i = 0; i < (n); i++) \
cin >> x[i];
#define ft first
#define sc second
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define all(v)... | #include <bits/stdc++.h>
#define cinf(n, x) \
for (int i = 0; i < (n); i++) \
cin >> x[i];
#define ft first
#define sc second
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define all(v)... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 1,358,600 | 1,358,601 | u619683748 | cpp |
p03685 | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <vector>
template <typename T> void fin(T const &t) {
std::cout << t << std::endl;
exit(0);
}
struct P {
int v1, v2;
};
template <typename T> void sort_u(T &v) {
std::sort(v.begin(), v.end());
v.erase(std::unique(v.begin(), v.end()), v.end... | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <vector>
template <typename T> void fin(T const &t) {
std::cout << t << std::endl;
exit(0);
}
struct P {
int v1, v2;
};
template <typename T> void sort_u(T &v) {
std::sort(v.begin(), v.end());
v.erase(std::unique(v.begin(), v.end()), v.end... | [
"literal.string.change",
"literal.string.case.change",
"call.arguments.change"
] | 1,358,604 | 1,358,605 | u294638337 | cpp |
p03685 | #include <bits/stdc++.h>
#define f(a, n) for (int a = 0; a < n; a++)
#define F(a, n) for (int a = 1; a <= n; a++)
using namespace std;
int r, c, n;
int lin(int x, int y) {
if (x != 0 && x != c && y != 0 && y != r)
return -1;
if (x == 0)
return y;
if (y == r)
return r + x;
if (x == c)
return r ... | #include <bits/stdc++.h>
#define f(a, n) for (int a = 0; a < n; a++)
#define F(a, n) for (int a = 1; a <= n; a++)
using namespace std;
int r, c, n;
int lin(int x, int y) {
if (x != 0 && x != c && y != 0 && y != r)
return -1;
if (x == 0)
return y;
if (y == r)
return r + x;
if (x == c)
return r ... | [
"expression.operation.binary.remove"
] | 1,358,606 | 1,358,607 | u824167335 | cpp |
p03685 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define llint long ... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define llint long ... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 1,358,615 | 1,358,616 | u319282133 | cpp |
p03685 | #include <algorithm> // minmax, sort, swap
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio> // printf, scanf
#include <deque> // deque
#include <functional> // function<void(int)>
#include <iomanip> // cout<<setprecision(n)
#include <iostream> // cin, cout, cerr
#include <map> ... | #include <algorithm> // minmax, sort, swap
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio> // printf, scanf
#include <deque> // deque
#include <functional> // function<void(int)>
#include <iomanip> // cout<<setprecision(n)
#include <iostream> // cin, cout, cerr
#include <map> ... | [
"call.add"
] | 1,358,621 | 1,358,622 | u128456980 | cpp |
p03685 | // Math = ♥️
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
/*-------------------------------------------------------------------------------------------------------------------------*/
#define ll long long /... | // Math = ♥️
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
/*-------------------------------------------------------------------------------------------------------------------------*/
#define ll long long /... | [
"misc.opposites",
"control_flow.branch.if.condition.change"
] | 1,358,625 | 1,358,626 | u584989818 | cpp |
p03685 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#define _USE_MATH_DEFINES
#include <functional>
#include <math.h>
using namespace std;
#define rep(i, x) for (ll i = 0; i < x; i++)
#define repn(i, x) for (ll i... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#define _USE_MATH_DEFINES
#include <functional>
#include <math.h>
using namespace std;
#define rep(i, x) for (ll i = 0; i < x; i++)
#define repn(i, x) for (ll i... | [
"identifier.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 1,358,627 | 1,358,628 | u004411048 | cpp |
p03685 | #include <bits/stdc++.h>
int r, c, n, sx, sy, tx, ty, cnt, x, y, tp, st[100005];
struct note {
int x, id, type;
} a[100005];
int cal(int x, int y) {
if (x == 0)
return y;
if (x == c)
return r + c + r - y;
if (y == 0)
return r + c + r + c - x;
if (y == r)
return r + x;
return -1;
}
bool cmp(n... | #include <bits/stdc++.h>
int r, c, n, sx, sy, tx, ty, cnt, x, y, tp, st[100005];
struct note {
int x, id, type;
} a[200005];
int cal(int x, int y) {
if (x == 0)
return y;
if (x == c)
return r + c + r - y;
if (y == 0)
return r + c + r + c - x;
if (y == r)
return r + x;
return -1;
}
bool cmp(n... | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"identifier.change",
"call.arguments.change"
] | 1,358,631 | 1,358,630 | u754587701 | cpp |
p03685 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#ifdef tabr
#include "library/debug.cpp"
#else
#define debug(...) 0
#endif
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int r, c, n;
cin >> r >> c >> n;
vector<pair<pair<int, int... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#ifdef tabr
#include "library/debug.cpp"
#else
#define debug(...) 0
#endif
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int r, c, n;
cin >> r >> c >> n;
vector<pair<pair<int, int... | [
"control_flow.branch.if.condition.change"
] | 1,358,632 | 1,358,633 | u604231488 | cpp |
p03685 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define per(i, n) for (int i = (n)-1; i >= 0; --i)
#define repa(i, n) for (int i = 1; i < (n); ++i)
#define foreach(i, n) for (auto &i : (n))
#define pii pair<int, int>
#define pll pair<long long, long long>
#define all(x) (x).begin(), (x).end()
#... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define per(i, n) for (int i = (n)-1; i >= 0; --i)
#define repa(i, n) for (int i = 1; i < (n); ++i)
#define foreach(i, n) for (auto &i : (n))
#define pii pair<int, int>
#define pll pair<long long, long long>
#define all(x) (x).begin(), (x).end()
#... | [
"variable_declaration.remove",
"variable_declaration.add"
] | 1,358,636 | 1,358,637 | u493610446 | cpp |
p03685 | #include <bits/stdc++.h>
using namespace std;
#define INFS (1LL << 28)
#define DEKAI 1000000007
//#define MOD 1000000007
#define lp(i, n) for (int i = 0; i < n; i++)
#define rep(i, n) lp(i, n)
#define lps(i, n) for (int i = 1; i <= n; i++)
#define all(c) begin(c), end(c)
//#define int long long
namespace {
#define __... | #include <bits/stdc++.h>
using namespace std;
#define INFS (1LL << 28)
#define DEKAI 1000000007
//#define MOD 1000000007
#define lp(i, n) for (int i = 0; i < n; i++)
#define rep(i, n) lp(i, n)
#define lps(i, n) for (int i = 1; i <= n; i++)
#define all(c) begin(c), end(c)
//#define int long long
namespace {
#define __... | [
"identifier.change",
"function.return_value.change"
] | 1,358,638 | 1,358,639 | u501494362 | cpp |
p03685 | // >>> TEMPLATES
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#define int ll
#define double ld
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define repR(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define rep1R... | // >>> TEMPLATES
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#define int ll
#define double ld
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define repR(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define rep1R... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 1,358,640 | 1,358,641 | u200215998 | cpp |
p03684 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define LLMAX (1ll << 60) - 1
#define INTMAX (1 << 30) - 1
#define MOD 1000000007
#define NMAX 1000 * 100 + 1
#define numberOfSetBits(S) \
__builtin_popcount(S) // __builtin_popcountl(S) __builtin_p... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define LLMAX (1ll << 60) - 1
#define INTMAX (1 << 30) - 1
#define MOD 1000000007
#define NMAX 1000 * 100 + 1
#define numberOfSetBits(S) \
__builtin_popcount(S) // __builtin_popcountl(S) __builtin_p... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"call.add"
] | 1,358,653 | 1,358,654 | u313568050 | cpp |
p03684 | #include <bits/stdc++.h>
using namespace std;
#define llong long long int
#define ldouble long double
#define rep(i, n) for (int i = 0; i < n; ++i)
#define REP(i, k, n) for (int i = k; i < n; ++i)
#define fore(i, a) for (auto &i : a)
#define repr(i, n) for (int i = n; i >= 0; --i)
#define stl_rep(itr, x) for (auto it... | #include <bits/stdc++.h>
using namespace std;
#define llong long long int
#define ldouble long double
#define rep(i, n) for (int i = 0; i < n; ++i)
#define REP(i, k, n) for (int i = k; i < n; ++i)
#define fore(i, a) for (auto &i : a)
#define repr(i, n) for (int i = n; i >= 0; --i)
#define stl_rep(itr, x) for (auto it... | [
"assignment.variable.change",
"identifier.change"
] | 1,358,682 | 1,358,683 | u943004959 | cpp |
p03684 | #include <bits/stdc++.h>
using namespace std;
int g[100005], px[100005], py[100005];
pair<int, int> sx[100005], sy[100005];
int FIND(int x) {
if (g[x] == x)
return x;
else
return g[x] = FIND(g[x]);
}
int value(int x, int y) {
x = FIND(x);
y = FIND(y);
if (x == y)
return 0;
g[x] = y;
return 1;... | #include <bits/stdc++.h>
using namespace std;
int g[100005], px[100005], py[100005];
pair<int, int> sx[100005], sy[100005];
int FIND(int x) {
if (g[x] == x)
return x;
else
return g[x] = FIND(g[x]);
}
int value(int x, int y) {
x = FIND(x);
y = FIND(y);
if (x == y)
return 0;
g[x] = y;
return 1;... | [
"call.add",
"call.arguments.change",
"function.return_value.change"
] | 1,358,686 | 1,358,687 | u314693739 | cpp |
p03684 | #include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
typedef pair<long long, long long> ii;
vector<pair<long long, ii>> edge;
long long n, up[100005], sz[100005];
pair<ii, long long> x[100005];
bool cmp(const pair<ii, long long> &a, const pair<ii... | #include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
typedef pair<long long, long long> ii;
vector<pair<long long, ii>> edge;
long long n, up[100005], sz[100005];
pair<ii, long long> x[100005];
bool cmp(const pair<ii, long long> &a, const pair<ii... | [
"identifier.change",
"call.arguments.change"
] | 1,358,696 | 1,358,697 | u298566265 | cpp |
p03684 | #include <algorithm>
#include <cstdio>
using namespace std;
long long n, m, i, j, k, cc[500000], a, b, c, s;
struct p {
long long x, y, z;
bool operator<(const p &gg) const { return x < gg.x; }
} s1[500000], s2[500000];
struct pp {
long long x, y, z;
bool operator<(const pp &tt) const { return z < tt.z; }
} wow... | #include <algorithm>
#include <cstdio>
using namespace std;
long long n, m, i, j, k, cc[500000], a, b, c, s;
struct p {
long long x, y, z;
bool operator<(const p &gg) const { return x < gg.x; }
} s1[500000], s2[500000];
struct pp {
long long x, y, z;
bool operator<(const pp &tt) const { return z < tt.z; }
} wow... | [
"expression.operation.binary.add"
] | 1,358,698 | 1,358,699 | u704549083 | cpp |
p03685 | #include <bits/stdc++.h>
#define RI register int
typedef long long LL;
#define FILEIO(name) \
freopen(name ".in", "r", stdin), freopen(name ".out", "w", stdout);
using namespace std;
char buf[1000000], *p1 = buf, *p2 = buf;
inline char gc() {
if (p1 == p2... | #include <bits/stdc++.h>
#define RI register int
typedef long long LL;
#define FILEIO(name) \
freopen(name ".in", "r", stdin), freopen(name ".out", "w", stdout);
using namespace std;
char buf[1000000], *p1 = buf, *p2 = buf;
inline char gc() {
if (p1 == p2... | [
"literal.string.change",
"literal.string.case.change",
"call.arguments.change",
"function.return_value.change",
"io.output.change"
] | 1,358,704 | 1,358,705 | u465426617 | cpp |
p03685 | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <stack>
#include <vector>
using namespace std;
int r, c;
int n;
typedef long long LL;
int type(int x, int y) {
if (x == 0)
return 0;
if (y == c)
return 1;
if (x == r)
return 2;
if (y == 0)
return 3;
return... | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <stack>
#include <vector>
using namespace std;
int r, c;
int n;
typedef long long LL;
int type(int x, int y) {
if (x == 0)
return 0;
if (y == c)
return 1;
if (x == r)
return 2;
if (y == 0)
return 3;
return... | [] | 1,358,706 | 1,358,707 | u962264371 | cpp |
p03685 | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using vvl = vector<vl>;
const ll INF = 1LL << 60;
const ll MOD = 1000000007;
template <class T> bool chmax(T &a, const T &b) {
... | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using vvl = vector<vl>;
const ll INF = 1LL << 60;
const ll MOD = 1000000007;
template <class T> bool chmax(T &a, const T &b) {
... | [
"identifier.change",
"control_flow.branch.if.condition.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,358,710 | 1,358,711 | u756088996 | cpp |
p03685 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> p_ll;
template <class T> void debug(T itr1, T itr2) {
auto now = itr1;
while (now < itr2) {
cout << *now << " ";
now++;
}
cout << endl;
}
#define repr(i, from, to) for (int i = (int)from; i < (int)to; i++)
#define... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> p_ll;
template <class T> void debug(T itr1, T itr2) {
auto now = itr1;
while (now < itr2) {
cout << *now << " ";
now++;
}
cout << endl;
}
#define repr(i, from, to) for (int i = (int)from; i < (int)to; i++)
#define... | [
"expression.operation.binary.remove"
] | 1,358,712 | 1,358,713 | u680707192 | cpp |
p03685 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_... | [
"literal.string.change",
"literal.string.case.change",
"call.arguments.change"
] | 1,358,716 | 1,358,717 | u096883693 | cpp |
p03685 | #include <bits/stdc++.h>
#include <cassert>
typedef long long int ll;
using namespace std;
#if defined(DEBUG)
#include <sys/fcntl.h>
#include <unistd.h>
#define DLOG(...) cerr << dbgFormat(__VA_ARGS__) << endl
#define DCALL(func, ...) func(__VA_ARGS__)
template <class... Args> string dbgFormat(const char *fmt, Args.... | #include <bits/stdc++.h>
#include <cassert>
typedef long long int ll;
using namespace std;
#if defined(DEBUG)
#include <sys/fcntl.h>
#include <unistd.h>
#define DLOG(...) cerr << dbgFormat(__VA_ARGS__) << endl
#define DCALL(func, ...) func(__VA_ARGS__)
template <class... Args> string dbgFormat(const char *fmt, Args.... | [
"identifier.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 1,358,722 | 1,358,723 | u588093355 | cpp |
p03685 | #include <bits/stdc++.h>
#include <cassert>
typedef long long int ll;
using namespace std;
#if defined(DEBUG)
#include <sys/fcntl.h>
#include <unistd.h>
#define DLOG(...) cerr << dbgFormat(__VA_ARGS__) << endl
#define DCALL(func, ...) func(__VA_ARGS__)
template <class... Args> string dbgFormat(const char *fmt, Args.... | #include <bits/stdc++.h>
#include <cassert>
typedef long long int ll;
using namespace std;
#if defined(DEBUG)
#include <sys/fcntl.h>
#include <unistd.h>
#define DLOG(...) cerr << dbgFormat(__VA_ARGS__) << endl
#define DCALL(func, ...) func(__VA_ARGS__)
template <class... Args> string dbgFormat(const char *fmt, Args.... | [
"identifier.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 1,358,724 | 1,358,723 | u588093355 | cpp |
p03685 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
typedef vector<int> vi... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
typedef vector<int> vi... | [
"assignment.variable.change",
"identifier.change"
] | 1,358,739 | 1,358,740 | u791593901 | cpp |
p03685 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
typedef vector<int> vi... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
typedef vector<int> vi... | [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.branch.if.condition.change",
"assignment.variable.change",
"identifier.change"
] | 1,358,741 | 1,358,740 | u791593901 | cpp |
p03685 | #pragma GCC optimize("O3")
#include <bits/stdc++.h>
#ifdef ONLINE_JUDGE
#define LLD "%I64d"
#else
#define LLD "%lld"
#endif
#define fu(a, b, c) for (int a = b; a <= (int)c; ++a)
#define fd(a, b, c) for (int a = b; a >= (int)c; --a)
#define cu(a, b, c) for (int a = b; a < (int)c; ++a)
#define cd(a, b, c) for (int a = (b... | #pragma GCC optimize("O3")
#include <bits/stdc++.h>
#ifdef ONLINE_JUDGE
#define LLD "%I64d"
#else
#define LLD "%lld"
#endif
#define fu(a, b, c) for (int a = b; a <= (int)c; ++a)
#define fd(a, b, c) for (int a = b; a >= (int)c; --a)
#define cu(a, b, c) for (int a = b; a < (int)c; ++a)
#define cd(a, b, c) for (int a = (b... | [
"expression.operation.binary.remove"
] | 1,358,742 | 1,358,743 | u730731139 | cpp |
p03685 | #include <bits/stdc++.h>
using namespace std;
using Int = long long;
int main() {
int R, C, N;
cin >> R >> C >> N;
map<int, int> M;
auto toindex = [=](int x, int y) {
if (y == 0)
return 0;
if (x == R)
return R + y;
if (y == C)
return R + C + R - x;
if (x == 0)
return R + ... | #include <bits/stdc++.h>
using namespace std;
using Int = long long;
int main() {
int R, C, N;
cin >> R >> C >> N;
map<int, int> M;
auto toindex = [=](int x, int y) {
if (y == 0)
return x;
if (x == R)
return R + y;
if (y == C)
return R + C + R - x;
if (x == 0)
return R + ... | [
"identifier.replace.add",
"literal.replace.remove",
"function.return_value.change"
] | 1,358,748 | 1,358,749 | u449722246 | cpp |
p03685 | #include <algorithm>
#include <cfloat>
#include <complex>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <unordered_map>
#include <vector>
#define fs first
... | #include <algorithm>
#include <cfloat>
#include <complex>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <unordered_map>
#include <vector>
#define fs first
... | [
"identifier.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 1,358,755 | 1,358,756 | u852158538 | cpp |
p03685 | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
const ll INF = 1LL << 60;
const double PI = 3.141592653589793238;
const double EPS = 1e-10;
typedef pair<int, int> P;
int R, C;
int get(int x, int y) {
if (y == 0)
return x;
if (x == C)
return C + y;
if (y == R)
... | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
const ll INF = 1LL << 60;
const double PI = 3.141592653589793238;
const double EPS = 1e-10;
typedef pair<int, int> P;
int R, C;
int get(int x, int y) {
if (y == 0)
return x;
if (x == C)
return C + y;
if (y == R)
... | [
"expression.operation.binary.remove"
] | 1,358,757 | 1,358,758 | u243961437 | cpp |
p03685 | #include "bits/stdc++.h"
using namespace std;
typedef long long LL;
typedef pair<int, int> P;
const LL MOD = 1000000007LL;
vector<P> v;
bool appear[100000];
int main() {
int R, C, N;
cin >> R >> C >> N;
for (int i = 0; i < N; i++) {
int x[2], y[2];
bool ok = 1;
for (int j = 0; j < 2; j++) {
cin ... | #include "bits/stdc++.h"
using namespace std;
typedef long long LL;
typedef pair<int, int> P;
const LL MOD = 1000000007LL;
vector<P> v;
bool appear[100000];
int main() {
int R, C, N;
cin >> R >> C >> N;
for (int i = 0; i < N; i++) {
int x[2], y[2];
bool ok = 1;
for (int j = 0; j < 2; j++) {
cin ... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 1,358,759 | 1,358,760 | u243961437 | cpp |
p03685 | #include "bits/stdc++.h"
using namespace std;
#define ll long long int
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n; i >= 0; i--)
#define REP(i, s, t) for (int i = s; i <= t; i++)
#define RREP(i, s, t) for (int i = s; i >= t; i--)
#define dump(x) cerr << #x << " = " << (x) << endl;
#d... | #include "bits/stdc++.h"
using namespace std;
#define ll long long int
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n; i >= 0; i--)
#define REP(i, s, t) for (int i = s; i <= t; i++)
#define RREP(i, s, t) for (int i = s; i >= t; i--)
#define dump(x) cerr << #x << " = " << (x) << endl;
#d... | [
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove",
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 1,358,761 | 1,358,762 | u965730380 | cpp |
p03685 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
typedef unsigned int uint;
using namespace std;
typedef pair<int, int> P;
int r, c, n;
int calc(int x... | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
typedef unsigned int uint;
using namespace std;
typedef pair<int, int> P;
int r, c, n;
int calc(int x... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 1,358,763 | 1,358,764 | u334624175 | cpp |
p03685 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#define LL long long
#define M 400020
using namespace std;
int read() {
int nm = 0, fh = 1;
int cw = getchar();
for (; !isdigit(cw); cw = getchar())
if (cw == '-')
fh = -fh;
for (; isdigit(cw); cw = getchar(... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#define LL long long
#define M 400020
using namespace std;
int read() {
int nm = 0, fh = 1;
int cw = getchar();
for (; !isdigit(cw); cw = getchar())
if (cw == '-')
fh = -fh;
for (; isdigit(cw); cw = getchar(... | [] | 1,358,778 | 1,358,779 | u141576590 | cpp |
p03685 | #include <bits/stdc++.h>
#define int long long
#define r(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef pair<int, int> P;
typedef pair<int, P> PP;
#define fi first
#define se second
void END() {
cout << "NO" << endl;
exit(0);
}
signed main() {
int h, w, n;
cin >> w >> h >> n;
vector<P> v1, v... | #include <bits/stdc++.h>
#define int long long
#define r(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef pair<int, int> P;
typedef pair<int, P> PP;
#define fi first
#define se second
void END() {
cout << "NO" << endl;
exit(0);
}
signed main() {
int h, w, n;
cin >> w >> h >> n;
vector<P> v1, v... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 1,358,785 | 1,358,786 | u777468981 | cpp |
p03685 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> i_i;
typedef pair<int, i_i> i_i_i;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
// const ll mod = 1000000007;
int main() {
// cout.precision(10);
int r, c, n;
cin >> r >> c >> n;
vector<i_i_i> v;
for (int... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> i_i;
typedef pair<int, i_i> i_i_i;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
// const ll mod = 1000000007;
int main() {
// cout.precision(10);
int r, c, n;
cin >> r >> c >> n;
vector<i_i_i> v;
for (int... | [
"literal.number.change",
"assignment.value.change",
"expression.operation.binary.change",
"identifier.change",
"control_flow.branch.if.condition.change"
] | 1,358,787 | 1,358,788 | u980655160 | cpp |
p03685 | #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 <string>
#include <vector>
using namespace std;
typedef long long ll;
typ... | #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 <string>
#include <vector>
using namespace std;
typedef long long ll;
typ... | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.branch.if.condition.change"
] | 1,358,789 | 1,358,790 | u294531924 | cpp |
p03685 | #define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include <algorithm>
#include <array>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#in... | #define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include <algorithm>
#include <array>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#in... | [
"expression.operation.binary.remove"
] | 1,358,795 | 1,358,796 | u836644468 | cpp |
p03685 | #include <bits/stdc++.h>
using namespace std;
int R, C, N;
struct node {
int u;
int v;
int flag;
} no[200005];
bool cmp(node a, node b) { return a.u < b.u; }
int Change(int x, int y) {
if (x == 0)
return y;
else if (y == C)
return C + y;
else if (x == R)
return R + C + C - y;
else if (y == 0)
... | #include <bits/stdc++.h>
using namespace std;
int R, C, N;
struct node {
int u;
int v;
int flag;
} no[200005];
bool cmp(node a, node b) { return a.u < b.u; }
int Change(int x, int y) {
if (x == 0)
return y;
else if (y == C)
return C + x;
else if (x == R)
return R + C + C - y;
else if (y == 0)
... | [
"identifier.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 1,358,799 | 1,358,800 | u349009650 | cpp |
p03685 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
int n;
int r, c;
int pt[5];
pair<int, int> top[5][100005];
int isedge(int x, int y) {
if (x == 0)
return 1;
if (y == 0)
retu... | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
int n;
int r, c;
int pt[5];
pair<int, int> top[5][100005];
int isedge(int x, int y) {
if (x == 0)
return 1;
if (y == 0)
retu... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 1,358,803 | 1,358,804 | u803345299 | cpp |
p03685 | #include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5;
struct node {
int mode, va, p;
};
node d[maxn << 1];
int c, r, n;
int calc(int x, int y) {
if (y == 0)
return x;
else if (x == r)
return r + y;
else if (y == c)
return r + c + x;
else if (x == 0)
return r + r + c + y;
else
... | #include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5;
struct node {
int mode, va, p;
};
node d[maxn << 1];
int c, r, n;
int calc(int x, int y) {
if (y == 0)
return x;
else if (x == r)
return r + y;
else if (y == c)
return r + c + r - x;
else if (x == 0)
return r + r + c + c - y;
... | [
"expression.operation.binary.add"
] | 1,358,805 | 1,358,806 | u715493708 | cpp |
p03685 | #include <bits/stdc++.h>
#define FOR(i, a, b) for (ll i = (a); i < (ll)(b); i++)
#define REP(i, n) FOR(i, 0, n)
#define YYS(x, arr) for (auto &x : arr)
#define PW(x) (1LL << (x))
#define SZ(x) ((ll)(x).size())
#define pb emplace_back
#define fi first
#define se second
using namespace std;
using ld = long double;
us... | #include <bits/stdc++.h>
#define FOR(i, a, b) for (ll i = (a); i < (ll)(b); i++)
#define REP(i, n) FOR(i, 0, n)
#define YYS(x, arr) for (auto &x : arr)
#define PW(x) (1LL << (x))
#define SZ(x) ((ll)(x).size())
#define pb emplace_back
#define fi first
#define se second
using namespace std;
using ld = long double;
us... | [
"identifier.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 1,358,807 | 1,358,808 | u612341606 | cpp |
p03685 | #include <bits/stdc++.h>
using namespace std;
using P = pair<int, int>;
int R, C, N;
vector<P> edge1, edge2, edge3, edge4;
void append(int x, int y, int i) {
if (y == 0)
edge1.push_back(make_pair(x, i));
else if (x == R)
edge2.push_back(make_pair(y, i));
else if (y == C)
edge3.push_back(make_pair(R ... | #include <bits/stdc++.h>
using namespace std;
using P = pair<int, int>;
int R, C, N;
vector<P> edge1, edge2, edge3, edge4;
void append(int x, int y, int i) {
if (y == 0)
edge1.push_back(make_pair(x, i));
else if (x == R)
edge2.push_back(make_pair(y, i));
else if (y == C)
edge3.push_back(make_pair(R ... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 1,358,809 | 1,358,810 | u110383845 | cpp |
p03685 | // Wrong answer on test inf.
#include <bits/stdc++.h>
#define rep(i, x, y) for (int i = (x); i <= (y); i++)
#define ll long long
#define inf 1000000001
#define pii pair<int, int>
#define fi first
#define se second
#define y1 y1___
using namespace std;
ll read() {
char ch = getchar();
ll x = 0;
int op = 1;
for (... | // Wrong answer on test inf.
#include <bits/stdc++.h>
#define rep(i, x, y) for (int i = (x); i <= (y); i++)
#define ll long long
#define inf 1000000001
#define pii pair<int, int>
#define fi first
#define se second
#define y1 y1___
using namespace std;
ll read() {
char ch = getchar();
ll x = 0;
int op = 1;
for (... | [
"preprocessor.define.value.change",
"literal.integer.change",
"assignment.variable.change",
"identifier.change"
] | 1,358,811 | 1,358,812 | u222216068 | cpp |
p03685 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define stoi stoll
using ll = long long;
using vi = vector<int>;
using pii = pair<int, int>;
#define ALL(c) begin(c), end(c)
#define RALL(c) rbegin(c), rend(c)
#define ITR(i, b, e) for (auto i = (b); i != (e); ++i)
#define FORE(x, c) for (auto &x : c)
... | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define stoi stoll
using ll = long long;
using vi = vector<int>;
using pii = pair<int, int>;
#define ALL(c) begin(c), end(c)
#define RALL(c) rbegin(c), rend(c)
#define ITR(i, b, e) for (auto i = (b); i != (e); ++i)
#define FORE(x, c) for (auto &x : c)
... | [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 1,358,817 | 1,358,818 | u133129810 | cpp |
p03685 | #include <bits/stdc++.h>
using namespace std;
int W, H, N;
vector<pair<int, int>> a;
main() {
cin >> W >> H >> N;
for (int i = 1; i <= N; ++i) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
if (x1 == 0 | x1 == W | y1 == 0 | y1 == H &&
x2 == 0 | x2 == W | y2 == 0 | y2 == H) {
... | #include <bits/stdc++.h>
using namespace std;
int W, H, N;
vector<pair<int, int>> a;
main() {
cin >> W >> H >> N;
for (int i = 1; i <= N; ++i) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
if (x1 == 0 | x1 == W | y1 == 0 | y1 == H &&
x2 == 0 | x2 == W | y2 == 0 | y2 == H) {
... | [
"expression.operation.binary.add"
] | 1,358,819 | 1,358,820 | u283869437 | cpp |
p03685 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, l, r) for (int i = l; i < r; i++)
#define dec(i, l, r) for (int i = l; i >= r; i--)
#define vi vector<int>
#define all(v) v.begin(), v.end()
#define pb(c) push_back(c)
#define vii vector<pair<int, int>>
#define ii pair<int, int>
#define mp(i, j) make_pair(i, ... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, l, r) for (int i = l; i < r; i++)
#define dec(i, l, r) for (int i = l; i >= r; i--)
#define vi vector<int>
#define all(v) v.begin(), v.end()
#define pb(c) push_back(c)
#define vii vector<pair<int, int>>
#define ii pair<int, int>
#define mp(i, j) make_pair(i, ... | [
"identifier.change"
] | 1,358,821 | 1,358,822 | u133517819 | cpp |
p03685 | #include <bits/stdc++.h>
using namespace std;
const int N = 101010;
inline char get(void) {
static char buf[100000], *S = buf, *T = buf;
if (S == T) {
T = (S = buf) + fread(buf, 1, 100000, stdin);
if (S == T)
return EOF;
}
return *S++;
}
template <typename T> inline void read(T &x) {
static ch... | #include <bits/stdc++.h>
using namespace std;
const int N = 101010;
inline char get(void) {
static char buf[100000], *S = buf, *T = buf;
if (S == T) {
T = (S = buf) + fread(buf, 1, 100000, stdin);
if (S == T)
return EOF;
}
return *S++;
}
template <typename T> inline void read(T &x) {
static ch... | [
"identifier.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 1,358,827 | 1,358,828 | u148230246 | cpp |
p03685 | #include <bits/stdc++.h>
using namespace std;
const int N = 101010;
inline char get(void) {
static char buf[100000], *S = buf, *T = buf;
if (S == T) {
T = (S = buf) + fread(buf, 1, 100000, stdin);
if (S == T)
return EOF;
}
return *S++;
}
template <typename T> inline void read(T &x) {
static ch... | #include <bits/stdc++.h>
using namespace std;
const int N = 101010;
inline char get(void) {
static char buf[100000], *S = buf, *T = buf;
if (S == T) {
T = (S = buf) + fread(buf, 1, 100000, stdin);
if (S == T)
return EOF;
}
return *S++;
}
template <typename T> inline void read(T &x) {
static ch... | [
"identifier.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 1,358,829 | 1,358,828 | u148230246 | cpp |
p03685 | #include <bits/stdc++.h>
using namespace std;
#define INF (1LL << 31 - 1)
#define MOD int(1e9 + 7)
#define repi(i, j, n) for (int i = (j); i < (n); ++i)
#define rep(i, n) repi(i, 0, n)
#define fi first
#define se second
#define all(v) (v).begin(), (v).end()
inline void init() {
cin.tie(0);
ios::sync_with_stdio(fa... | #include <bits/stdc++.h>
using namespace std;
#define INF (1LL << 31 - 1)
#define MOD int(1e9 + 7)
#define repi(i, j, n) for (int i = (j); i < (n); ++i)
#define rep(i, n) repi(i, 0, n)
#define fi first
#define se second
#define all(v) (v).begin(), (v).end()
inline void init() {
cin.tie(0);
ios::sync_with_stdio(fa... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 1,358,832 | 1,358,833 | u294283114 | cpp |
p03685 | #include <bits/stdc++.h>
#define fi first
#define se second
using namespace std;
typedef pair<int, int> pi;
const int N = 200005;
int R, C;
int ID() {
static int x, y;
scanf("%d%d", &x, &y);
if (x != R && x != 0 || y != C && y != 0)
return -1;
if (y == 0)
return x;
if (x == R)
return y + R;
if... | #include <bits/stdc++.h>
#define fi first
#define se second
using namespace std;
typedef pair<int, int> pi;
const int N = 200005;
int R, C;
int ID() {
static int x, y;
scanf("%d%d", &x, &y);
if (x != R && x != 0 && y != C && y != 0)
return -1;
if (y == 0)
return x;
if (x == R)
return y + R;
if... | [
"misc.opposites",
"control_flow.branch.if.condition.change"
] | 1,358,836 | 1,358,837 | u729132437 | cpp |
p03685 | #include <bits/stdc++.h>
#define fi first
#define se second
using namespace std;
typedef pair<int, int> pi;
const int N = 200005;
int R, C;
int ID() {
static int x, y;
scanf("%d%d", &x, &y);
if (x != R && x != 0 || y != C && y != 0)
return -1;
if (y == 0)
return x;
if (x == R)
return y + R;
if... | #include <bits/stdc++.h>
#define fi first
#define se second
using namespace std;
typedef pair<int, int> pi;
const int N = 200005;
int R, C;
int ID() {
static int x, y;
scanf("%d%d", &x, &y);
if (x != R && x != 0 && y != C && y != 0)
return -1;
if (y == 0)
return x;
if (x == R)
return y + R;
if... | [
"misc.opposites",
"control_flow.branch.if.condition.change",
"assignment.value.change"
] | 1,358,838 | 1,358,837 | u729132437 | cpp |
p03685 | #include <bits/stdc++.h>
#define inf 200000000
using namespace std;
int r, c, n, top;
int check(int x, int y) {
if (y == 0)
return inf + x;
if (x == c)
return 2 * inf + y;
if (y == r)
return 3 * inf - x;
if (x == 0)
return 4 * inf - y;
return 0;
}
pair<int, int> st[200010];
map<int, int> mp;
u... | #include <bits/stdc++.h>
#define inf 200000000
using namespace std;
int r, c, n, top;
int check(int x, int y) {
if (y == 0)
return inf + x;
if (x == r)
return 2 * inf + y;
if (y == c)
return 3 * inf - x;
if (x == 0)
return 4 * inf - y;
return 0;
}
pair<int, int> st[200010];
map<int, int> mp;
u... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 1,358,845 | 1,358,846 | u053327001 | cpp |
p03685 | #include <bits/stdc++.h>
#define N 100009
#define M 3000009
using namespace std;
int n, m, cnt, rt, trtot, H, W, ls[M], rs[M];
bool bo[M];
struct node {
int x, y;
} a[N];
bool cmp(node u, node v) { return u.x < v.x; }
int calc(int x, int y) {
if (x && y && x < H && y < H)
return 0;
if (!x)
return y + 1;
... | #include <bits/stdc++.h>
#define N 100009
#define M 3000009
using namespace std;
int n, m, cnt, rt, trtot, H, W, ls[M], rs[M];
bool bo[M];
struct node {
int x, y;
} a[N];
bool cmp(node u, node v) { return u.x < v.x; }
int calc(int x, int y) {
if (x && y && x < H && y < W)
return 0;
if (!x)
return y + 1;
... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 1,358,847 | 1,358,848 | u070528238 | cpp |
p03685 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <ss... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <ss... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 1,358,855 | 1,358,856 | u120810144 | cpp |
p03685 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <ss... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <ss... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 1,358,857 | 1,358,856 | u120810144 | cpp |
p03685 | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
using namespace std;
typedef long long ll;
const int N = 1e5 + 11, INF = ~0u >> 2;
struct Point {
int pos, x, y, id;
} p[N << 2];
int h, w, n, cnt, S[N << 2], top;
bool cmp(Point a, Point b) {
if (a.pos != ... | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
using namespace std;
typedef long long ll;
const int N = 1e5 + 11, INF = ~0u >> 2;
struct Point {
int pos, x, y, id;
} p[N << 2];
int h, w, n, cnt, S[N << 2], top;
bool cmp(Point a, Point b) {
if (a.pos != ... | [
"identifier.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 1,358,860 | 1,358,861 | u457721459 | cpp |
p03685 | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
using namespace std;
typedef long long ll;
const int N = 1e5 + 11, INF = ~0u >> 2;
struct Point {
int pos, x, y, id;
} p[N << 2];
int h, w, n, cnt, S[N], top;
bool cmp(Point a, Point b) {
if (a.pos != b.pos... | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
using namespace std;
typedef long long ll;
const int N = 1e5 + 11, INF = ~0u >> 2;
struct Point {
int pos, x, y, id;
} p[N << 2];
int h, w, n, cnt, S[N << 2], top;
bool cmp(Point a, Point b) {
if (a.pos != ... | [
"identifier.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 1,358,862 | 1,358,861 | u457721459 | cpp |
p03685 | #include <bits/stdc++.h>
using namespace std;
#define rep2(x, fr, to) for (int(x) = (fr); (x) < (to); (x)++)
#define rep(x, to) for (int(x) = 0; (x) < (to); (x)++)
#define repr(x, fr, to) for (int(x) = (fr); (x) >= (to); (x)--)
#define all(c) (c).begin(), (c).end()
#define sz(v) (int)(v).size()
typedef uint64_t ll;
... | #include <bits/stdc++.h>
using namespace std;
#define rep2(x, fr, to) for (int(x) = (fr); (x) < (to); (x)++)
#define rep(x, to) for (int(x) = 0; (x) < (to); (x)++)
#define repr(x, fr, to) for (int(x) = (fr); (x) >= (to); (x)--)
#define all(c) (c).begin(), (c).end()
#define sz(v) (int)(v).size()
typedef uint64_t ll;
... | [
"expression.operation.binary.remove"
] | 1,358,863 | 1,358,864 | u714564133 | cpp |
p03687 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = 1e9 + 7;
const long long INF = 1e15;
bool check(string s, char f) {
int n = s.size();
for (int i = 0; i < n; i++) {
if (s[i] != f)
return false;
}
return true;
}
int main() {
string s;
cin >> s;
int ans = mod;
... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = 1e9 + 7;
const long long INF = 1e15;
bool check(string s, char f) {
int n = s.size();
for (int i = 0; i < n; i++) {
if (s[i] != f)
return false;
}
return true;
}
int main() {
string s;
cin >> s;
int ans = mod;
... | [
"variable_declaration.type.primitive.change",
"control_flow.loop.condition.change",
"expression.operation.binary.remove",
"control_flow.loop.for.condition.change"
] | 1,358,872 | 1,358,873 | u191484928 | cpp |
p03687 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = 1e9 + 7;
const long long INF = 1e15;
bool check(string s, char f) {
int n = s.size();
for (int i = 0; i < n; i++) {
if (s[i] != f)
return false;
}
return true;
}
int main() {
string s;
cin >> s;
int ans = mod;
... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = 1e9 + 7;
const long long INF = 1e15;
bool check(string s, char f) {
int n = s.size();
for (int i = 0; i < n; i++) {
if (s[i] != f)
return false;
}
return true;
}
int main() {
string s;
cin >> s;
int ans = mod;
... | [
"variable_declaration.type.primitive.change",
"control_flow.loop.condition.change",
"expression.operation.binary.remove"
] | 1,358,874 | 1,358,873 | u191484928 | cpp |
p03687 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
#define rep(i, s, n) for (int i = s; i < (int)(n); i++)
int main() {
string s;
cin >> s;
reverse(s.begin(), s.end());
int ans = 1e9;
rep(i, 0, 26) {
bool df = true;
int dc = 0, cc = 0, tmp = 0;
rep(j, 0,... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
#define rep(i, s, n) for (int i = s; i < (int)(n); i++)
int main() {
string s;
cin >> s;
reverse(s.begin(), s.end());
int ans = 1e9;
rep(i, 0, 26) {
bool df = true;
int dc = 0, cc = 0, tmp = 0;
rep(j, 0,... | [
"expression.operation.binary.remove"
] | 1,358,877 | 1,358,878 | u634967948 | cpp |
p03687 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define repl(i, l, r) for (ll i = (l); i < (r); i++)
#define per(i, n) for (ll i = n - 1; i >= 0; i--)
#define perl(i, r, l) for (ll i = r - 1; i >= l; i--)
#define fi first
#define se second
#define pb push... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define repl(i, l, r) for (ll i = (l); i < (r); i++)
#define per(i, n) for (ll i = n - 1; i >= 0; i--)
#define perl(i, r, l) for (ll i = r - 1; i >= l; i--)
#define fi first
#define se second
#define pb push... | [
"assignment.add"
] | 1,358,885 | 1,358,886 | u722640678 | cpp |
p03687 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define zero_pad(num) setfill('0') << std::right << setw(num)
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
int main() {
string s;
cin >> s;
int n = s.size();
set<char> se;
rep(i, n) se.ins... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define zero_pad(num) setfill('0') << std::right << setw(num)
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
int main() {
string s;
cin >> s;
int n = s.size();
set<char> se;
rep(i, n) se.ins... | [
"expression.operation.binary.remove"
] | 1,358,887 | 1,358,888 | u068713120 | cpp |
p03687 | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int N = s.size();
s += '?';
int ans = 100;
for (char i = 'a'; i <= 'z'; i++) {
int a = 0;
int b = 0;
for (int j = 0; j <= N; j++)
if (s.at(j) != i && s.at(j) != '?')
a++;
else {
if (a < b)
... | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int N = s.size();
s += '?';
int ans = 100;
for (char i = 'a'; i <= 'z'; i++) {
int a = 0;
int b = 0;
for (int j = 0; j <= N; j++)
if (s.at(j) != i && s.at(j) != '?')
a++;
else {
if (b < a)
... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 1,358,896 | 1,358,897 | u101018317 | cpp |
p03687 | #include <bits/stdc++.h>
#define pb push_back
#define rep(i, n) for (int i = 0; i < (n); i++)
#define reps(i, n, s) for (int i = (s); i < (n); i++)
#define rrep(i, n) for (int i = (n - 1); i >= 0; i--)
#define rreps(i, n, s) for (int i = s; i >= n; i--)
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
... | #include <bits/stdc++.h>
#define pb push_back
#define rep(i, n) for (int i = 0; i < (n); i++)
#define reps(i, n, s) for (int i = (s); i < (n); i++)
#define rrep(i, n) for (int i = (n - 1); i >= 0; i--)
#define rreps(i, n, s) for (int i = s; i >= n; i--)
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
... | [
"assignment.change"
] | 1,358,908 | 1,358,909 | u438265890 | cpp |
p03687 | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
#define cinf(n, x, y) \
for (int i = 0; i < (n); i++) \
cin >> x[i] >> y[i];
typedef long long int ll;
using names... | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
#define cinf(n, x, y) \
for (int i = 0; i < (n); i++) \
cin >> x[i] >> y[i];
typedef long long int ll;
using names... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 1,358,916 | 1,358,917 | u928536113 | cpp |
p03687 | #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 INF 2e9
#define MOD 1000000007
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
using P = pair<int, int>;
int main(... | #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 INF 2e9
#define MOD 1000000007
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
using P = pair<int, int>;
int main(... | [
"literal.number.change",
"variable_declaration.value.change"
] | 1,358,918 | 1,358,919 | u135626132 | cpp |
p03687 | #include <bits/stdc++.h>
#define rep(i, n) for (long long int i = 0; i < n; i++)
#define _rep(i, m, n) for (long long int i = m; i < n; i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
// const int N = 1000000;
const ll mod = 1000000007;
using Graph = vector<vector<int>>;
const int dx[4] = {1, ... | #include <bits/stdc++.h>
#define rep(i, n) for (long long int i = 0; i < n; i++)
#define _rep(i, m, n) for (long long int i = m; i < n; i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
// const int N = 1000000;
const ll mod = 1000000007;
using Graph = vector<vector<int>>;
const int dx[4] = {1, ... | [
"call.arguments.change"
] | 1,358,920 | 1,358,921 | u999788719 | cpp |
p03687 | #include <bits/stdc++.h>
#include <stdlib.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> llP;
int main() {
string s;
cin >> s;
bool past[26];
for (int i = 0; i < 26; i++)
past[i] = false;
int ans = 1000;
for (int i = 0; i < s.size(); i++) {
char a = s[i... | #include <bits/stdc++.h>
#include <stdlib.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> llP;
int main() {
string s;
cin >> s;
bool past[26];
for (int i = 0; i < 26; i++)
past[i] = false;
int ans = 1000;
for (int i = 0; i < s.size(); i++) {
char a = s[i... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 1,358,924 | 1,358,925 | u201553784 | cpp |
p03687 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF 1LL << 62
#define inf 1000000007
ll now[26], ans[26];
int main() {
string s;
cin >> s;
for (ll i = 0; i < 26; i++) {
now[i] = -1;
}
for (ll i = 0; i < s.size(); i++) {
ll no = s[i] - 'a';
ans[no] = max(ans[no], i - no... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF 1LL << 62
#define inf 1000000007
ll now[26], ans[26];
int main() {
string s;
cin >> s;
for (ll i = 0; i < 26; i++) {
now[i] = -1;
}
for (ll i = 0; i < s.size(); i++) {
ll no = s[i] - 'a';
ans[no] = max(ans[no], i - no... | [
"assignment.change"
] | 1,358,928 | 1,358,929 | u166378830 | cpp |
p03687 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define PI 3.14159265358979323846
constexpr int INF = numeric_limits<int>::max() / 2;
constexpr long long INFL = numeric_limits<long long>::max() / 2;
constexpr int MOD = 1000000007;
using Graph = vector<vector<int>>;
in... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define PI 3.14159265358979323846
constexpr int INF = numeric_limits<int>::max() / 2;
constexpr long long INFL = numeric_limits<long long>::max() / 2;
constexpr int MOD = 1000000007;
using Graph = vector<vector<int>>;
in... | [
"literal.number.change",
"assignment.value.change",
"assignment.change"
] | 1,358,932 | 1,358,933 | u093973314 | cpp |
p03687 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define PI 3.14159265358979323846
constexpr int INF = numeric_limits<int>::max() / 2;
constexpr long long INFL = numeric_limits<long long>::max() / 2;
constexpr int MOD = 1000000007;
using Graph = vector<vector<int>>;
in... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define PI 3.14159265358979323846
constexpr int INF = numeric_limits<int>::max() / 2;
constexpr long long INFL = numeric_limits<long long>::max() / 2;
constexpr int MOD = 1000000007;
using Graph = vector<vector<int>>;
in... | [
"literal.number.change",
"assignment.value.change",
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove",
"expression.operation.binary.remove"
] | 1,358,934 | 1,358,933 | u093973314 | cpp |
p03687 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define PI 3.14159265358979323846
constexpr int INF = numeric_limits<int>::max() / 2;
constexpr long long INFL = numeric_limits<long long>::max() / 2;
constexpr int MOD = 1000000007;
using Graph = vector<vector<int>>;
in... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define PI 3.14159265358979323846
constexpr int INF = numeric_limits<int>::max() / 2;
constexpr long long INFL = numeric_limits<long long>::max() / 2;
constexpr int MOD = 1000000007;
using Graph = vector<vector<int>>;
in... | [
"literal.number.change",
"assignment.value.change",
"expression.operation.binary.remove"
] | 1,358,935 | 1,358,933 | u093973314 | cpp |
p03687 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef string str;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vint;
typedef vector<double> vdou;
typedef vector<ll> vll;
typedef vector<vint> vvint;
typedef vector<str> vstr;
typedef vector<pii> vpii;
typedef vector<pll... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef string str;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vint;
typedef vector<double> vdou;
typedef vector<ll> vll;
typedef vector<vint> vvint;
typedef vector<str> vstr;
typedef vector<pii> vpii;
typedef vector<pll... | [
"identifier.change",
"call.arguments.change"
] | 1,358,936 | 1,358,937 | u852449189 | cpp |
p03687 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
string s;
cin >> s;
set<char> obj;
for (int i = 0; i < s.size(); i++)
obj.insert(s.at(i));
ll cnt = 0, res = 1e+10;
if (obj.size() == 1)
res = 1;
for (auto c : obj) {
string str = s;
bool f = true;
cnt =... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
string s;
cin >> s;
set<char> obj;
for (int i = 0; i < s.size(); i++)
obj.insert(s.at(i));
ll cnt = 0, res = 1e+10;
if (obj.size() == 1)
res = 0;
for (auto c : obj) {
string str = s;
bool f = true;
cnt =... | [
"literal.number.change",
"assignment.value.change"
] | 1,358,938 | 1,358,939 | u050087249 | cpp |
p03687 | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = int(a); i < int(b); i++)
typedef vector<int> vi;
typedef long long ll;
int main() {
string s;
int a[110], d[200], MAX, Dc = -1;
rep(i, 0, 200) d[i] = 0;
cin >> s;
int N = s.size();
rep(i, 0, N) { a[i] = ... | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = int(a); i < int(b); i++)
typedef vector<int> vi;
typedef long long ll;
int main() {
string s;
int a[110], d[200], MAX, Dc = -1;
rep(i, 0, 200) d[i] = -1;
cin >> s;
int N = s.size();
rep(i, 0, N) { a[i] =... | [
"literal.number.change",
"assignment.value.change"
] | 1,358,952 | 1,358,953 | u293156359 | cpp |
p03687 | #include <bits/stdc++.h>
#define rep(i, n) for (long long i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s;
cin >> s;
int n = s.size();
int alp[26] = {};
rep(i, n) { alp[s[i] - 'a']++; }
vecto... | #include <bits/stdc++.h>
#define rep(i, n) for (long long i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s;
cin >> s;
int n = s.size();
int alp[26] = {};
rep(i, n) { alp[s[i] - 'a']++; }
vecto... | [
"expression.operation.binary.remove"
] | 1,358,956 | 1,358,957 | u371149954 | cpp |
p03687 | #include "bits/stdc++.h"
using namespace std;
int main() {
string s;
cin >> s;
int ans;
if (count(s.begin(), s.end(), s.at(0)) == s.size()) {
ans = 0;
} else {
ans = s.size() / 2;
}
for (int i = 0; i < ans; i++) {
int d1 = i;
int d2 = s.size();
int p = i;
for (int j = i + 1; j <... | #include "bits/stdc++.h"
using namespace std;
int main() {
string s;
cin >> s;
int ans;
if (count(s.begin(), s.end(), s.at(0)) == s.size()) {
ans = 0;
} else {
ans = s.size() / 2;
}
for (int i = 0; i < ans; i++) {
int d1 = i;
int d2 = s.size();
int p = i;
for (int j = i + 1; j <... | [
"assignment.change"
] | 1,358,958 | 1,358,959 | u251410638 | cpp |
p03687 | #include "bits/stdc++.h"
using namespace std;
int main() {
string s;
cin >> s;
int ans;
if (count(s.begin(), s.end(), s.at(0)) == s.size()) {
ans = 0;
} else {
ans = s.size() / 2;
}
for (int i = 0; i < ans; i++) {
int d1 = 0;
int d2 = s.size();
int p = i;
// cout << "ch=" << s.... | #include "bits/stdc++.h"
using namespace std;
int main() {
string s;
cin >> s;
int ans;
if (count(s.begin(), s.end(), s.at(0)) == s.size()) {
ans = 0;
} else {
ans = s.size() / 2;
}
for (int i = 0; i < ans; i++) {
int d1 = i;
int d2 = s.size();
int p = i;
for (int j = i + 1; j <... | [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove",
"assignment.change"
] | 1,358,960 | 1,358,959 | u251410638 | cpp |
p03687 | #include <bits/stdc++.h>
using namespace std;
char alphas[26] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
int main() {
string s;
cin >> s;
int ans = 1000;
int siz = s.size();
for ... | #include <bits/stdc++.h>
using namespace std;
char alphas[26] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
int main() {
string s;
cin >> s;
int ans = 1000;
int siz = s.size();
for ... | [
"expression.operation.binary.remove",
"assignment.change"
] | 1,358,961 | 1,358,962 | u926416331 | cpp |
p03687 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_set>
#include <vector>
#define rep(i, a) for (int i = (int)0; i ... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_set>
#include <vector>
#define rep(i, a) for (int i = (int)0; i ... | [
"assignment.change"
] | 1,358,970 | 1,358,971 | u698883164 | cpp |
p03687 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
signed main() {
string s;
cin >> s;
int ans = s.size();
rep(i, s.size()) {
int cnt = 0;
int tmp = 0;
... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
signed main() {
string s;
cin >> s;
int ans = s.size();
rep(i, 26) {
int cnt = 0;
int tmp = 0;
r... | [
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change",
"call.remove"
] | 1,358,974 | 1,358,975 | u828388155 | cpp |
p03687 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define rep(i, a, b) for (int i = a; i < (b); ++i)
#define p(s) std::cout << s;
#define pl(s) std::cout << s << endl;
#define printIf(j, s1, s2) cout << (j ? s1 : s2) << endl;
#define YES(j) cout << (j ? "YES" : "NO") << endl... | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define rep(i, a, b) for (int i = a; i < (b); ++i)
#define p(s) std::cout << s;
#define pl(s) std::cout << s << endl;
#define printIf(j, s1, s2) cout << (j ? s1 : s2) << endl;
#define YES(j) cout << (j ? "YES" : "NO") << endl... | [
"expression.operation.binary.remove"
] | 1,358,985 | 1,358,986 | u491550356 | cpp |
p03687 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <list>
#include <map>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define REP(i, n) for (i = 0; i < n; i++)
#define REPR(i, n) for (i = n; i >= 0; i--)
#define FOR(i, m, n) for (i = m; i < n; i++)
#define max(a, b) ((a) > (b) ? (... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <list>
#include <map>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define REP(i, n) for (i = 0; i < n; i++)
#define REPR(i, n) for (i = n; i >= 0; i--)
#define FOR(i, m, n) for (i = m; i < n; i++)
#define max(a, b) ((a) > (b) ? (... | [
"control_flow.branch.if.condition.change"
] | 1,359,060 | 1,359,061 | u768152935 | cpp |
p03687 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i < n; i++)
#define int64 long long
#define yokuwaruprime (10 * 10 * 10 * 10 * 10 * 10 * 10 * 10 * 10 + 7)
usin... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i < n; i++)
#define int64 long long
#define yokuwaruprime (10 * 10 * 10 * 10 * 10 * 10 * 10 * 10 * 10 + 7)
usin... | [
"literal.number.change",
"variable_declaration.value.change"
] | 1,359,064 | 1,359,065 | u170301438 | cpp |
p03687 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
string s;
cin >> s;
int ans = 111;
for (int i = 0; i < (int)s.size(); i++) {
char c = s[i];
int cnt = 0, num = 0;
for (int j = 0; j < (int)s.size(); j++) {
if (s[j] == c) {
cnt = max(cnt, j - num);
... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
string s;
cin >> s;
int ans = 111;
for (int i = 0; i < (int)s.size(); i++) {
char c = s[i];
int cnt = 0, num = 0;
for (int j = 0; j < (int)s.size(); j++) {
if (s[j] == c) {
cnt = max(cnt, j - num);
... | [
"expression.operation.binary.remove"
] | 1,359,066 | 1,359,067 | u374929478 | cpp |
p03687 | #include <bits/stdc++.h>
using namespace std;
string s;
int ans = 100, now, mx;
char i;
main() {
cin >> s;
for (i = 'a'; i <= 'z'; i++) {
now = 0, mx = 0;
for (auto c : s) {
if (c == i)
now = 0;
else
mx = max(mx, now++);
}
ans = min(ans, mx);
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
string s;
int ans = 100, now, mx;
char i;
main() {
cin >> s;
for (i = 'a'; i <= 'z'; i++) {
now = 0, mx = 0;
for (auto c : s) {
if (c == i)
now = 0;
else
mx = max(mx, ++now);
}
ans = min(ans, mx);
}
cout << ans << endl;
}
| [
"call.arguments.change"
] | 1,359,071 | 1,359,073 | u743561048 | cpp |
p03687 | #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 <unordered_map>
#include <utility>
#in... | #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 <unordered_map>
#include <utility>
#in... | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.remove",
"assignment.change"
] | 1,359,074 | 1,359,075 | u294531924 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.