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 9
values |
|---|---|---|---|---|---|---|---|
p03017 | #include <bits/stdc++.h>
using namespace std;
bool isChangeble(int start, int goal, string s) {
int p = start;
int num = 0;
while (p < goal) {
if (s[p] == '.') {
num += 1;
p += 1;
if (num == 3) {
return true;
}
continue;
} else {
num = 0;
p += 1;
co... | #include <bits/stdc++.h>
using namespace std;
bool isChangeble(int start, int goal, string s) {
int p = start;
int num = 0;
while (p < goal) {
if (s[p] == '.') {
num += 1;
p += 1;
if (num == 3) {
return true;
}
continue;
} else {
num = 0;
p += 1;
co... | [
"misc.opposites",
"identifier.change",
"call.function.change",
"control_flow.branch.if.condition.change"
] | 832,332 | 832,330 | u679245300 | cpp |
p03017 | #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, a, b) for (int i = (a); i < (b); ++i)
#define FORR(i, a, b) for (int i = b - 1; i >= a; --i)
#define p(s) cout << (s) << endl
#define p2(s, t) cout << (s) << " " << (t) << endl
#define A... | #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, a, b) for (int i = (a); i < (b); ++i)
#define FORR(i, a, b) for (int i = b - 1; i >= a; --i)
#define p(s) cout << (s) << endl
#define p2(s, t) cout << (s) << " " << (t) << endl
#define A... | [
"call.arguments.change",
"call.arguments.add"
] | 832,333 | 832,334 | u839397805 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
a--, b--, c--, d--;
int ok = 1;
for (int i = a; i < c; i++... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
a--, b--, c--, d--;
int ok = 1;
for (int i = a; i < c; i++... | [
"control_flow.loop.for.initializer.change"
] | 832,335 | 832,336 | u440032761 | cpp |
p03017 | #include <iostream>
#include <string>
using namespace std;
int main() {
long long N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
string ans = "Yes";
if (C > D) {
for (long long i = B - 2; i < D - 2; i++) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.') {
ans = "Y... | #include <iostream>
#include <string>
using namespace std;
int main() {
long long N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
string ans = "Yes";
if (C > D) {
for (long long i = B - 2; i < D - 1; i++) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.') {
ans = "Y... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 832,345 | 832,346 | u940000534 | cpp |
p03017 | #include <iostream>
#include <string>
using namespace std;
int main() {
long long N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
string ans = "Yes";
if (C > D) {
for (long long i = B - 1; i < D - 2; i++) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.') {
ans = "Y... | #include <iostream>
#include <string>
using namespace std;
int main() {
long long N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
string ans = "Yes";
if (C > D) {
for (long long i = B - 2; i < D - 1; i++) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.') {
ans = "Y... | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 832,347 | 832,346 | u940000534 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
A--;
B--;
C--;
D--;
string S;
cin >> S;
bool yesA = true;
bool yesB = true;
int cnt = 0; // check # count
for (int i = A; i <= C; i++) {
if (S[i] == '#')
cnt++;
else
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
A--;
B--;
C--;
D--;
string S;
cin >> S;
bool yesA = true;
bool yesB = true;
int cnt = 0; // check # count
for (int i = A; i <= C; i++) {
if (S[i] == '#')
cnt++;
else
... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 832,348 | 832,349 | u761335395 | cpp |
p03017 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const double... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const double... | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change"
] | 832,350 | 832,351 | u269278772 | cpp |
p03017 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const double... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const double... | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 832,352 | 832,351 | u269278772 | cpp |
p03017 | #include <bits/stdc++.h>
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define fu(i, r, t) for (int i = r; i... | #include <bits/stdc++.h>
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define fu(i, r, t) for (int i = r; i... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 832,353 | 832,354 | u020160935 | cpp |
p03017 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <iostream>
#include <math.h>
#include <string>
#include <utility>
#include <vector>
#define INF 1000000000;
using namespace std;
char mas[200500];
int main() {
int N = 0, A = 0, B = 0, C = 0, D = 0;
cin >> N >> A >> B >> C >> D;
for (int i = 0; i <... | #include <algorithm>
#include <cassert>
#include <cmath>
#include <iostream>
#include <math.h>
#include <string>
#include <utility>
#include <vector>
#define INF 1000000000;
using namespace std;
char mas[200500];
int main() {
int N = 0, A = 0, B = 0, C = 0, D = 0;
cin >> N >> A >> B >> C >> D;
for (int i = 0; i <... | [
"control_flow.loop.for.initializer.change"
] | 832,365 | 832,366 | u019465635 | cpp |
p03017 | #ifdef _WIN32
#define DEBUG 1
#endif
#define _CRT_SECURE_NO_WARNINGS
#define MATH_PI 3.14159265358979323846264338327950288419716939
#include <fstream>
#include <iostream>
#include <math.h>
#include <string.h>
using namespace std;
#ifdef DEBUG
#include "include.h"
#else
inline void wait() {}
inline void dout(const cha... | #ifdef _WIN32
#define DEBUG 1
#endif
#define _CRT_SECURE_NO_WARNINGS
#define MATH_PI 3.14159265358979323846264338327950288419716939
#include <fstream>
#include <iostream>
#include <math.h>
#include <string.h>
using namespace std;
#ifdef DEBUG
#include "include.h"
#else
inline void wait() {}
inline void dout(const cha... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 832,381 | 832,380 | u575781793 | cpp |
p03017 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#inc... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#inc... | [
"expression.operation.binary.remove"
] | 832,382 | 832,383 | u391331433 | cpp |
p03017 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#inc... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#inc... | [
"expression.operation.binary.remove",
"identifier.change",
"control_flow.branch.if.condition.change"
] | 832,384 | 832,383 | u391331433 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
#define REP(i, a, n) for (int i = a; i < n; ++i)
#define REPR(i, a, n) for (int i = a; i > n; --i)
#define RUP(a, b) ((a + b - 1) / (b))
#define SORTG(v) sort(v.begin(), v.end(), greater<>())
#define SORT(v) sort(v.begin(), v.end())
... | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
#define REP(i, a, n) for (int i = a; i < n; ++i)
#define REPR(i, a, n) for (int i = a; i > n; --i)
#define RUP(a, b) ((a + b - 1) / (b))
#define SORTG(v) sort(v.begin(), v.end(), greater<>())
#define SORT(v) sort(v.begin(), v.end())
... | [
"expression.operation.binary.add"
] | 832,385 | 832,386 | u635484372 | cpp |
p03017 | #include <iostream>
#include <algorithm>
#include <cmath>
#include <iomanip>
// array
#include <map>
#include <set>
#include <vector>
using namespace std;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
if (c > d) {
//追い越し確認
bool oikosu = false;
for (int i = b... | #include <iostream>
#include <algorithm>
#include <cmath>
#include <iomanip>
// array
#include <map>
#include <set>
#include <vector>
using namespace std;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
if (c > d) {
//追い越し確認
bool oikosu = false;
for (int i = b... | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 832,398 | 832,399 | u466161487 | cpp |
p03017 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int N, A, B, C, D;
string S;
int CHECK(void) {
for (int i = B + 1; i <= D; i++) {
if ((S[i] == '#') && (S[i - 1] == '#')) {
return -1;
}
}
for (int i = A + 1; i <= C; i++) {
if ((S[i] == '#') &... | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int N, A, B, C, D;
string S;
int CHECK(void) {
for (int i = B + 1; i <= D; i++) {
if ((S[i] == '#') && (S[i - 1] == '#')) {
return -1;
}
}
for (int i = A + 1; i <= C; i++) {
if ((S[i] == '#') &... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 832,407 | 832,408 | u835297884 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
/*{{{*/ // template
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
constexpr int INF = numeric_limits<int>::max() / 2;
constexpr long long LINF = numeric_limits<long long>::max() / 3;
#define pb push_back
#define eb ... | #include <bits/stdc++.h>
using namespace std;
/*{{{*/ // template
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
constexpr int INF = numeric_limits<int>::max() / 2;
constexpr long long LINF = numeric_limits<long long>::max() / 3;
#define pb push_back
#define eb ... | [
"control_flow.loop.for.initializer.change"
] | 832,414 | 832,415 | u013750540 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repr(i, b, e) for (int i = (b); i <= (e); i++)
#define pr(x) \
do { ... | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repr(i, b, e) for (int i = (b); i <= (e); i++)
#define pr(x) \
do { ... | [
"expression.operation.binary.remove"
] | 832,416 | 832,417 | u674402178 | cpp |
p03017 | // by xxj
#include <bits/stdc++.h>
using namespace std;
#define fst first
#define snd second
#define mp make_pair
#define ll long long
#define pii pair<int, int>
#define lowbit(x) x & -x
const int inf = 1e9 + 7;
const double eps = 1e-10;
const ll linf = 1e18 + 7;
const ll hh = 523;
// const int mod=;
string s;
int main... | // by xxj
#include <bits/stdc++.h>
using namespace std;
#define fst first
#define snd second
#define mp make_pair
#define ll long long
#define pii pair<int, int>
#define lowbit(x) x & -x
const int inf = 1e9 + 7;
const double eps = 1e-10;
const ll linf = 1e18 + 7;
const ll hh = 523;
// const int mod=;
string s;
int main... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 832,420 | 832,421 | u776618439 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
using namespace std;
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
int maxcd = C;
if (D > C)
maxcd = D;
for (int i = A - 1; i < maxcd; i++) {
if (S[i] == '#') {
if (S[i + 1] == '... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
using namespace std;
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
int maxcd = C;
if (D > C)
maxcd = D;
for (int i = A - 1; i < maxcd; i++) {
if (S[i] == '#') {
if (S[i + 1] == '... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 832,422 | 832,423 | u772041670 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
using namespace std;
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
int maxcd = C;
if (D > C)
maxcd = D;
for (int i = A - 1; i < maxcd; i++) {
if (S[i] == '#') {
if (S[i + 1] == '... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
using namespace std;
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
int maxcd = C;
if (D > C)
maxcd = D;
for (int i = A - 1; i < maxcd; i++) {
if (S[i] == '#') {
if (S[i + 1] == '... | [
"identifier.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 832,424 | 832,423 | u772041670 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
using namespace std;
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
int maxcd = C;
if (D > C)
maxcd = D;
for (int i = A - 1; i < maxcd; i++) {
if (S[i] == '#') {
if (S[i + 1] == '... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
using namespace std;
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
int maxcd = C;
if (D > C)
maxcd = D;
for (int i = A - 1; i < maxcd; i++) {
if (S[i] == '#') {
if (S[i + 1] == '... | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change",
"identifier.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 832,425 | 832,423 | u772041670 | cpp |
p03017 | #include <algorithm>
#include <iostream>
#include <list>
#include <math.h>
#include <stdio.h>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using vec = vector<int>;
using mat = vector<vec>;
using lst = list<int>;
int main() {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >>... | #include <algorithm>
#include <iostream>
#include <list>
#include <math.h>
#include <stdio.h>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using vec = vector<int>;
using mat = vector<vec>;
using lst = list<int>;
int main() {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >>... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 832,426 | 832,427 | u765606693 | cpp |
p03017 | #include <algorithm>
#include <iostream>
#include <list>
#include <math.h>
#include <stdio.h>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using vec = vector<int>;
using mat = vector<vec>;
using lst = list<int>;
int main() {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >>... | #include <algorithm>
#include <iostream>
#include <list>
#include <math.h>
#include <stdio.h>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using vec = vector<int>;
using mat = vector<vec>;
using lst = list<int>;
int main() {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >>... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 832,428 | 832,427 | u765606693 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <iterator>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define mems(p) memset(p, 0, sizeof(p))
#define mp make_pair
void fast() {
ios_base::sync_... | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <iterator>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define mems(p) memset(p, 0, sizeof(p))
#define mp make_pair
void fast() {
ios_base::sync_... | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 832,431 | 832,432 | u217609546 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int N, A, B, C, D;
string S;
bool solve() {
int R1 = min(C, D), R2 = max(C, D);
for (int i = A; i < C; i++) {
if (S[i] == '#' && S[i + 1] == '#')
return false;
}
for (int i = B; i < D; i++) {
if (S[i] == '#' && S[i + 1] == '#')
... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int N, A, B, C, D;
string S;
bool solve() {
int R1 = min(C, D), R2 = max(C, D);
for (int i = A; i < C; i++) {
if (S[i] == '#' && S[i + 1] == '#')
return false;
}
for (int i = B; i < D; i++) {
if (S[i] == '#' && S[i + 1] == '#')
... | [
"control_flow.loop.for.initializer.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 832,441 | 832,442 | u930841425 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef double db;
#define go(u) for (int i = head[u], v = e[i].to; i; i = e[i].lst, v = e[i].to)
#define rep(i, a, b) for (int i = a; i <= b; ++i)
#define pb push_back
#define re(x) memset(x, 0, sizeof x)
inline int gi() {
int x = 0, f = 1;
char c... | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef double db;
#define go(u) for (int i = head[u], v = e[i].to; i; i = e[i].lst, v = e[i].to)
#define rep(i, a, b) for (int i = a; i <= b; ++i)
#define pb push_back
#define re(x) memset(x, 0, sizeof x)
inline int gi() {
int x = 0, f = 1;
char c... | [
"identifier.change",
"control_flow.loop.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 832,447 | 832,446 | u543414214 | cpp |
p03017 | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfenv>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#inc... | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfenv>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#inc... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 832,448 | 832,449 | u202928696 | cpp |
p03017 | #include <bits/stdc++.h>
//#include<ext/pb_ds/assoc_container.hpp>
using namespace std;
// using namespace __gnu_pbds;
const int inf = 0x3f3f3f3f;
const double eps = 1e-6;
const int mod = 1000000007;
typedef long long ll;
int modpow(int x, int y, int md = mod) {
if (y == 0)
return 1;
int ret = modpow(x, y >> 1,... | #include <bits/stdc++.h>
//#include<ext/pb_ds/assoc_container.hpp>
using namespace std;
// using namespace __gnu_pbds;
const int inf = 0x3f3f3f3f;
const double eps = 1e-6;
const int mod = 1000000007;
typedef long long ll;
int modpow(int x, int y, int md = mod) {
if (y == 0)
return 1;
int ret = modpow(x, y >> 1,... | [
"control_flow.loop.for.initializer.change"
] | 832,454 | 832,455 | u588911593 | cpp |
p03017 | #include <bits/stdc++.h>
//#include<ext/pb_ds/assoc_container.hpp>
using namespace std;
// using namespace __gnu_pbds;
const int inf = 0x3f3f3f3f;
const double eps = 1e-6;
const int mod = 1000000007;
typedef long long ll;
int modpow(int x, int y, int md = mod) {
if (y == 0)
return 1;
int ret = modpow(x, y >> 1,... | #include <bits/stdc++.h>
//#include<ext/pb_ds/assoc_container.hpp>
using namespace std;
// using namespace __gnu_pbds;
const int inf = 0x3f3f3f3f;
const double eps = 1e-6;
const int mod = 1000000007;
typedef long long ll;
int modpow(int x, int y, int md = mod) {
if (y == 0)
return 1;
int ret = modpow(x, y >> 1,... | [
"control_flow.loop.for.initializer.change",
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 832,456 | 832,455 | u588911593 | cpp |
p03017 | #include <bits/stdc++.h>
//#include<ext/pb_ds/assoc_container.hpp>
using namespace std;
// using namespace __gnu_pbds;
const int inf = 0x3f3f3f3f;
const double eps = 1e-6;
const int mod = 1000000007;
typedef long long ll;
int modpow(int x, int y, int md = mod) {
if (y == 0)
return 1;
int ret = modpow(x, y >> 1,... | #include <bits/stdc++.h>
//#include<ext/pb_ds/assoc_container.hpp>
using namespace std;
// using namespace __gnu_pbds;
const int inf = 0x3f3f3f3f;
const double eps = 1e-6;
const int mod = 1000000007;
typedef long long ll;
int modpow(int x, int y, int md = mod) {
if (y == 0)
return 1;
int ret = modpow(x, y >> 1,... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.change",
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 832,457 | 832,455 | u588911593 | cpp |
p03017 | #include <bits/stdc++.h>
//#include<ext/pb_ds/assoc_container.hpp>
using namespace std;
// using namespace __gnu_pbds;
const int inf = 0x3f3f3f3f;
const double eps = 1e-6;
const int mod = 1000000007;
typedef long long ll;
int modpow(int x, int y, int md = mod) {
if (y == 0)
return 1;
int ret = modpow(x, y >> 1,... | #include <bits/stdc++.h>
//#include<ext/pb_ds/assoc_container.hpp>
using namespace std;
// using namespace __gnu_pbds;
const int inf = 0x3f3f3f3f;
const double eps = 1e-6;
const int mod = 1000000007;
typedef long long ll;
int modpow(int x, int y, int md = mod) {
if (y == 0)
return 1;
int ret = modpow(x, y >> 1,... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.change",
"identifier.change",
"control_flow.branch.if.condition.change",
"literal.number.change"
] | 832,458 | 832,455 | u588911593 | cpp |
p03017 | #include "bits/stdc++.h"
using namespace std;
#define PB push_back
#define MP make_pair
#define REP(i, n) for (int i = 0; i < (n); i++)
int main() {
string s;
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
cin >> s;
a--;
b--;
c--;
d--;
for (int i = a + 1; i < max(c, d); i++) {
if (s[i] == '#' &... | #include "bits/stdc++.h"
using namespace std;
#define PB push_back
#define MP make_pair
#define REP(i, n) for (int i = 0; i < (n); i++)
int main() {
string s;
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
cin >> s;
a--;
b--;
c--;
d--;
for (int i = a + 1; i < max(c, d); i++) {
if (s[i] == '#' &... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 832,465 | 832,466 | u572537642 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
#define inf 999999999
#define loop(i, a, b) for (int i = (a), i##len = (b); i < i##len; ++i)
#define rep(i, n) loop(i, 0, n)
#define lin long long
#define lfl long double
lin n, a, b, c, d;
string s;
bool solve(lin src, lin dst) {
lin cur = src;
while (cur < dst) {
... | #include <bits/stdc++.h>
using namespace std;
#define inf 999999999
#define loop(i, a, b) for (int i = (a), i##len = (b); i < i##len; ++i)
#define rep(i, n) loop(i, 0, n)
#define lin long long
#define lfl long double
lin n, a, b, c, d;
string s;
bool solve(lin src, lin dst) {
lin cur = src;
while (cur < dst) {
... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"identifier.change",
"control_flow.branch.if.condition.change"
] | 832,469 | 832,470 | u762193256 | cpp |
p03017 | #include <iostream>
using namespace std;
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
A--;
B--;
C--;
D--;
string S;
cin >> S;
if (C < D) {
for (int i = A + 1; i <= D; i++) {
if (S[i] == '#' && S[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}... | #include <iostream>
using namespace std;
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
A--;
B--;
C--;
D--;
string S;
cin >> S;
if (C < D) {
for (int i = A + 1; i <= D; i++) {
if (S[i] == '#' && S[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 832,471 | 832,472 | u693133807 | cpp |
p03017 | #include <iostream>
using namespace std;
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
A--;
B--;
C--;
D--;
string S;
cin >> S;
if (C < D) {
for (int i = A + 1; i <= D; i++) {
if (S[i] == '#' && S[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}... | #include <iostream>
using namespace std;
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
A--;
B--;
C--;
D--;
string S;
cin >> S;
if (C < D) {
for (int i = A + 1; i <= D; i++) {
if (S[i] == '#' && S[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}... | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 832,473 | 832,472 | u693133807 | cpp |
p03017 | #include <iostream>
using namespace std;
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
A--;
B--;
C--;
D--;
string S;
cin >> S;
if (C < D) {
for (int i = A; i <= D; i++) {
if (S[i] == '#' && S[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}
... | #include <iostream>
using namespace std;
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
A--;
B--;
C--;
D--;
string S;
cin >> S;
if (C < D) {
for (int i = A + 1; i <= D; i++) {
if (S[i] == '#' && S[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}... | [
"control_flow.loop.for.initializer.change",
"literal.number.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 832,474 | 832,472 | u693133807 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
#define modulo 1000000007
#define mod(mod_x) (((long long)mod_x) % modulo)
int main() {
long long N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
for (int i = A - 1; i < C - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No... | #include <bits/stdc++.h>
using namespace std;
#define modulo 1000000007
#define mod(mod_x) (((long long)mod_x) % modulo)
int main() {
long long N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
for (int i = A - 1; i < C - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 832,478 | 832,479 | u118797367 | cpp |
p03017 | #include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <complex>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <casser... | #include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <complex>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <casser... | [
"expression.operation.binary.remove",
"assignment.change"
] | 832,487 | 832,488 | u378419207 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <vector>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(a) (a).begin(), (a).end()
typedef long long... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <vector>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(a) (a).begin(), (a).end()
typedef long long... | [
"expression.operation.binary.add"
] | 832,495 | 832,496 | u484460274 | cpp |
p03017 | #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_... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 832,497 | 832,498 | u096883693 | cpp |
p03017 | #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_... | [
"control_flow.loop.for.initializer.change",
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 832,499 | 832,498 | u096883693 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> i_i;
typedef pair<ll, ll> l_l;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
// const ll mod = 1000000007;
int n, a, b, c, d;
string s;
signed main() {
cin >> n >> a >> b >> c >> d >> s;
a--;
b--;
c--;
d--... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> i_i;
typedef pair<ll, ll> l_l;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
// const ll mod = 1000000007;
int n, a, b, c, d;
string s;
signed main() {
cin >> n >> a >> b >> c >> d >> s;
a--;
b--;
c--;
d--... | [
"literal.number.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 832,500 | 832,501 | u684255050 | cpp |
p03017 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using std::cerr;
using std::cin;
using... | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using std::cerr;
using std::cin;
using... | [
"control_flow.loop.for.initializer.change"
] | 832,505 | 832,506 | u844133200 | cpp |
p03017 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <queue>
#include <string>
#include <sys/time.h>
#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
void solve(long long N, long long A, long long ... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <queue>
#include <string>
#include <sys/time.h>
#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
void solve(long long N, long long A, long long ... | [
"control_flow.loop.for.initializer.change"
] | 832,509 | 832,510 | u462434199 | cpp |
p03017 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <queue>
#include <string>
#include <sys/time.h>
#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
void solve(long long N, long long A, long long ... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <queue>
#include <string>
#include <sys/time.h>
#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
void solve(long long N, long long A, long long ... | [
"control_flow.loop.for.initializer.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 832,511 | 832,510 | u462434199 | cpp |
p03017 | #include <bits/stdc++.h>
#define int long long
#define rep(i, n) REP(i, 0, n)
#define REP(i, l, r) for (long long i = l; i < r; i++)
using namespace std;
typedef pair<int, int> P;
struct edge {
int to, cost;
};
class dijkstra {
int V;
int d[100002];
priority_queue<P, vector<P>, greater<P>> que;
void update(i... | #include <bits/stdc++.h>
#define int long long
#define rep(i, n) REP(i, 0, n)
#define REP(i, l, r) for (long long i = l; i < r; i++)
using namespace std;
typedef pair<int, int> P;
struct edge {
int to, cost;
};
class dijkstra {
int V;
int d[100002];
priority_queue<P, vector<P>, greater<P>> que;
void update(i... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 832,518 | 832,519 | u073057072 | cpp |
p03017 | #include <bits/stdc++.h>
#define int long long
#define rep(i, n) REP(i, 0, n)
#define REP(i, l, r) for (long long i = l; i < r; i++)
using namespace std;
typedef pair<int, int> P;
struct edge {
int to, cost;
};
class dijkstra {
int V;
int d[100002];
priority_queue<P, vector<P>, greater<P>> que;
void update(i... | #include <bits/stdc++.h>
#define int long long
#define rep(i, n) REP(i, 0, n)
#define REP(i, l, r) for (long long i = l; i < r; i++)
using namespace std;
typedef pair<int, int> P;
struct edge {
int to, cost;
};
class dijkstra {
int V;
int d[100002];
priority_queue<P, vector<P>, greater<P>> que;
void update(i... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 832,520 | 832,519 | u073057072 | cpp |
p03017 | #include <cstdio>
#include <iostream>
using namespace std;
const int maxn = 222222;
char ss[maxn];
int N, A, B, C, D;
bool check1(int x, int y) {
for (int i = x + 2; i < y; ++i)
if (ss[i] == '#' && ss[i - 1] == '#')
return false;
return true;
}
bool check2(int x, int y) {
for (int i = x + 1; i < y; ++i)... | #include <cstdio>
#include <iostream>
using namespace std;
const int maxn = 222222;
char ss[maxn];
int N, A, B, C, D;
bool check1(int x, int y) {
for (int i = x + 2; i < y; ++i)
if (ss[i] == '#' && ss[i - 1] == '#')
return false;
return true;
}
bool check2(int x, int y) {
for (int i = x; i <= y; ++i)
... | [
"control_flow.loop.for.initializer.change",
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 832,521 | 832,522 | u136503093 | cpp |
p03017 | #include <bits/stdc++.h>
#define LL long long
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPA(i, n) for (int i = 1; i < (n); ++i)
#define PII pair<int, int>
#define PLI pair<long long, int>
#define PLL pair<long long, long long>
#define MOD ((int)1e6 + 3)
#define INF ((int)1e9)
#define INFLL ((LL)1e18)
#de... | #include <bits/stdc++.h>
#define LL long long
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPA(i, n) for (int i = 1; i < (n); ++i)
#define PII pair<int, int>
#define PLI pair<long long, int>
#define PLL pair<long long, long long>
#define MOD ((int)1e6 + 3)
#define INF ((int)1e9)
#define INFLL ((LL)1e18)
#de... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 832,529 | 832,530 | u493610446 | cpp |
p03017 | /*
_ _ _ _ _ _ _
_ _ _ _
/ /\ / /\ / /\ / /\ /
/\ /\ \ /\_\/\_\ _ /\ \ /\ \ _ /\ \
/ / \ / / \ / / \ / / / / / / \ \ \ / / ... | /*
_ _ _ _ _ _ _
_ _ _ _
/ /\ / /\ / /\ / /\ /
/\ /\ \ /\_\/\_\ _ /\ \ /\ \ _ /\ \
/ / \ / / \ / / \ / / / / / / \ \ \ / / ... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 832,531 | 832,532 | u748069390 | cpp |
p03017 | /*
_ _ _ _ _ _ _
_ _ _ _
/ /\ / /\ / /\ / /\ /
/\ /\ \ /\_\/\_\ _ /\ \ /\ \ _ /\ \
/ / \ / / \ / / \ / / / / / / \ \ \ / / ... | /*
_ _ _ _ _ _ _
_ _ _ _
/ /\ / /\ / /\ / /\ /
/\ /\ \ /\_\/\_\ _ /\ \ /\ \ _ /\ \
/ / \ / / \ / / \ / / / / / / \ \ \ / / ... | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change"
] | 832,533 | 832,532 | u748069390 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define REP(i, n) for (ll i = 0; i < n; i++)
#define REPR(i, n) for (ll i = n; i >... | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define REP(i, n) for (ll i = 0; i < n; i++)
#define REPR(i, n) for (ll i = n; i >... | [
"expression.operation.binary.add"
] | 832,534 | 832,535 | u196497077 | cpp |
p03017 | #include <bits/stdc++.h>
#include <climits>
#define rep(i, begin, end) \
for (__typeof(end) i = (begin) - ((begin) > (end)); \
i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
#define srep(i, begin, end) for (__typeof(e... | #include <bits/stdc++.h>
#include <climits>
#define rep(i, begin, end) \
for (__typeof(end) i = (begin) - ((begin) > (end)); \
i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
#define srep(i, begin, end) for (__typeof(e... | [
"literal.string.change",
"literal.string.case.change",
"call.arguments.change",
"io.output.change"
] | 832,536 | 832,537 | u196875870 | cpp |
p03017 | #include <bits/stdc++.h>
#define MIN_INT -2147483648
#define MAX_INT 2147483647
#define MIN_LONG -9223372036854775808L
#define MAX_LONG 9223372036854775807L
#define long long long int
using namespace std;
// @author: pashka
int main() {
ios::sync_with_stdio(false);
int n, a, b, c, d;
cin >> n >> a >> b >> c... | #include <bits/stdc++.h>
#define MIN_INT -2147483648
#define MAX_INT 2147483647
#define MIN_LONG -9223372036854775808L
#define MAX_LONG 9223372036854775807L
#define long long long int
using namespace std;
// @author: pashka
int main() {
ios::sync_with_stdio(false);
int n, a, b, c, d;
cin >> n >> a >> b >> c... | [
"control_flow.loop.for.initializer.change",
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 832,542 | 832,543 | u136509923 | cpp |
p03017 | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sst... | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sst... | [
"identifier.change",
"call.function.change"
] | 832,546 | 832,547 | u862095327 | cpp |
p03017 | #include <bits/stdc++.h>
#define REP(x, y, z) for (int x = y; x <= z; x++)
#define MSET(x, y) memset(x, y, sizeof(x))
#define M 200005
using namespace std;
int n, A, B, C, D;
char in[M];
int main() {
while (~scanf("%d %d %d %d %d", &n, &A, &B, &C, &D)) {
scanf("%s", in + 1);
auto chk = [&](int x, int y) {
... | #include <bits/stdc++.h>
#define REP(x, y, z) for (int x = y; x <= z; x++)
#define MSET(x, y) memset(x, y, sizeof(x))
#define M 200005
using namespace std;
int n, A, B, C, D;
char in[M];
int main() {
while (~scanf("%d %d %d %d %d", &n, &A, &B, &C, &D)) {
scanf("%s", in + 1);
auto chk = [&](int x, int y) {
... | [
"expression.operation.binary.remove"
] | 832,552 | 832,553 | u710687729 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define int long long
#define pie 3.141592653589793238462... | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define int long long
#define pie 3.141592653589793238462... | [
"control_flow.loop.for.initializer.change",
"expression.operation.binary.remove",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 832,557 | 832,558 | u277153875 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define all(x) (x).begin(), (x).end()
#define m0(x) memset(x, 0, sizeof(x))
int dx4[4] = {1, 0, -1, 0}, dy4[4] = {0, 1, 0, -1};
i... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define all(x) (x).begin(), (x).end()
#define m0(x) memset(x, 0, sizeof(x))
int dx4[4] = {1, 0, -1, 0}, dy4[4] = {0, 1, 0, -1};
i... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 832,559 | 832,560 | u773916255 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <complex>
#include <functional>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <unordered_map>
#include <unordered... | #include <algorithm>
#include <cmath>
#include <complex>
#include <functional>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <unordered_map>
#include <unordered... | [
"expression.operation.binary.add"
] | 832,561 | 832,562 | u453246394 | cpp |
p03017 | #include <bits/stdc++.h>
#include <iomanip>
//#define DEBUG 1
using namespace std;
typedef long long LL;
typedef long double LD;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef pair<LD, LD> PLDLD;
typedef vector<int> VI;
typedef vector<LL> VLL;
typedef vector<char> VB;
#define FOR(i, a, b) for (int i =... | #include <bits/stdc++.h>
#include <iomanip>
//#define DEBUG 1
using namespace std;
typedef long long LL;
typedef long double LD;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef pair<LD, LD> PLDLD;
typedef vector<int> VI;
typedef vector<LL> VLL;
typedef vector<char> VB;
#define FOR(i, a, b) for (int i =... | [
"call.arguments.change",
"call.arguments.add"
] | 832,563 | 832,564 | u284759714 | cpp |
p03017 | #include <bits/stdc++.h>
#include <iomanip>
//#define DEBUG 1
using namespace std;
typedef long long LL;
typedef long double LD;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef pair<LD, LD> PLDLD;
typedef vector<int> VI;
typedef vector<LL> VLL;
typedef vector<char> VB;
#define FOR(i, a, b) for (int i =... | #include <bits/stdc++.h>
#include <iomanip>
//#define DEBUG 1
using namespace std;
typedef long long LL;
typedef long double LD;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef pair<LD, LD> PLDLD;
typedef vector<int> VI;
typedef vector<LL> VLL;
typedef vector<char> VB;
#define FOR(i, a, b) for (int i =... | [
"expression.operation.binary.add"
] | 832,565 | 832,564 | u284759714 | cpp |
p03017 | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <bitset>
#include <climits>
#include <float.h>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <t... | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <bitset>
#include <climits>
#include <float.h>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <t... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 832,570 | 832,571 | u313288017 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define REP(i, n) FOR(i, 0, (n))
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define LAR(a, b) ((a) = max((a), (b)))
#define SML(a, b) ((a) = min((a), (b)))
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define REP(i, n) FOR(i, 0, (n))
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define LAR(a, b) ((a) = max((a), (b)))
#define SML(a, b) ((a) = min((a), (b)))
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 832,572 | 832,573 | u483277935 | cpp |
p03017 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utili... | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utili... | [
"control_flow.loop.for.initializer.change"
] | 832,574 | 832,575 | u712981454 | cpp |
p03017 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utili... | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utili... | [
"control_flow.loop.for.initializer.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 832,576 | 832,575 | u712981454 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
A--;
B--;
C--;
D--;
string S;
cin >> S;
for (int i = min(A, B); i < max(C, D); i++) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
if (... | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
A--;
B--;
C--;
D--;
string S;
cin >> S;
for (int i = min(A, B); i < max(C, D); i++) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
if (... | [
"control_flow.loop.for.initializer.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 832,577 | 832,578 | u898331860 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int n, A, B, C, D;
char ch[400010];
int main() {
scanf("%d%d%d%d%d", &n, &A, &B, &C, &D);
scanf("%s", ch + 1);
if (C < D) {
for (int i = B + 1; i < D; i++)
if (ch[i - 1] == '#' && ch[i] == '#') {
puts("No");
return 0;
}
for (int... | #include <bits/stdc++.h>
using namespace std;
int n, A, B, C, D;
char ch[400010];
int main() {
scanf("%d%d%d%d%d", &n, &A, &B, &C, &D);
scanf("%s", ch + 1);
if (C < D) {
for (int i = B + 1; i < D; i++)
if (ch[i - 1] == '#' && ch[i] == '#') {
puts("No");
return 0;
}
for (int... | [
"control_flow.loop.for.initializer.change",
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 832,579 | 832,580 | u902487619 | cpp |
p03017 | #include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
int n, a, b, c, d;
char s[200020];
int main() {
scanf("%d %d %d %d %d", &n, &a, &b, &c, &d);
scanf("%s", s + 1);
int flag = 1;
for (int i = a; i < c; ++i)
if (s[i] == '#' && s[i + 1] == '#') {
flag = 0;
break;
}
... | #include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
int n, a, b, c, d;
char s[200020];
int main() {
scanf("%d %d %d %d %d", &n, &a, &b, &c, &d);
scanf("%s", s + 1);
int flag = 1;
for (int i = a; i < c; ++i)
if (s[i] == '#' && s[i + 1] == '#') {
flag = 0;
break;
}
... | [
"control_flow.loop.for.initializer.change",
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 832,581 | 832,582 | u361707943 | cpp |
p03017 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <s... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <s... | [
"literal.string.change",
"literal.string.case.change",
"call.arguments.change",
"io.output.change"
] | 832,587 | 832,588 | u389366406 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define ms(s, n) memset(s, n, sizeof(s))
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORd(i, a, b) for (int i = (a)-1; i >= (b); --i)
#define FO... | #include <bits/stdc++.h>
using namespace std;
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define ms(s, n) memset(s, n, sizeof(s))
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORd(i, a, b) for (int i = (a)-1; i >= (b); --i)
#define FO... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 832,589 | 832,590 | u264312457 | cpp |
p03018 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main() {
string s;
cin >> s;
int n = s.size();
ll ans = 0;
ll cnt = 0;
for (int i = 0; i < n - 2; i++) {
if (s[i] == 'A' && s[i + 1] == 'B' && s[i + 2] == 'C... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main() {
string s;
cin >> s;
int n = s.size();
ll ans = 0;
ll cnt = 0;
for (int i = 0; i < n - 2; i++) {
if (s[i] == 'A' && s[i + 1] == 'B' && s[i + 2] == 'C... | [
"expression.unary.arithmetic.add"
] | 832,601 | 832,602 | u859566721 | cpp |
p03017 | #include <iostream>
#include <math.h>
#include <stdio.h>
#include <string>
#include <vector>
typedef long long ll;
typedef unsigned short int unsi;
typedef unsigned int uni;
typedef unsigned long int unli;
using namespace std;
int main() {
int N, A, B, C, D;
string S;
bool IsRock = false;
bool FirstSpace = ... | #include <iostream>
#include <math.h>
#include <stdio.h>
#include <string>
#include <vector>
typedef long long ll;
typedef unsigned short int unsi;
typedef unsigned int uni;
typedef unsigned long int unli;
using namespace std;
int main() {
int N, A, B, C, D;
string S;
bool IsRock = false;
bool FirstSpace = ... | [
"control_flow.loop.for.initializer.change"
] | 832,617 | 832,618 | u848871413 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <limits>
#include <numeric>
#include <string>
#include <utility>
#include <vector>
int main() {
int N, A, B, C, D;
std::string S;
std::cin >> N >> A >> B >> C >> D;
std::cin >> S;
if (C < D) {
int re_rock = 0;
for (int i = A - 1; i ... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <limits>
#include <numeric>
#include <string>
#include <utility>
#include <vector>
int main() {
int N, A, B, C, D;
std::string S;
std::cin >> N >> A >> B >> C >> D;
std::cin >> S;
if (C < D) {
int re_rock = 0;
for (int i = A - 1; i ... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 832,621 | 832,622 | u005702636 | cpp |
p03017 | #include <cmath>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
int a, b, c, d;
cin >> a >> b >> c >> d;
string s;
cin >> s;
for (int i = b - 1; i < d - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
b... | #include <cmath>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
int a, b, c, d;
cin >> a >> b >> c >> d;
string s;
cin >> s;
for (int i = b - 1; i < d - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
b... | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 832,626 | 832,627 | u135203576 | cpp |
p03017 | #include <cmath>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
int a, b, c, d;
cin >> a >> b >> c >> d;
string s;
cin >> s;
for (int i = b - 1; i < d - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
b... | #include <cmath>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
int a, b, c, d;
cin >> a >> b >> c >> d;
string s;
cin >> s;
for (int i = b - 1; i < d - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
b... | [
"identifier.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.change",
"literal.number.change",
"expression.off_by_one",
"control_flow.branch.if.condition.change"
] | 832,628 | 832,627 | u135203576 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
int count = 0;
for (ll i = a - 1; i < c - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
count++;
break;
}
}
for (ll i = b - 1; i < d ... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
int count = 0;
for (ll i = a - 1; i < c - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
count++;
break;
}
}
for (ll i = b - 1; i < d ... | [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.initializer.change"
] | 832,629 | 832,630 | u330689597 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int n, a, b, c, d;
char s[200005];
int sign = 0;
int main() {
scanf("%d%d%d%d%d", &n, &a, &b, &c, &d);
scanf("%s", s);
int n = strlen(s);
if (s[c - 1] == '#' || s[d - 1] == '#') {
printf("No\n");
return 0;
}
if (c < d) {
for (int i = a - 1; i < d ... | #include <bits/stdc++.h>
using namespace std;
int n, a, b, c, d;
char s[200005];
int sign = 0;
int main() {
scanf("%d%d%d%d%d", &n, &a, &b, &c, &d);
scanf("%s", s);
int n = strlen(s);
if (s[c - 1] == '#' || s[d - 1] == '#') {
printf("No\n");
return 0;
}
if (c < d) {
for (int i = a - 1; i < d ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 832,633 | 832,634 | u433665020 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
string ans = "";
if (ans.empty()) {
for (int i = A - 1; i < C; i++)
if (S[i] == '#' && S[i + 1] == '#')
ans = "No";
for (int i = B - 1; i < D; i++)
if ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
string ans = "";
if (ans.empty()) {
for (int i = A - 1; i < C; i++)
if (S[i] == '#' && S[i + 1] == '#')
ans = "No";
for (int i = B - 1; i < D; i++)
if ... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 832,635 | 832,636 | u581018765 | cpp |
p03017 | #include "bits/stdc++.h"
int main() {
int N, A, B, C, D;
std::cin >> N >> A >> B >> C >> D;
std::string S;
std::cin >> S;
bool ans = true;
bool swappable = false;
int rock = 0;
int none = 0;
int bigger = std::max(C, D);
for (int i = 0; i < N; ++i) {
if (S[i] == '#') {
none = 0;
if ... | #include "bits/stdc++.h"
int main() {
int N, A, B, C, D;
std::cin >> N >> A >> B >> C >> D;
std::string S;
std::cin >> S;
bool ans = true;
bool swappable = false;
int rock = 0;
int none = 0;
int bigger = std::max(C, D);
for (int i = 0; i < N; ++i) {
if (S[i] == '#') {
none = 0;
if ... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 832,637 | 832,638 | u264304509 | cpp |
p03017 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
long long int n, a, b, c, d, k, i, j, ng = 0, ok = 0;
scanf("%lld %lld %lld %lld %lld", &n, &a, &b, &c, &d);
char s[n + 1];
a--;
b--;
c--;
d--;
scanf("%s", s);
if (c < d)
ok = 1;
for (i = a; i <= c || i <= d; i++) {
... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
long long int n, a, b, c, d, k, i, j, ng = 0, ok = 0;
scanf("%lld %lld %lld %lld %lld", &n, &a, &b, &c, &d);
char s[n + 1];
a--;
b--;
c--;
d--;
scanf("%s", s);
if (c < d)
ok = 1;
for (i = a; i <= c || i <= d; i++) {
... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 832,641 | 832,642 | u356991267 | cpp |
p03017 | #include <algorithm>
#include <bitset>
#include <climits>
#include <complex>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define __int64 long long
#define long __int64
#define REP(i... | #include <algorithm>
#include <bitset>
#include <climits>
#include <complex>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define __int64 long long
#define long __int64
#define REP(i... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"literal.string.change",
"io.output.change"
] | 832,645 | 832,646 | u805346907 | cpp |
p03017 | #include <algorithm>
#include <bitset>
#include <climits>
#include <complex>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define __int64 long long
#define long __int64
#define REP(i... | #include <algorithm>
#include <bitset>
#include <climits>
#include <complex>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define __int64 long long
#define long __int64
#define REP(i... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"literal.string.change",
"io.output.change"
] | 832,647 | 832,646 | u805346907 | cpp |
p03017 | #include <algorithm>
#include <bitset>
#include <climits>
#include <complex>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define __int64 long long
#define long __int64
#define REP(i... | #include <algorithm>
#include <bitset>
#include <climits>
#include <complex>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define __int64 long long
#define long __int64
#define REP(i... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"literal.string.change",
"io.output.change"
] | 832,648 | 832,646 | u805346907 | cpp |
p03017 | #include <algorithm>
#include <bitset>
#include <climits>
#include <complex>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define __int64 long long
#define long __int64
#define REP(i... | #include <algorithm>
#include <bitset>
#include <climits>
#include <complex>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define __int64 long long
#define long __int64
#define REP(i... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"literal.string.change",
"io.output.change"
] | 832,649 | 832,646 | u805346907 | cpp |
p03017 | #include <algorithm>
#include <bitset>
#include <climits>
#include <complex>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define __int64 long long
#define long __int64
#define REP(i... | #include <algorithm>
#include <bitset>
#include <climits>
#include <complex>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define __int64 long long
#define long __int64
#define REP(i... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"literal.string.change",
"io.output.change"
] | 832,650 | 832,646 | u805346907 | cpp |
p03017 | #include <algorithm>
#include <bitset>
#include <climits>
#include <complex>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define __int64 long long
#define long __int64
#define REP(i... | #include <algorithm>
#include <bitset>
#include <climits>
#include <complex>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define __int64 long long
#define long __int64
#define REP(i... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 832,651 | 832,646 | u805346907 | cpp |
p03017 |
/*vvv>
zzzzzI
.---. zzuzuI .vgggg&,.
+++++= dunkoI .WbbWo JMM9^```?TMB` ..&gNNg,. gggggggJ, qgggggggg]
(&&&&&&&&[ c+OA&J, (&&&&&&+J, .cJeAA&-. (&&&&&&&&x .&AA&=-.
+++++= dunkoI Xpbpbp JM#` (M#^ ?MMp MM| +TMN. JMF '
|yk ` dVY 7Vk, Vy ... |
/*vvv>
zzzzzI
.---. zzuzuI .vgggg&,.
+++++= dunkoI .WbbWo JMM9^```?TMB` ..&gNNg,. gggggggJ, qgggggggg]
(&&&&&&&&[ c+OA&J, (&&&&&&+J, .cJeAA&-. (&&&&&&&&x .&AA&=-.
+++++= dunkoI Xpbpbp JM#` (M#^ ?MMp MM| +TMN. JMF '
|yk ` dVY 7Vk, Vy ... | [
"expression.operation.binary.remove"
] | 832,656 | 832,657 | u675296835 | cpp |
p03017 | #include <iostream>
#include <string>
using namespace std;
int main() {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
bool three_dot_exists = false;
bool two_sharp_exists = false;
for (int i = A + 1; i < max(C, D); ++i) {
if (S[i] == 35 && S[i - 1] == 35)
two_sharp_exists = tru... | #include <iostream>
#include <string>
using namespace std;
int main() {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
bool three_dot_exists = false;
bool two_sharp_exists = false;
for (int i = A + 1; i < max(C, D); ++i) {
if (S[i] == 35 && S[i - 1] == 35)
two_sharp_exists = tru... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"call.remove"
] | 832,661 | 832,662 | u128142352 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
string s;
cin >> s;
if (c < d) {
int pos = a;
while (pos < d) {
int count = 0;
while (pos < d && s[pos] == '.') {
pos++;
... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
string s;
cin >> s;
if (c < d) {
int pos = a;
while (pos < d) {
int count = 0;
while (pos < d && s[pos] == '.') {
pos++;
... | [
"control_flow.loop.condition.change"
] | 832,687 | 832,688 | u410878763 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
#define MP make_pair
#define PB push_back
#define ALL(x) (x).begin(), (x).end()
#define REP(i, n) for (int i = 0; i < (n); i++)
#define REP1(i, n) for (int i = 1; i < (n); i++)
#define REP2(i, d, n) for (int i = (d); i < (n); i++)
#define RREP(i, n) for (int i = (n); i >= ... | #include <bits/stdc++.h>
using namespace std;
#define MP make_pair
#define PB push_back
#define ALL(x) (x).begin(), (x).end()
#define REP(i, n) for (int i = 0; i < (n); i++)
#define REP1(i, n) for (int i = 1; i < (n); i++)
#define REP2(i, d, n) for (int i = (d); i < (n); i++)
#define RREP(i, n) for (int i = (n); i >= ... | [
"control_flow.loop.for.initializer.change"
] | 832,691 | 832,692 | u250996767 | cpp |
p03017 | // Shift-JIS（シフトジス）
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
int stones;
bool flag1 = true, flag2 = true;
stones = 0;
for (int i = A; i < C - 1; i++) {
if (S[i] == '#') {
stones++;
} else {
stones = 0;... | // Shift-JIS（シフトジス）
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
int stones;
bool flag1 = true, flag2 = true;
stones = 0;
for (int i = A; i < C - 1; i++) {
if (S[i] == '#') {
stones++;
} else {
stones = 0;... | [
"control_flow.branch.if.condition.change",
"control_flow.branch.if.add",
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 832,706 | 832,707 | u380317210 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll N, A, B, C, D;
string S;
bool cont(int X, int Y) {
for (int i = X; i <= Y - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
return false;
}
}
return true;
}
void solve() {
A--;
B--;
C--;
D--;
if (!cont(A, C) || !cont... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll N, A, B, C, D;
string S;
bool cont(int X, int Y) {
for (int i = X; i <= Y - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
return false;
}
}
return true;
}
void solve() {
A--;
B--;
C--;
D--;
if (!cont(A, C) || !cont... | [
"assignment.change"
] | 832,710 | 832,711 | u319242216 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll N, A, B, C, D;
string S;
bool cont(int X, int Y) {
for (int i = X; i <= Y - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
return false;
}
}
return true;
}
void solve() {
A--;
B--;
C--;
D--;
if (!cont(A, C) || !cont... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll N, A, B, C, D;
string S;
bool cont(int X, int Y) {
for (int i = X; i <= Y - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
return false;
}
}
return true;
}
void solve() {
A--;
B--;
C--;
D--;
if (!cont(A, C) || !cont... | [
"assignment.change"
] | 832,712 | 832,711 | u319242216 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int main() {
long n, a, b, c, d;
string str;
cin >> n >> a >> b >> c >> d >> str;
a -= 1;
b -= 1;
c -= 1;
d -= 1;
if (c < d || c < b) {
for (long i = a; i < c - 1; i++) {
if (str[i] == '#' && str[i + 1] == '#') {
cout << "No" << endl;
... | #include <bits/stdc++.h>
using namespace std;
int main() {
long n, a, b, c, d;
string str;
cin >> n >> a >> b >> c >> d >> str;
a -= 1;
b -= 1;
c -= 1;
d -= 1;
if (c < d || c < b) {
for (long i = a; i < c - 1; i++) {
if (str[i] == '#' && str[i + 1] == '#') {
cout << "No" << endl;
... | [
"control_flow.loop.for.condition.change"
] | 832,723 | 832,724 | u777864981 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vi>
#define pii pair<int, int>
#define pll pair<long long, long long>
#define vpll vector<pair<long long, long long>>
#define fill(a, val) memset(a, val, sizeof(a))
#define sort_unique... | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vi>
#define pii pair<int, int>
#define pll pair<long long, long long>
#define vpll vector<pair<long long, long long>>
#define fill(a, val) memset(a, val, sizeof(a))
#define sort_unique... | [
"expression.operation.binary.remove"
] | 832,732 | 832,733 | u251695874 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, a, b) for (int i = (a); i < (... | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, a, b) for (int i = (a); i < (... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 832,739 | 832,740 | u305138467 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, a, b) for (int i = (a); i < (... | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, a, b) for (int i = (a); i < (... | [
"control_flow.branch.if.condition.change"
] | 832,741 | 832,740 | u305138467 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d;
cin.ignore();
cin >> s;
cin.ignore();
// a<b<dより、ふぬけ君から先に行けばいい
// 0-origin
a--;
b--;
c--;
d--;
// ふぬけ
int len = s.length();
int su = a;
int fu = b;
// for(in... | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d;
cin.ignore();
cin >> s;
cin.ignore();
// a<b<dより、ふぬけ君から先に行けばいい
// 0-origin
a--;
b--;
c--;
d--;
// ふぬけ
int len = s.length();
int su = a;
int fu = b;
// for(in... | [
"literal.string.change",
"control_flow.branch.if.condition.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 832,746 | 832,747 | u042605975 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
int fstoneA = 0, fstoneB = 0;
for (int i = A - 1; i < C - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#')
fstoneA = 1;
}
... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
int fstoneA = 0, fstoneB = 0;
for (int i = A - 1; i < C - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#')
fstoneA = 1;
}
... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 832,754 | 832,755 | u129667379 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.