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 <iostream>
using namespace std;
int main() {
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d >> s;
a--;
b--;
c--;
d--;
string result = "Yes";
if (c < d) {
for (int i = a + 2; i < d; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
result = "No";
}
}
} else... | #include <iostream>
using namespace std;
int main() {
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d >> s;
a--;
b--;
c--;
d--;
string result = "Yes";
if (c < d) {
for (int i = a + 2; i < d; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
result = "No";
}
}
} else... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 830,825 | 830,826 | u085367022 | cpp |
p03017 | #include <iostream>
using namespace std;
int main() {
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d >> s;
a--;
b--;
c--;
d--;
string result = "Yes";
if (c < d) {
for (int i = a + 2; i < d; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
result = "No";
}
}
} else... | #include <iostream>
using namespace std;
int main() {
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d >> s;
a--;
b--;
c--;
d--;
string result = "Yes";
if (c < d) {
for (int i = a + 2; i < d; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
result = "No";
}
}
} else... | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 830,828 | 830,826 | u085367022 | cpp |
p03017 | #include <iostream>
using namespace std;
int main() {
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d >> s;
a--;
b--;
c--;
d--;
string result = "Yes";
if (c < d) {
for (int i = a + 2; i < d; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
result = "No";
}
}
} else... | #include <iostream>
using namespace std;
int main() {
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d >> s;
a--;
b--;
c--;
d--;
string result = "Yes";
if (c < d) {
for (int i = a + 2; i < d; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
result = "No";
}
}
} else... | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 830,829 | 830,826 | u085367022 | 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 flag = true;
if (D > C) {
for (int i = B; i < D; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flag = false;
}
}
f... | #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 flag = true;
if (D > C) {
for (int i = B; i < D; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flag = false;
}
}
f... | [
"control_flow.loop.for.initializer.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 830,832 | 830,833 | u904123392 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int N, A, B, C, D;
string S;
void solve() {
A--, B--, C--, D--;
bool ok = true;
for (int i = A + 1; ok && i <= C; ++i) {
if (S[i] == '#' && S[i - 1] == '#')
ok = false;
}
for (int i = B + 1; ok && i <= D; ++i) {
if (S[i] == '#' && S[i - 1] == '#')
... | #include <bits/stdc++.h>
using namespace std;
int N, A, B, C, D;
string S;
void solve() {
A--, B--, C--, D--;
bool ok = true;
for (int i = A + 1; ok && i <= C; ++i) {
if (S[i] == '#' && S[i - 1] == '#')
ok = false;
}
for (int i = B + 1; ok && i <= D; ++i) {
if (S[i] == '#' && S[i - 1] == '#')
... | [
"control_flow.loop.for.initializer.change",
"expression.operation.binary.remove",
"control_flow.loop.for.condition.change"
] | 830,834 | 830,835 | u570770016 | cpp |
p03017 | /*
гонфлад
*/
#pragma ARCENIY_KIRILLOV_UVIDEL_KROKODILOV
//#pragma comment(linker, "/stack:200000000")
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//#pragma GCC optimize("no-stack-protector")
//#pragma GCC push_options
//#pragma GCC optimize ("unroll-l... | /*
гонфлад
*/
#pragma ARCENIY_KIRILLOV_UVIDEL_KROKODILOV
//#pragma comment(linker, "/stack:200000000")
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//#pragma GCC optimize("no-stack-protector")
//#pragma GCC push_options
//#pragma GCC optimize ("unroll-l... | [
"control_flow.loop.for.initializer.change",
"call.remove",
"call.arguments.change",
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 830,843 | 830,844 | u122149278 | cpp |
p03017 | /*
гонфлад
*/
#pragma ARCENIY_KIRILLOV_UVIDEL_KROKODILOV
//#pragma comment(linker, "/stack:200000000")
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//#pragma GCC optimize("no-stack-protector")
//#pragma GCC push_options
//#pragma GCC optimize ("unroll-l... | /*
гонфлад
*/
#pragma ARCENIY_KIRILLOV_UVIDEL_KROKODILOV
//#pragma comment(linker, "/stack:200000000")
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//#pragma GCC optimize("no-stack-protector")
//#pragma GCC push_options
//#pragma GCC optimize ("unroll-l... | [
"control_flow.loop.for.initializer.change",
"call.remove",
"call.arguments.change"
] | 830,845 | 830,844 | u122149278 | cpp |
p03017 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define rep(i, s, n) for (int i = s; i < n; i++)
#define repe(i, s, n) for (int i = s; i <= n; i++)
#define rep_r(i, s, n) for (int i = n - 1;... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define rep(i, s, n) for (int i = s; i < n; i++)
#define repe(i, s, n) for (int i = s; i <= n; i++)
#define rep_r(i, s, n) for (int i = n - 1;... | [
"expression.operation.binary.remove"
] | 830,848 | 830,849 | u685009987 | cpp |
p03017 | #include "bits/stdc++.h"
#define pb push_back
#define pob pop_back
#define pf push_front
#define pof pop_front
#define eb emplace_back
#define rep(i, a, b) for (long i = (a); i <= (b); ++i)
#define per(i, a, b) for (long i = (a); i >= (b); --i)
#define mmst(v) memset(v, 0, sizeof(v))
const long kMax2 = 109;
const lon... | #include "bits/stdc++.h"
#define pb push_back
#define pob pop_back
#define pf push_front
#define pof pop_front
#define eb emplace_back
#define rep(i, a, b) for (long i = (a); i <= (b); ++i)
#define per(i, a, b) for (long i = (a); i >= (b); --i)
#define mmst(v) memset(v, 0, sizeof(v))
const long kMax2 = 109;
const lon... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 830,852 | 830,853 | u449221649 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int mod = 1000000007;
int main() {
ios::sync_with_stdio(false);
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d >> s;
s = '#' + s + '#';
if (c < d) {
for (int i = a; i < d; i++)
if (s[i... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int mod = 1000000007;
int main() {
ios::sync_with_stdio(false);
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d >> s;
s = '#' + s + '#';
if (c < d) {
for (int i = a; i < d; i++)
if (s[i... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 830,861 | 830,862 | u151855078 | cpp |
p03017 | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
constexpr ld EPS = 1e-12;
constexpr int INF = numeric_limits<int>::max() / 2;
constexpr int MOD = 1e9 + 7;
template <typename T> void printv(const vector<T> &v) {
int sz = v.size();
for (int i = ... | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
constexpr ld EPS = 1e-12;
constexpr int INF = numeric_limits<int>::max() / 2;
constexpr int MOD = 1e9 + 7;
template <typename T> void printv(const vector<T> &v) {
int sz = v.size();
for (int i = ... | [
"control_flow.loop.for.condition.change"
] | 830,873 | 830,874 | u968834127 | cpp |
p03017 | #include <iostream>
using namespace std;
int main() {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
S = "#" + S + "#";
auto can_reach = [&](int start, int end) {
for (int i = start; i + 1 <= end; ++i) {
if (S[i] == '#' && S[i + 1] == '#')
return false;
}
return ... | #include <iostream>
using namespace std;
int main() {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
S = "#" + S + "#";
auto can_reach = [&](int start, int end) {
for (int i = start; i + 1 <= end; i++) {
if (S[i] == '#' && S[i + 1] == '#')
return false;
}
return ... | [
"expression.operation.compare.replace.add",
"assignment.replace.remove",
"misc.typo"
] | 830,886 | 830,887 | u625893557 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
string ans = "Yes";
bool flag = true;
for (int i = a - 1; i < max(c, d) - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
string ans = "Yes";
bool flag = true;
for (int i = a - 1; i < max(c, d) - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 830,896 | 830,897 | u190679129 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
string ans = "Yes";
bool flag = true;
for (int i = a - 1; i < max(c, d) - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
string ans = "Yes";
bool flag = true;
for (int i = a - 1; i < max(c, d) - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
... | [
"literal.number.change",
"control_flow.branch.if.condition.change",
"identifier.change"
] | 830,898 | 830,897 | u190679129 | cpp |
p03017 | // agc034_a.cpp
// Sat Aug 3 16:42:25 2019
#include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
#define INTINF 2147483647
#define LLINF 9223372036854775807
using namespace std;
using ll = long long;
typed... | // agc034_a.cpp
// Sat Aug 3 16:42:25 2019
#include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
#define INTINF 2147483647
#define LLINF 9223372036854775807
using namespace std;
using ll = long long;
typed... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 830,899 | 830,900 | u628871447 | cpp |
p03017 | #include <algorithm>
#include <fstream>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
int main(int argc, const char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
--a;
--b;
--c;
--d;
string s;
cin >> s;
v... | #include <algorithm>
#include <fstream>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
int main(int argc, const char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
--a;
--b;
--c;
--d;
string s;
cin >> s;
v... | [
"control_flow.branch.if.condition.change",
"variable_declaration.name.change",
"identifier.change",
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 830,901 | 830,902 | u906651641 | cpp |
p03017 | #include <algorithm>
#include <fstream>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
int main(int argc, const char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
--a;
--b;
--c;
--d;
string s;
cin >> s;
v... | #include <algorithm>
#include <fstream>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
int main(int argc, const char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
--a;
--b;
--c;
--d;
string s;
cin >> s;
v... | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 830,903 | 830,904 | u906651641 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define sz(x) (int)(x.size())
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d >> s;
s = " " + s;
bool ans = true;
for (int i = b + 1; i < d; i++) {
if (s[i] =... | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define sz(x) (int)(x.size())
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d >> s;
s = " " + s;
bool ans = true;
for (int i = b + 1; i < d; i++) {
if (s[i] =... | [
"control_flow.loop.for.condition.change"
] | 830,916 | 830,917 | u590725538 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int N, A, B, C, D;
string S;
int main() {
cin >> N >> A >> B >> C >> D;
cin >> S;
A--;
B--;
C--;
D--;
bool flag = false;
if (D < C) {
for (int i = B; i < D; i++) {
if (S[i] == '#' && S[i + 1] == '#')
flag = true;
}
bool flag2 =... | #include <bits/stdc++.h>
using namespace std;
int N, A, B, C, D;
string S;
int main() {
cin >> N >> A >> B >> C >> D;
cin >> S;
A--;
B--;
C--;
D--;
bool flag = false;
if (D < C) {
for (int i = B; i < D; i++) {
if (S[i] == '#' && S[i + 1] == '#')
flag = true;
}
bool flag2 =... | [
"control_flow.loop.for.initializer.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"literal.string.change",
"io.output.change"
] | 830,926 | 830,925 | u205655980 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
template... | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
template... | [
"control_flow.loop.for.initializer.change",
"identifier.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 830,934 | 830,935 | u077337864 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
template... | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
template... | [
"control_flow.loop.for.initializer.change",
"identifier.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 830,936 | 830,935 | u077337864 | 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;
for (int i{A + 1}; i < max(C, D); ++i) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
if (C > D) {
S.... | #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;
for (int i{A + 1}; i < max(C, D); ++i) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
if (C > D) {
S.... | [
"control_flow.loop.for.initializer.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 830,944 | 830,945 | u154289649 | cpp |
p03017 | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
using namespace std;
typedef pair<int, int> P;
const int maxn = 1e5 + 10;
char s[maxn * 2];
int main() {
int n, a, b, c, d;
cin >> n;
cin >> a >> b >> c >> d;
scanf("%s", s + 1);
int len = strlen(s + 1);
int f = 1... | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
using namespace std;
typedef pair<int, int> P;
const int maxn = 1e5 + 10;
char s[maxn * 2];
int main() {
int n, a, b, c, d;
cin >> n;
cin >> a >> b >> c >> d;
scanf("%s", s + 1);
int len = strlen(s + 1);
int f = 1... | [
"misc.opposites",
"identifier.change",
"call.function.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 830,951 | 830,952 | u914135866 | cpp |
p03017 | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
using namespace std;
typedef pair<int, int> P;
const int maxn = 1e5 + 10;
char s[maxn * 2];
int main() {
int n, a, b, c, d;
cin >> n;
cin >> a >> b >> c >> d;
scanf("%s", s + 1);
int len = strlen(s + 1);
int f = 1... | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
using namespace std;
typedef pair<int, int> P;
const int maxn = 1e5 + 10;
char s[maxn * 2];
int main() {
int n, a, b, c, d;
cin >> n;
cin >> a >> b >> c >> d;
scanf("%s", s + 1);
int len = strlen(s + 1);
int f = 1... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 830,953 | 830,952 | u914135866 | cpp |
p03017 | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
using namespace std;
typedef pair<int, int> P;
const int maxn = 1e5 + 10;
char s[maxn * 2];
int main() {
int n, a, b, c, d;
cin >> n;
cin >> a >> b >> c >> d;
scanf("%s", s + 1);
int len = strlen(s + 1);
int f = 1... | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
using namespace std;
typedef pair<int, int> P;
const int maxn = 1e5 + 10;
char s[maxn * 2];
int main() {
int n, a, b, c, d;
cin >> n;
cin >> a >> b >> c >> d;
scanf("%s", s + 1);
int len = strlen(s + 1);
int f = 1... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 830,954 | 830,952 | u914135866 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
char s[maxn];
int vis[maxn];
int n, a, b, c, d;
int main() {
scanf("%d%d%d%d%d", &n, &a, &b, &c, &d);
scanf("%s", s + 1);
// int len=strlen(s+1);
// cout<<len<<endl;
if (s[c] == '#' || s[d] == '#')
puts("No");
else {
if (a > b... | #include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
char s[maxn];
int vis[maxn];
int n, a, b, c, d;
int main() {
scanf("%d%d%d%d%d", &n, &a, &b, &c, &d);
scanf("%s", s + 1);
// int len=strlen(s+1);
// cout<<len<<endl;
if (s[c] == '#' || s[d] == '#')
puts("No");
else {
if (a > b... | [
"variable_declaration.remove",
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 830,955 | 830,956 | u914135866 | cpp |
p03017 | #include <iostream>
using namespace std;
int main(void) {
int n, a, b, c, d, x = 0, y = 0;
bool f = true;
string s;
cin >> n >> a >> b >> c >> d >> s;
for (int i = a; i < c; i++) {
if (s[i] == '#' && s[i - 1] == '#')
f = false;
}
for (int i = b; i < d; i++) {
if (s[i] == '#' && s[i - 1] == '... | #include <iostream>
using namespace std;
int main(void) {
int n, a, b, c, d, x = 0, y = 0;
bool f = true;
string s;
cin >> n >> a >> b >> c >> d >> s;
for (int i = a; i < c; i++) {
if (s[i] == '#' && s[i - 1] == '#')
f = false;
}
for (int i = b; i < d; i++) {
if (s[i] == '#' && s[i - 1] == '... | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 830,958 | 830,959 | u024809932 | cpp |
p03017 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string.h>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
long long int mod = 1e9 + 7;
bool debug = false;
typedef long long ll;
bool check(string s, int a, int b) {
bool jump = true;
for (int i = a; i <= b; i+... | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string.h>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
long long int mod = 1e9 + 7;
bool debug = false;
typedef long long ll;
bool check(string s, int a, int b) {
bool jump = true;
for (int i = a; i <= b; i+... | [
"control_flow.branch.if.condition.change"
] | 830,970 | 830,971 | u732502311 | cpp |
p03017 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string.h>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
long long int mod = 1e9 + 7;
bool debug = false;
typedef long long ll;
bool check(string s, int a, int b) {
bool jump = true;
for (int i = a; i <= b; i+... | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string.h>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
long long int mod = 1e9 + 7;
bool debug = false;
typedef long long ll;
bool check(string s, int a, int b) {
bool jump = true;
for (int i = a; i <= b; i+... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 830,972 | 830,971 | u732502311 | cpp |
p03017 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define OK 1
#define NG 0
#define MOD (10000000... | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define OK 1
#define NG 0
#define MOD (10000000... | [
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.change",
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 830,973 | 830,974 | u498141549 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
int main() {
ll n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
string s;
cin >> s;
bool ans = true;
s[n] = '#';
for (ll i = b; i <= d; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
int main() {
ll n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
string s;
cin >> s;
bool ans = true;
s[n] = '#';
for (ll i = b; i <= d; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
... | [] | 830,981 | 830,982 | u876784108 | cpp |
p03017 | #include <bits/stdc++.h>
#define REP(i, x) for (int i = 0; i < (int)(x); i++)
#define ALL(x) (x).begin(), (x).end()
typedef long long ll;
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D;
cin >> S;
for (int i = A + 1;... | #include <bits/stdc++.h>
#define REP(i, x) for (int i = 0; i < (int)(x); i++)
#define ALL(x) (x).begin(), (x).end()
typedef long long ll;
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D;
cin >> S;
for (int i = A + 1;... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 830,985 | 830,986 | u965529378 | cpp |
p03017 | #include <bits/stdc++.h>
#define REP(i, x) for (int i = 0; i < (int)(x); i++)
#define ALL(x) (x).begin(), (x).end()
typedef long long ll;
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D;
cin >> S;
for (int i = A + 1;... | #include <bits/stdc++.h>
#define REP(i, x) for (int i = 0; i < (int)(x); i++)
#define ALL(x) (x).begin(), (x).end()
typedef long long ll;
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D;
cin >> S;
for (int i = A + 1;... | [
"control_flow.loop.for.initializer.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 830,987 | 830,986 | u965529378 | cpp |
p03017 | #include <iostream>
using namespace std;
int main(void) {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D;
cin >> S;
A--;
B--;
C--;
D--;
int flag = true;
int end = C;
if (C < D) {
end = D;
}
for (int i = A; i + 1 <= end; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
... | #include <iostream>
using namespace std;
int main(void) {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D;
cin >> S;
A--;
B--;
C--;
D--;
int flag = true;
int end = C;
if (C < D) {
end = D;
}
for (int i = A; i + 1 <= end; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 830,991 | 830,992 | u422831867 | cpp |
p03017 | #include <alloca.h>
#include <iostream>
using namespace std;
int main() {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
bool result = true;
A--;
B--;
C--;
D--;
if (S[C] == '#' || S[D] == '#') {
result = false;
}
for (int chkIdx = 0; result && chkIdx < 2; chkIdx++) {
... | #include <alloca.h>
#include <iostream>
using namespace std;
int main() {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
bool result = true;
A--;
B--;
C--;
D--;
if (S[C] == '#' || S[D] == '#') {
result = false;
}
for (int chkIdx = 0; result && chkIdx < 2; chkIdx++) {
... | [
"control_flow.branch.if.condition.change",
"expression.operator.compare.change"
] | 831,008 | 831,009 | u298381622 | cpp |
p03016 | #include <bits/stdc++.h>
using ll = long long;
using namespace std;
long long l, a, b, MOD;
struct Matrix {
vector<vector<long long>> val;
Matrix(int n, int m, long long x = 0) : val(n, vector<long long>(m, x)) {}
void init(int n, int m, long long x = 0) {
val.assign(n, vector<long long>(m, x));
}
int s... | #include <bits/stdc++.h>
using ll = long long;
using namespace std;
long long l, a, b, MOD;
struct Matrix {
vector<vector<long long>> val;
Matrix(int n, int m, long long x = 0) : val(n, vector<long long>(m, x)) {}
void init(int n, int m, long long x = 0) {
val.assign(n, vector<long long>(m, x));
}
int s... | [
"assignment.change"
] | 831,088 | 831,091 | u842028864 | cpp |
p03016 | #include <algorithm>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
// long long mod = 998244353;
long long mod = 1000000007;
vector<long long> fact(1000001);
vector<long long> invFact(1... | #include <algorithm>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
// long long mod = 998244353;
long long mod = 1000000007;
vector<long long> fact(1000001);
vector<long long> invFact(1... | [
"variable_declaration.remove",
"assignment.change"
] | 831,238 | 831,249 | u800277548 | cpp |
p03016 | /*{{{*/
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define SZ(X) ((int)(X).size())
#defin... | /*{{{*/
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define SZ(X) ((int)(X).size())
#defin... | [
"control_flow.branch.if.condition.change",
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"expression.operation.binary.change"
] | 831,305 | 831,299 | u284124505 | cpp |
p03016 | /*{{{*/
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define SZ(X) ((int)(X).size())
#defin... | /*{{{*/
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define SZ(X) ((int)(X).size())
#defin... | [
"control_flow.branch.if.condition.change"
] | 831,313 | 831,299 | u284124505 | cpp |
p03016 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
#define REP(i, k, n) for (long long i = k; i < (long long)(n); i++)
#define all(a) a.begin(), a.end()
#define eb emplace_back
#define pb push_back
#define lb(v, k) (lower_bound(all(v), k) - v.begin())
#define ... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
#define REP(i, k, n) for (long long i = k; i < (long long)(n); i++)
#define all(a) a.begin(), a.end()
#define eb emplace_back
#define pb push_back
#define lb(v, k) (lower_bound(all(v), k) - v.begin())
#define ... | [
"variable_declaration.remove"
] | 831,320 | 831,324 | u422633119 | cpp |
p03016 | //#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
//衝突対策
#define ws wszzzz
#define int long long
//@formatter:off
template <class A, class B, class C> struct T2 {
A f;
B s;
C t;
T2() { f = 0, s = 0, t = 0; }
T2(A f, B s, C t) : f(f), s(s), t(t) {}
bool operator<(const T2 &r) con... | //#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
//衝突対策
#define ws wszzzz
#define int long long
//@formatter:off
template <class A, class B, class C> struct T2 {
A f;
B s;
C t;
T2() { f = 0, s = 0, t = 0; }
T2(A f, B s, C t) : f(f), s(s), t(t) {}
bool operator<(const T2 &r) con... | [
"call.arguments.change",
"call.arguments.add"
] | 831,328 | 831,382 | u986437843 | cpp |
p03016 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define FOR(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define ALLOF(c) (c).begin(), (c).... | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define FOR(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define ALLOF(c) (c).begin(), (c).... | [
"assignment.change"
] | 831,444 | 831,450 | u624678037 | cpp |
p03016 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <ciso646>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <ciso646>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 831,464 | 831,468 | u508571192 | cpp |
p03016 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define rep(i, a, b) for (int i = int(a); i < int(b); ++i)
#define All(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
ll mod;
class mint {
private:
ll _num, _mod;
mint set(ll num) {
_num = num;
... | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define rep(i, a, b) for (int i = int(a); i < int(b); ++i)
#define All(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
ll mod;
class mint {
private:
ll _num, _mod;
mint set(ll num) {
_num = num;
... | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.branch.if.condition.change"
] | 831,552 | 831,562 | u203033720 | cpp |
p03016 |
#include <algorithm>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using nam... |
#include <algorithm>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using nam... | [
"assignment.change"
] | 831,569 | 831,571 | u471289663 | cpp |
p03016 |
#include <algorithm>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using nam... |
#include <algorithm>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using nam... | [
"assignment.change"
] | 831,572 | 831,571 | u471289663 | cpp |
p03017 | #include <bits/stdc++.h>
// using namespace std;
#define DUMP(x) std::cout << (#x) << " = " << (x) << "\n"
void Main() {
int n, a, b, c, d;
std::cin >> n >> a >> b >> c >> d;
std::string s;
s.reserve(n);
std::cin >> s;
for (int i = b; i < d - 1; ++i) {
if (s[i] == '#' && s[i + 1] == '#') {
std... | #include <bits/stdc++.h>
// using namespace std;
#define DUMP(x) std::cout << (#x) << " = " << (x) << "\n"
void Main() {
int n, a, b, c, d;
std::cin >> n >> a >> b >> c >> d;
std::string s;
s.reserve(n);
std::cin >> s;
for (int i = b; i < d - 1; ++i) {
if (s[i] == '#' && s[i + 1] == '#') {
std... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 831,011 | 831,013 | u664394831 | cpp |
p03017 | #include <iostream>
#include <string>
using namespace std;
bool reachable(string s, int start, int end) {
bool res = true;
for (int i = start - 1; i < end - 1; i++) {
if (s[i] == '#' & s[i + 1] == '#') {
res = false;
break;
}
}
return res;
}
int main() {
int n, a, b, c, d;
string s;
... | #include <iostream>
#include <string>
using namespace std;
bool reachable(string s, int start, int end) {
bool res = true;
for (int i = start - 1; i < end - 1; i++) {
if (s[i] == '#' & s[i + 1] == '#') {
res = false;
break;
}
}
return res;
}
int main() {
int n, a, b, c, d;
string s;
... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 831,014 | 831,016 | u717463970 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef std::pair<int, int> ipair;
bool lessPair(const ipair &l, const ipair &r) { return l.second < r.secon... | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef std::pair<int, int> ipair;
bool lessPair(const ipair &l, const ipair &r) { return l.second < r.secon... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 831,066 | 831,068 | u775224245 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef std::pair<int, int> ipair;
bool lessPair(const ipair &l, const ipair &r) { return l.second < r.secon... | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef std::pair<int, int> ipair;
bool lessPair(const ipair &l, const ipair &r) { return l.second < r.secon... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 831,070 | 831,068 | u775224245 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef std::pair<int, int> ipair;
bool lessPair(const ipair &l, const ipair &r) { return l.second < r.secon... | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef std::pair<int, int> ipair;
bool lessPair(const ipair &l, const ipair &r) { return l.second < r.secon... | [
"identifier.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 831,072 | 831,068 | u775224245 | cpp |
p03017 | #include "bits/stdc++.h"
using namespace std;
// typedef
//------------------------------------------
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<string> VS;
typedef pair<LL, LL> PLL;
// container util
//---------------------------------------... | #include "bits/stdc++.h"
using namespace std;
// typedef
//------------------------------------------
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<string> VS;
typedef pair<LL, LL> PLL;
// container util
//---------------------------------------... | [
"expression.operation.binary.remove"
] | 831,110 | 831,111 | u196798307 | cpp |
p03017 | #include "bits/stdc++.h"
using namespace std;
// typedef
//------------------------------------------
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<string> VS;
typedef pair<LL, LL> PLL;
// container util
//---------------------------------------... | #include "bits/stdc++.h"
using namespace std;
// typedef
//------------------------------------------
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<string> VS;
typedef pair<LL, LL> PLL;
// container util
//---------------------------------------... | [
"assignment.change"
] | 831,112 | 831,111 | u196798307 | cpp |
p03017 | #include "bits/stdc++.h"
using namespace std;
// typedef
//------------------------------------------
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<string> VS;
typedef pair<LL, LL> PLL;
// container util
//---------------------------------------... | #include "bits/stdc++.h"
using namespace std;
// typedef
//------------------------------------------
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<string> VS;
typedef pair<LL, LL> PLL;
// container util
//---------------------------------------... | [
"expression.operation.binary.remove"
] | 831,113 | 831,111 | u196798307 | cpp |
p03017 | #include "bits/stdc++.h"
using namespace std;
// typedef
//------------------------------------------
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<string> VS;
typedef pair<LL, LL> PLL;
// container util
//---------------------------------------... | #include "bits/stdc++.h"
using namespace std;
// typedef
//------------------------------------------
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<string> VS;
typedef pair<LL, LL> PLL;
// container util
//---------------------------------------... | [
"expression.operation.binary.remove"
] | 831,114 | 831,111 | u196798307 | cpp |
p03017 | #include "bits/stdc++.h"
using namespace std;
// typedef
//------------------------------------------
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<string> VS;
typedef pair<LL, LL> PLL;
// container util
//---------------------------------------... | #include "bits/stdc++.h"
using namespace std;
// typedef
//------------------------------------------
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<string> VS;
typedef pair<LL, LL> PLL;
// container util
//---------------------------------------... | [
"expression.operation.binary.remove"
] | 831,115 | 831,111 | u196798307 | cpp |
p03017 | #include "bits/stdc++.h"
using namespace std;
// typedef
//------------------------------------------
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<string> VS;
typedef pair<LL, LL> PLL;
// container util
//---------------------------------------... | #include "bits/stdc++.h"
using namespace std;
// typedef
//------------------------------------------
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<string> VS;
typedef pair<LL, LL> PLL;
// container util
//---------------------------------------... | [
"expression.operation.binary.remove"
] | 831,116 | 831,111 | u196798307 | cpp |
p03017 | #include <bits/stdc++.h>
#define ll long long
#define rep(i, n) for (ll(i) = 0; (i) < (n); (i)++)
using namespace std;
int main() {
ll n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
string str;
cin >> str;
for (ll i = a - 1; i < max(c, d); i++) {
if (str[i] == '#' && str[i - 1] ... | #include <bits/stdc++.h>
#define ll long long
#define rep(i, n) for (ll(i) = 0; (i) < (n); (i)++)
using namespace std;
int main() {
ll n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
string str;
cin >> str;
for (ll i = a; i < max(c, d); i++) {
if (str[i] == '#' && str[i - 1] == '... | [
"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",
"misc.off_by_one"
] | 831,125 | 831,127 | u201316840 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
bool equals(const string &a, int start, const string &b) {
for (int i = 0; i < b.size(); ++i) {
if (start + i >= a.size() || a[start + i] != b[i]) {
return false;
}
}
return true;
}
bool can_goal(const string &s, int beg, int end) {
for (int i = beg... | #include <bits/stdc++.h>
using namespace std;
bool equals(const string &a, int start, const string &b) {
for (int i = 0; i < b.size(); ++i) {
if (start + i >= a.size() || a[start + i] != b[i]) {
return false;
}
}
return true;
}
bool can_goal(const string &s, int beg, int end) {
for (int i = beg... | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 831,133 | 831,134 | u842596864 | cpp |
p03017 |
#include <bits/stdc++.h>
#define fi first
#define se second
#define pb push_back
#define endl "\n"
#define int long long
using namespace std;
const int N = 300111;
int n, m, a, b, c, d;
string s;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
// freopen("input.txt","r",stdin);
cin ... |
#include <bits/stdc++.h>
#define fi first
#define se second
#define pb push_back
#define endl "\n"
#define int long long
using namespace std;
const int N = 300111;
int n, m, a, b, c, d;
string s;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
// freopen("input.txt","r",stdin);
cin ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 831,151 | 831,152 | u067866475 | cpp |
p03017 | #define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
#define fi first
#define se second
#define pb push_back
#define E "\n";
using namespace std;
const long long MOD = (long long)1e9 + 7;
int n, a, b, c, d;
string s;
bool fun1(int x, int y) {
for (int i = x + 2; i < y; i++) {
if (s[i - 1] == '#' && s[i] ==... | #define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
#define fi first
#define se second
#define pb push_back
#define E "\n";
using namespace std;
const long long MOD = (long long)1e9 + 7;
int n, a, b, c, d;
string s;
bool fun1(int x, int y) {
for (int i = x + 2; i < y; i++) {
if (s[i - 1] == '#' && s[i] ==... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 831,162 | 831,164 | u398025421 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
const ll mod = 1e9 + 7;
const ll INF = 1LL << 60;
int main()... | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
const ll mod = 1e9 + 7;
const ll INF = 1LL << 60;
int main()... | [
"control_flow.loop.for.initializer.change"
] | 831,171 | 831,173 | u553605501 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
const ll mod = 1e9 + 7;
const ll INF = 1LL << 60;
int main()... | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
const ll mod = 1e9 + 7;
const ll INF = 1LL << 60;
int main()... | [
"control_flow.loop.for.initializer.change"
] | 831,174 | 831,173 | u553605501 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
const ll mod = 1e9 + 7;
const ll INF = 1LL << 60;
int main()... | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
const ll mod = 1e9 + 7;
const ll INF = 1LL << 60;
int main()... | [
"control_flow.loop.for.initializer.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 831,175 | 831,173 | u553605501 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <list>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string str = "0", strtemp;
ci... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <list>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string str = "0", strtemp;
ci... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 831,176 | 831,177 | u947304300 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define REP(i, N) for (int i = 0; i < N; i++)
#define REP1(i, N) for (int i = 1; i < N; i++)
#define RREP(i, N) for (int i = N - 1; i >= 0; --i)
#define ANS(a) cout << a << endl;
#define SORT(V) sort(V.begin(), V.end()... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define REP(i, N) for (int i = 0; i < N; i++)
#define REP1(i, N) for (int i = 1; i < N; i++)
#define RREP(i, N) for (int i = N - 1; i >= 0; --i)
#define ANS(a) cout << a << endl;
#define SORT(V) sort(V.begin(), V.end()... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 831,182 | 831,183 | u013373291 | cpp |
p03017 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
#define ll long long
#define ... | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
#define ll long long
#define ... | [] | 831,199 | 831,200 | u241367243 | cpp |
p03017 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
#define ll long long
#define ... | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
#define ll long long
#define ... | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 831,202 | 831,200 | u241367243 | cpp |
p03017 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define pb push_back
#define mp make_pair
#define all(a) begin(a), end(a)
#define FOR(x, val, to) for (int x = (val); x < int((to)); ++x)
#define FORE(x, val, to) for (auto x = (val); x <= (to); ++x)
#define FORR(x, a... | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define pb push_back
#define mp make_pair
#define all(a) begin(a), end(a)
#define FOR(x, val, to) for (int x = (val); x < int((to)); ++x)
#define FORE(x, val, to) for (auto x = (val); x <= (to); ++x)
#define FORR(x, a... | [
"identifier.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 831,212 | 831,213 | u761407600 | cpp |
p03017 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define pb push_back
#define mp make_pair
#define all(a) begin(a), end(a)
#define FOR(x, val, to) for (int x = (val); x < int((to)); ++x)
#define FORE(x, val, to) for (auto x = (val); x <= (to); ++x)
#define FORR(x, a... | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define pb push_back
#define mp make_pair
#define all(a) begin(a), end(a)
#define FOR(x, val, to) for (int x = (val); x < int((to)); ++x)
#define FORE(x, val, to) for (auto x = (val); x <= (to); ++x)
#define FORR(x, a... | [
"identifier.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 831,215 | 831,213 | u761407600 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, d;
string s;
bool match = true;
cin >> n >> a >> b >> c >> d >> s;
a--;
b--;
c--;
d--;
for (int i = a; i < max(c, d); i++) {
if (s[i] == '#' && s[i + 1] == '#')
match = false;
}
if (c > d) {
for (int i = b... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, d;
string s;
bool match = true;
cin >> n >> a >> b >> c >> d >> s;
a--;
b--;
c--;
d--;
for (int i = a; i < max(c, d); i++) {
if (s[i] == '#' && s[i + 1] == '#')
match = false;
}
if (c > d) {
for (int i = b... | [
"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"
] | 831,216 | 831,217 | u710135612 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, d;
string s;
bool match = true;
cin >> n >> a >> b >> c >> d >> s;
a--;
b--;
c--;
d--;
for (int i = a; i < max(c, d); i++) {
if (s[i] == '#' && s[i + 1] == '#')
match = false;
}
if (c > d) {
for (int i = b... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, d;
string s;
bool match = true;
cin >> n >> a >> b >> c >> d >> s;
a--;
b--;
c--;
d--;
for (int i = a; i < max(c, d); i++) {
if (s[i] == '#' && s[i + 1] == '#')
match = false;
}
if (c > d) {
for (int i = b... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 831,219 | 831,217 | u710135612 | cpp |
p03017 | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
typedef uns... | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
typedef uns... | [
"control_flow.loop.for.initializer.change",
"control_flow.loop.for.condition.change"
] | 831,225 | 831,227 | u348670055 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
#define watch(x) cerr << (#x) << ": " << (x) << endl
bool bad(int a, int c, string s) {
int cnt = 0;
for (int i = a; i < c; ++i) {
if (s[i] == '#')
cnt++;
else
cnt = 0;
if (cnt == 2)
return true;
}
return false;
}
bool criss(int a, i... | #include <bits/stdc++.h>
using namespace std;
#define watch(x) cerr << (#x) << ": " << (x) << endl
bool bad(int a, int c, string s) {
int cnt = 0;
for (int i = a; i < c; ++i) {
if (s[i] == '#')
cnt++;
else
cnt = 0;
if (cnt == 2)
return true;
}
return false;
}
bool criss(int a, i... | [
"expression.unary.arithmetic.add"
] | 831,228 | 831,229 | u455309216 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define T_ template
#define Tn typename
T_<Tn T> inline bool cmin(T &a, const T &b) { return a > b ? a = b, 1 : 0; }
T_<Tn T> inline bool cmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }
T_<Tn L, Tn R> ostream &operator<<(ostream &out, pair<L, ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define T_ template
#define Tn typename
T_<Tn T> inline bool cmin(T &a, const T &b) { return a > b ? a = b, 1 : 0; }
T_<Tn T> inline bool cmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }
T_<Tn L, Tn R> ostream &operator<<(ostream &out, pair<L, ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 831,240 | 831,241 | u890171625 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define T_ template
#define Tn typename
T_<Tn T> inline bool cmin(T &a, const T &b) { return a > b ? a = b, 1 : 0; }
T_<Tn T> inline bool cmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }
T_<Tn L, Tn R> ostream &operator<<(ostream &out, pair<L, ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define T_ template
#define Tn typename
T_<Tn T> inline bool cmin(T &a, const T &b) { return a > b ? a = b, 1 : 0; }
T_<Tn T> inline bool cmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }
T_<Tn L, Tn R> ostream &operator<<(ostream &out, pair<L, ... | [
"control_flow.loop.for.condition.change"
] | 831,242 | 831,241 | u890171625 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define T_ template
#define Tn typename
T_<Tn T> inline bool cmin(T &a, const T &b) { return a > b ? a = b, 1 : 0; }
T_<Tn T> inline bool cmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }
T_<Tn L, Tn R> ostream &operator<<(ostream &out, pair<L, ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define T_ template
#define Tn typename
T_<Tn T> inline bool cmin(T &a, const T &b) { return a > b ? a = b, 1 : 0; }
T_<Tn T> inline bool cmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }
T_<Tn L, Tn R> ostream &operator<<(ostream &out, pair<L, ... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 831,243 | 831,241 | u890171625 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define T_ template
#define Tn typename
T_<Tn T> inline bool cmin(T &a, const T &b) { return a > b ? a = b, 1 : 0; }
T_<Tn T> inline bool cmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }
T_<Tn L, Tn R> ostream &operator<<(ostream &out, pair<L, ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define T_ template
#define Tn typename
T_<Tn T> inline bool cmin(T &a, const T &b) { return a > b ? a = b, 1 : 0; }
T_<Tn T> inline bool cmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }
T_<Tn L, Tn R> ostream &operator<<(ostream &out, pair<L, ... | [
"control_flow.loop.for.initializer.change",
"expression.operation.binary.remove",
"control_flow.loop.for.condition.change"
] | 831,244 | 831,241 | u890171625 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define T_ template
#define Tn typename
T_<Tn T> inline bool cmin(T &a, const T &b) { return a > b ? a = b, 1 : 0; }
T_<Tn T> inline bool cmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }
T_<Tn L, Tn R> ostream &operator<<(ostream &out, pair<L, ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define T_ template
#define Tn typename
T_<Tn T> inline bool cmin(T &a, const T &b) { return a > b ? a = b, 1 : 0; }
T_<Tn T> inline bool cmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }
T_<Tn L, Tn R> ostream &operator<<(ostream &out, pair<L, ... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.remove"
] | 831,245 | 831,241 | u890171625 | cpp |
p03017 | #include <cstdio>
#include <iostream>
using namespace std;
int n, a, b, c, d;
string s;
int main() {
cin >> n >> a >> b >> c >> d >> s;
s = '-' + s;
for (int i = a; i < c - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
puts("No");
return 0;
}
}
for (int i = b; i < d - 1; i++) {
if (s... | #include <cstdio>
#include <iostream>
using namespace std;
int n, a, b, c, d;
string s;
int main() {
cin >> n >> a >> b >> c >> d >> s;
s = '-' + s;
for (int i = a; i < c - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
puts("No");
return 0;
}
}
for (int i = b; i < d - 1; i++) {
if (s... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 831,256 | 831,258 | u093170535 | cpp |
p03017 | // Copyright: lzt
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef long dou... | // Copyright: lzt
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef long dou... | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 831,261 | 831,262 | u357800105 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using lli = long long int;
int inf = 1000000007;
using namespace std;
int N, A, B, C, D;
string S;
int main() {
cin >> N >> A >> B >> C ... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using lli = long long int;
int inf = 1000000007;
using namespace std;
int N, A, B, C, D;
string S;
int main() {
cin >> N >> A >> B >> C ... | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 831,268 | 831,269 | u134381136 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using lli = long long int;
int inf = 1000000007;
using namespace std;
int N, A, B, C, D;
string S;
int main() {
cin >> N >> A >> B >> C ... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using lli = long long int;
int inf = 1000000007;
using namespace std;
int N, A, B, C, D;
string S;
int main() {
cin >> N >> A >> B >> C ... | [
"identifier.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.change",
"literal.number.change",
"expression.off_by_one"
] | 831,270 | 831,269 | u134381136 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using lli = long long int;
int inf = 1000000007;
using namespace std;
int N, A, B, C, D;
string S;
int main() {
cin >> N >> A >> B >> C ... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using lli = long long int;
int inf = 1000000007;
using namespace std;
int N, A, B, C, D;
string S;
int main() {
cin >> N >> A >> B >> C ... | [
"identifier.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.change",
"literal.number.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change"
] | 831,271 | 831,269 | u134381136 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
using i64 = long long;
int main() {
int n, a, b, c, d;
string s;
bool ans = true;
cin >> n >> a >> b >> c >> d >> s;
for (int i = a - 1; i < max(c, d) - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
if... | #include <bits/stdc++.h>
using namespace std;
using i64 = long long;
int main() {
int n, a, b, c, d;
string s;
bool ans = true;
cin >> n >> a >> b >> c >> d >> s;
for (int i = a - 1; i < max(c, d) - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
if... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 831,280 | 831,281 | u366245083 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
using i64 = long long;
int main() {
int n, a, b, c, d;
string s;
bool ans = true;
cin >> n >> a >> b >> c >> d >> s;
for (int i = a - 1; i < max(c, d) - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
if... | #include <bits/stdc++.h>
using namespace std;
using i64 = long long;
int main() {
int n, a, b, c, d;
string s;
bool ans = true;
cin >> n >> a >> b >> c >> d >> s;
for (int i = a - 1; i < max(c, d) - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
if... | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change",
"misc.opposites",
"identifier.change",
"call.function.change",
"control_flow.branch.if.condition.change"
] | 831,283 | 831,281 | u366245083 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
using i64 = long long;
int main() {
int n, a, b, c, d;
string s;
bool ans = true;
cin >> n >> a >> b >> c >> d >> s;
for (int i = a - 1; i < max(c, d) - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
if... | #include <bits/stdc++.h>
using namespace std;
using i64 = long long;
int main() {
int n, a, b, c, d;
string s;
bool ans = true;
cin >> n >> a >> b >> c >> d >> s;
for (int i = a - 1; i < max(c, d) - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
if... | [
"identifier.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.change",
"literal.number.change",
"expression.off_by_one",
"misc.opposites",
"call.function.change",
"control_flow.branch.if.condition.change"
] | 831,284 | 831,281 | u366245083 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007LL;
long long GCD(long long a, long long b) { return b == 0 ? a : GCD(b, a % b); }
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
int... | #include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007LL;
long long GCD(long long a, long long b) { return b == 0 ? a : GCD(b, a % b); }
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
int... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 831,285 | 831,286 | u276568758 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007LL;
long long GCD(long long a, long long b) { return b == 0 ? a : GCD(b, a % b); }
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
int... | #include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007LL;
long long GCD(long long a, long long b) { return b == 0 ? a : GCD(b, a % b); }
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
int... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 831,287 | 831,286 | u276568758 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007LL;
long long GCD(long long a, long long b) { return b == 0 ? a : GCD(b, a % b); }
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
int... | #include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007LL;
long long GCD(long long a, long long b) { return b == 0 ? a : GCD(b, a % b); }
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
int... | [
"misc.opposites",
"identifier.change",
"call.function.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 831,288 | 831,286 | u276568758 | cpp |
p03017 | #include <bits/stdc++.h>
#define syosu(x) fixed << setprecision(x)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef pair<double, double> pdd;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<double> vd;
typedef vector<vd... | #include <bits/stdc++.h>
#define syosu(x) fixed << setprecision(x)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef pair<double, double> pdd;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<double> vd;
typedef vector<vd... | [
"identifier.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.change"
] | 831,296 | 831,297 | u434747175 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
t... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
t... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 831,298 | 831,300 | u194385557 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, d;
string s;
scanf("%d %d %d %d %d", &n, &a, &b, &c, &d);
cin >> s;
a--;
b--;
c--;
d--;
int x = 0, y = 0;
int m = max(c, d);
for (int i = a; i < m; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
printf("No");
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, d;
string s;
scanf("%d %d %d %d %d", &n, &a, &b, &c, &d);
cin >> s;
a--;
b--;
c--;
d--;
int x = 0, y = 0;
int m = max(c, d);
for (int i = a; i < m; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
printf("No");
... | [
"control_flow.loop.for.initializer.change"
] | 831,301 | 831,302 | u717536011 | cpp |
p03017 | #include "bits/stdc++.h"
using namespace std;
#define LL long long
#define PB push_back
#define MP make_pair
int N, A, B, C, D;
string S;
int main() {
cin >> N >> A >> B >> C >> D >> S;
A--;
B--;
C--;
D--;
if (A > B) {
swap(A, B);
swap(C, D);
}
if (C < D) {
for (int i = A; i < C; i++) {
... | #include "bits/stdc++.h"
using namespace std;
#define LL long long
#define PB push_back
#define MP make_pair
int N, A, B, C, D;
string S;
int main() {
cin >> N >> A >> B >> C >> D >> S;
A--;
B--;
C--;
D--;
if (A > B) {
swap(A, B);
swap(C, D);
}
if (C < D) {
for (int i = A; i < C; i++) {
... | [
"variable_declaration.value.change",
"identifier.change",
"control_flow.loop.for.initializer.change",
"control_flow.branch.if.condition.change"
] | 831,303 | 831,304 | u422592877 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
signed main() {
string s;
int n, sa, sb, ea, eb, end;
cin >> n >> sa >> sb >> ea >> eb;
cin >> s;
s = s + "aaaa";
eb--;
ea--;
sa--;
sb--;
bool check = false;
for (int i = sa; i < max(ea, eb); i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout ... | #include <bits/stdc++.h>
using namespace std;
signed main() {
string s;
int n, sa, sb, ea, eb, end;
cin >> n >> sa >> sb >> ea >> eb;
cin >> s;
s = s + "aaaa";
eb--;
ea--;
sa--;
sb--;
bool check = false;
for (int i = sa; i < max(ea, eb); i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout ... | [
"control_flow.loop.for.initializer.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 831,306 | 831,307 | u998997473 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
signed main() {
string s;
int n, sa, sb, ea, eb, end;
cin >> n >> sa >> sb >> ea >> eb;
cin >> s;
s = s + "aaaa";
eb--;
ea--;
sa--;
sb--;
bool check = false;
for (int i = sa; i < max(ea, eb); i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout ... | #include <bits/stdc++.h>
using namespace std;
signed main() {
string s;
int n, sa, sb, ea, eb, end;
cin >> n >> sa >> sb >> ea >> eb;
cin >> s;
s = s + "aaaa";
eb--;
ea--;
sa--;
sb--;
bool check = false;
for (int i = sa; i < max(ea, eb); i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout ... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 831,308 | 831,307 | u998997473 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 50;
int n;
int a, b, c, d;
string s;
int cnt;
int main() {
cin >> n;
cin >> a >> b >> c >> d;
cin >> s;
s = ' ' + s;
if (c < d) {
cnt = 0;
for (int i = a; i <= d + 1; i++) {
if (s[i] == s[i + 1] && s[i] == '#') {
cnt++;
... | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 50;
int n;
int a, b, c, d;
string s;
int cnt;
int main() {
cin >> n;
cin >> a >> b >> c >> d;
cin >> s;
s = ' ' + s;
if (c < d) {
cnt = 0;
for (int i = a; i <= d; i++) {
if (s[i] == s[i + 1] && s[i] == '#') {
cnt++;
... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change",
"misc.off_by_one"
] | 831,315 | 831,316 | u979516092 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 50;
int n;
int a, b, c, d;
string s;
int cnt;
int main() {
cin >> n;
cin >> a >> b >> c >> d;
cin >> s;
s = ' ' + s;
if (c < d) {
cnt = 0;
for (int i = a; i <= d; i++) {
if (s[i] == s[i + 1] && s[i] == '#') {
cnt++;
... | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 50;
int n;
int a, b, c, d;
string s;
int cnt;
int main() {
cin >> n;
cin >> a >> b >> c >> d;
cin >> s;
s = ' ' + s;
if (c < d) {
cnt = 0;
for (int i = a; i <= d; i++) {
if (s[i] == s[i + 1] && s[i] == '#') {
cnt++;
... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 831,317 | 831,316 | u979516092 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 50;
int n;
int a, b, c, d;
string s;
int cnt;
int main() {
cin >> n;
cin >> a >> b >> c >> d;
cin >> s;
s = ' ' + s;
if (c < d) {
cnt = 0;
for (int i = a; i <= d; i++) {
if (s[i] == s[i + 1] && s[i] == '#') {
cnt++;
... | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 50;
int n;
int a, b, c, d;
string s;
int cnt;
int main() {
cin >> n;
cin >> a >> b >> c >> d;
cin >> s;
s = ' ' + s;
if (c < d) {
cnt = 0;
for (int i = a; i <= d; i++) {
if (s[i] == s[i + 1] && s[i] == '#') {
cnt++;
... | [
"control_flow.loop.for.initializer.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 831,318 | 831,316 | u979516092 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int n, a, b, c, d;
string s;
int dem;
int main() {
cin >> n >> a >> b >> c >> d;
cin >> s;
s = " " + s;
if (c < d) {
for (int i = a; i <= d - 1; i++) {
if (s[i] == s[i + 1] && s[i] == '#') {
cout << "No";
return 0;
}
}
cout <<... | #include <bits/stdc++.h>
using namespace std;
int n, a, b, c, d;
string s;
int dem;
int main() {
cin >> n >> a >> b >> c >> d;
cin >> s;
s = " " + s;
if (c < d) {
for (int i = a; i <= d - 1; i++) {
if (s[i] == s[i + 1] && s[i] == '#') {
cout << "No";
return 0;
}
}
cout <<... | [
"control_flow.loop.for.initializer.change"
] | 831,323 | 831,325 | u185917548 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.