problem_id stringlengths 6 6 | buggy_code stringlengths 8 526k | fixed_code stringlengths 12 526k | labels listlengths 0 15 ⌀ | buggy_submission_id int64 1 1.54M | fixed_submission_id int64 2 1.54M | user_id stringlengths 10 10 | language stringclasses 8
values |
|---|---|---|---|---|---|---|---|
p03053 | #include <bits/stdc++.h>
using namespace std;
int main() {
int H, W;
cin >> H >> W;
vector<vector<char>> Masu(H, vector<char>(W));
vector<vector<int>> Map(H, vector<int>(W, -1));
deque<int> queY;
deque<int> queX;
getchar();
for (int i = 0; i < W; i++) {
for (int j = 0; j < H; j++) {
Masu[i][j]... | #include <bits/stdc++.h>
using namespace std;
int main() {
int H, W;
cin >> H >> W;
vector<vector<char>> Masu(H, vector<char>(W));
vector<vector<int>> Map(H, vector<int>(W, -1));
deque<int> queY;
deque<int> queX;
getchar();
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
Masu[i][j]... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 868,694 | 868,695 | u501643136 | cpp |
p03053 | #include <algorithm>
#include <bits/stdc++.h>
#include <deque>
#include <numeric>
#include <utility>
#include <vector>
#define sign(a) ((a > 0) - (a < 0))
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define LL long long
#define INF (LL)(1LL << 60)
#define all(a) a.begin(), a.end()
#define gr greater<LL>()
usi... | #include <algorithm>
#include <bits/stdc++.h>
#include <deque>
#include <numeric>
#include <utility>
#include <vector>
#define sign(a) ((a > 0) - (a < 0))
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define LL long long
#define INF (LL)(1LL << 60)
#define all(a) a.begin(), a.end()
#define gr greater<LL>()
usi... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 868,710 | 868,711 | u414425367 | cpp |
p03053 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define ALL(a) (a).begin(), (a).end()
using namespace std;
using ll = long long;
using P = pair<int, int>;
int h, w;
vector<string> field(1000);
vector<vector<int>> d(1000, vector<int>(1000));
int INF = 1e9;
vector<int> dx = {1, 0, -1, 0}, dy = ... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define ALL(a) (a).begin(), (a).end()
using namespace std;
using ll = long long;
using P = pair<int, int>;
int h, w;
vector<string> field(1000);
vector<vector<int>> d(1000, vector<int>(1000));
int INF = 1e9;
vector<int> dx = {1, 0, -1, 0}, dy = ... | [
"identifier.change",
"call.arguments.change"
] | 868,712 | 868,713 | u346629192 | cpp |
p03053 | #include <bits/stdc++.h>
#include <type_traits>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define ddrep(i, n) for (int i = n; i > 0; --i)
#define srep(i, s, t) for (in... | #include <bits/stdc++.h>
#include <type_traits>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define ddrep(i, n) for (int i = n; i > 0; --i)
#define srep(i, s, t) for (in... | [] | 868,735 | 868,736 | u700484101 | cpp |
p03053 | /*Function Template*/
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int MAX = 510000;
const int MOD = 1000000007;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define ALL(a) (a).begin(), (a).end()
#define IOS \
ios::s... | /*Function Template*/
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int MAX = 510000;
const int MOD = 1000000007;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define ALL(a) (a).begin(), (a).end()
#define IOS \
ios::s... | [
"expression.operation.binary.change"
] | 868,739 | 868,740 | u264265458 | cpp |
p03053 | /*Function Template*/
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int MAX = 510000;
const int MOD = 1000000007;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define ALL(a) (a).begin(), (a).end()
#define IOS \
ios::s... | /*Function Template*/
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int MAX = 510000;
const int MOD = 1000000007;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define ALL(a) (a).begin(), (a).end()
#define IOS \
ios::s... | [
"expression.operation.binary.change",
"assignment.value.change",
"variable_access.subscript.index.change"
] | 868,741 | 868,740 | u264265458 | cpp |
p03053 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
// 方向ベクトル
int dx[4] = {1,... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
// 方向ベクトル
int dx[4] = {1,... | [] | 868,742 | 868,743 | u828388155 | cpp |
p03053 | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define REP(i, m, n) for (int i = m; i ... | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define REP(i, m, n) for (int i = m; i ... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 868,753 | 868,754 | u020230257 | cpp |
p03053 | #include <bits/stdc++.h>
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (ll i = (ll)(a); i < (ll)(b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define ll long long
#define lld long double
#define ALL(x) x.begin(), x.end()
using n... | #include <bits/stdc++.h>
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (ll i = (ll)(a); i < (ll)(b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define ll long long
#define lld long double
#define ALL(x) x.begin(), x.end()
using n... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 868,755 | 868,756 | u174404613 | cpp |
p03053 | #include <iostream>
#include <queue>
using namespace std;
const int MAX_N = 1e3 + 5;
int dist[MAX_N][MAX_N];
int ni[4] = {1, 0, -1, 0};
int nj[4] = {0, 1, 0, -1};
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<pair<int, int>> zeros;
for (int i = 1; i <= n; i++) {
for (int ... | #include <iostream>
#include <queue>
using namespace std;
const int MAX_N = 1e3 + 5;
int dist[MAX_N][MAX_N];
int ni[4] = {1, 0, -1, 0};
int nj[4] = {0, 1, 0, -1};
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<pair<int, int>> zeros;
for (int i = 1; i <= n; i++) {
for (int ... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 868,784 | 868,785 | u882575405 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
typedef vector<vector<char>> field_t;
typedef pair<int, int> point_t;
// point_tの足し算
point_t operator+(const point_t &lhs, const point_t &rhs) {
point_t res;
res.first = lhs.first + rhs.first;
res.second = lhs.second + rhs.second;
return res;
}
//範囲内外判定
bool is_i... | #include <bits/stdc++.h>
using namespace std;
typedef vector<vector<char>> field_t;
typedef pair<int, int> point_t;
// point_tの足し算
point_t operator+(const point_t &lhs, const point_t &rhs) {
point_t res;
res.first = lhs.first + rhs.first;
res.second = lhs.second + rhs.second;
return res;
}
//範囲内外判定
bool is_i... | [
"identifier.change",
"call.arguments.change"
] | 868,799 | 868,800 | u115927976 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
typedef vector<vector<char>> field_t;
typedef pair<int, int> point_t;
// point_tの足し算
point_t operator+(const point_t &lhs, const point_t &rhs) {
point_t res;
res.first = lhs.first + rhs.first;
res.second = lhs.second + rhs.second;
return res;
}
//範囲内外判定
bool is_i... | #include <bits/stdc++.h>
using namespace std;
typedef vector<vector<char>> field_t;
typedef pair<int, int> point_t;
// point_tの足し算
point_t operator+(const point_t &lhs, const point_t &rhs) {
point_t res;
res.first = lhs.first + rhs.first;
res.second = lhs.second + rhs.second;
return res;
}
//範囲内外判定
bool is_i... | [
"identifier.change",
"call.arguments.change",
"control_flow.return.add",
"control_flow.return.0.add"
] | 868,802 | 868,800 | u115927976 | cpp |
p03053 | #include <cstdio>
#include <queue>
#include <tuple>
using namespace std;
int main(int argc, char const *argv[]) {
int h, w;
scanf("%d %d\n", h, w);
char maze[h][w + 1];
for (int i = 0; i < h; i++) {
scanf("%s\n", maze[i]);
}
int ans = 0;
queue<tuple<int, int, int>> que;
for (int i = 0; i < h; i++)... | #include <cstdio>
#include <queue>
#include <tuple>
using namespace std;
int main(int argc, char const *argv[]) {
int h, w;
scanf("%d %d\n", &h, &w);
char maze[h][w + 1];
for (int i = 0; i < h; i++) {
scanf("%s\n", maze[i]);
}
int ans = 0;
queue<tuple<int, int, int>> que;
for (int i = 0; i < h; i+... | [
"expression.operation.unary.reference.add"
] | 868,807 | 868,808 | u445784649 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
int main() {
long H, W;
cin >> H >> W;
vector<vector<long>> data(H, vector<long>(W, INT_MAX));
char a;
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
cin >> a;
if (a == '#')
data.at(i).at(j) = 0;
}
}
for (int i = 0; i <... | #include <bits/stdc++.h>
using namespace std;
int main() {
long H, W;
cin >> H >> W;
vector<vector<long>> data(H, vector<long>(W, INT_MAX));
char a;
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
cin >> a;
if (a == '#')
data.at(i).at(j) = 0;
}
}
for (int i = 0; i <... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 868,809 | 868,810 | u239087789 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
struct Fast {
Fast() {
std::cin.tie(0);
ios::sync_with_stdio(false);
}
} fast;
/* short */
#define pb push_back
#define mp make_pair
#define fst first
#define snd second
#define ALL(v) begin(v), end(v)
/* REPmacro */
#define FOR(i, s, n) for (int i = (s); i <... | #include <bits/stdc++.h>
using namespace std;
struct Fast {
Fast() {
std::cin.tie(0);
ios::sync_with_stdio(false);
}
} fast;
/* short */
#define pb push_back
#define mp make_pair
#define fst first
#define snd second
#define ALL(v) begin(v), end(v)
/* REPmacro */
#define FOR(i, s, n) for (int i = (s); i <... | [
"call.arguments.change",
"call.arguments.add"
] | 868,816 | 868,817 | u106964380 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define all(v) v.begin(), v.end()
using in = int64_t;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
const double PI = 3.14159265358979323846;
const int64_t waru = 1000000007;
const in INF = 1 << 30;
#define vec2(a, y, x) vector<vector<char>> a(... | #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define all(v) v.begin(), v.end()
using in = int64_t;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
const double PI = 3.14159265358979323846;
const int64_t waru = 1000000007;
const in INF = 1 << 30;
#define vec2(a, y, x) vector<vector<char>> a(... | [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 868,824 | 868,825 | u424602097 | cpp |
p03053 | #include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#inclu... | #include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#inclu... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 868,844 | 868,845 | u303039933 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
int R, C;
char G[1005][1005];
queue<pair<int, pair<int, int>>> Q;
int dist[1005][1005];
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
int main() {
cin >> R >> C;
for (int i = 0; i < R; i++) {
for (int j = 0; j < C; j++) {
cin >> G[i][j];
if (... | #include <bits/stdc++.h>
using namespace std;
int R, C;
char G[1005][1005];
queue<pair<int, pair<int, int>>> Q;
int dist[1005][1005];
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
int main() {
cin >> R >> C;
for (int i = 0; i < R; i++) {
for (int j = 0; j < C; j++) {
cin >> G[i][j];
if (... | [
"assignment.change"
] | 868,852 | 868,853 | u532047586 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
int main() {
int H, W;
cin >> H >> W;
char board[H][W];
for (int i = 0; i < H; i++)
for (int j = 0; j < W; j++)
cin >> board[i][j];
int dis[H][W];
for (int i = 0; i < H; i++)
for (int j = 0; j < W; j++)
dis[i][j] = (board[i][j] == '#') ? 0 ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int H, W;
cin >> H >> W;
char board[H][W];
for (int i = 0; i < H; i++)
for (int j = 0; j < W; j++)
cin >> board[i][j];
int dis[H][W];
for (int i = 0; i < H; i++)
for (int j = 0; j < W; j++)
dis[i][j] = (board[i][j] == '#') ? 0 ... | [
"variable_declaration.add",
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 868,875 | 868,876 | u052247353 | cpp |
p03053 | #include <iostream>
#include <stdio.h>
#include <vector>
int main(int argc, char **argv) {
int H, W;
std::cin >> H;
std::cin >> W;
std::vector<char> A;
std::vector<int> vIndex;
for (int h = 0; h < H; h++) {
for (int w = 0; w < W; w++) {
char Aij;
std::cin >> Aij;
A.push_back(Aij);
... | #include <iostream>
#include <stdio.h>
#include <vector>
int main(int argc, char **argv) {
int H, W;
std::cin >> H;
std::cin >> W;
std::vector<char> A;
std::vector<int> vIndex;
for (int h = 0; h < H; h++) {
for (int w = 0; w < W; w++) {
char Aij;
std::cin >> Aij;
A.push_back(Aij);
... | [
"expression.unary.arithmetic.add"
] | 868,881 | 868,882 | u547728054 | cpp |
p03053 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <tupl... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <tupl... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 868,883 | 868,884 | u574045761 | cpp |
p03053 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <limits>
#include <numeric>
#include <string>
#include <vector>
int main() {
int H, W;
int int_max = 10000;
std::vector<std::string> A;
std::vector<std::vector<std::vector<int>>> dp;
std::cin >> H >> W;
A = std::vector<std::string>(H, " "... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <limits>
#include <numeric>
#include <string>
#include <vector>
int main() {
int H, W;
int int_max = 10000;
std::vector<std::string> A;
std::vector<std::vector<std::vector<int>>> dp;
std::cin >> H >> W;
A = std::vector<std::string>(H, " "... | [
"assignment.change",
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 868,898 | 868,899 | u005702636 | cpp |
p03053 | #include <bits/stdc++.h>
#define _CRT_SECURE_NO_WARNINGS
#define ll long long
#define BUF 1e5
#define INF 1 << 30
using namespace std;
ll MOD = 1e9 + 7;
ll A, B, C, D, G, H, N, M, L, K, P, Q, R, W, X, Y, Z;
string S;
int ans = 0;
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
int main() {
cin >> H >> W;
vect... | #include <bits/stdc++.h>
#define _CRT_SECURE_NO_WARNINGS
#define ll long long
#define BUF 1e5
#define INF 1 << 30
using namespace std;
ll MOD = 1e9 + 7;
ll A, B, C, D, G, H, N, M, L, K, P, Q, R, W, X, Y, Z;
string S;
int ans = 0;
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
int main() {
cin >> H >> W;
vect... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 868,900 | 868,901 | u030090262 | cpp |
p03053 | #include <iostream>
#include <queue>
using namespace std;
static const int MAX = 1002;
typedef pair<int, int> P;
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, 1, -1};
bool used[MAX][MAX] = {};
int H, W;
char a[MAX][MAX];
int bfs() {
queue<P> que;
queue<int> num;
for (int i = 0; i < H; i++) {
for (int j = ... | #include <iostream>
#include <queue>
using namespace std;
static const int MAX = 1002;
typedef pair<int, int> P;
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, 1, -1};
bool used[MAX][MAX] = {};
int H, W;
char a[MAX][MAX];
int bfs() {
queue<P> que;
queue<int> num;
for (int i = 0; i < H; i++) {
for (int j = ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 868,925 | 868,926 | u660341491 | cpp |
p03053 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
#define CHMAX(a, b) a = std::max(a, b)
#define CHMIN(a, b) a = std::min(a, b)
#define CHABS(a) a = std::abs(a)
#define COUT(a) std::cout << a << std::endl
#define CERR(a) std... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
#define CHMAX(a, b) a = std::max(a, b)
#define CHMIN(a, b) a = std::min(a, b)
#define CHABS(a) a = std::abs(a)
#define COUT(a) std::cout << a << std::endl
#define CERR(a) std... | [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 868,929 | 868,930 | u155216115 | cpp |
p03053 | #include <algorithm>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
struct Square {
int x;
int y;
int dist;
Square(int _x, int _y, int _dist) : x(_x), y(_y), dist(_dist) {}
};
int main() {
int H, W;
cin >> H >> W;... | #include <algorithm>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
struct Square {
int x;
int y;
int dist;
Square(int _x, int _y, int _dist) : x(_x), y(_y), dist(_dist) {}
};
int main() {
int H, W;
cin >> H >> W;... | [
"call.arguments.change",
"call.arguments.add"
] | 868,939 | 868,940 | u420528322 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
const ll INF64 = 1LL << 60;
const int INF32 = 1 << 29;
const int MOD = 1000000007;
const int dx[] = {0, 0, 1, -1};
const int dy[] = {1, -1, 0, 0};
int h, w, n;
vector<string> s;
vector<vector<int>> steps;
void bfs(vector<... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
const ll INF64 = 1LL << 60;
const int INF32 = 1 << 29;
const int MOD = 1000000007;
const int dx[] = {0, 0, 1, -1};
const int dy[] = {1, -1, 0, 0};
int h, w, n;
vector<string> s;
vector<vector<int>> steps;
void bfs(vector<... | [
"call.arguments.change",
"call.arguments.add"
] | 868,941 | 868,942 | u335667012 | cpp |
p03053 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define MOD 1000000007
using namespace std;
typedef long long int ll;
const ll INF = (ll)1e18;
int dx... | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define MOD 1000000007
using namespace std;
typedef long long int ll;
const ll INF = (ll)1e18;
int dx... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 868,946 | 868,947 | u868089307 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a) for (int i = 0; i < (a); i++)
typedef long long ll;
typedef pair<int, int> P;
const int INF = 1e9;
const int MOD = 1e9 + 7;
#define MAX 1000
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int main() {
int h, w;
cin >> h >> w;
char a[h][w];
REP... | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a) for (int i = 0; i < (a); i++)
typedef long long ll;
typedef pair<int, int> P;
const int INF = 1e9;
const int MOD = 1e9 + 7;
#define MAX 1000
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int main() {
int h, w;
cin >> h >> w;
char a[h][w];
REP... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 868,953 | 868,954 | u366398972 | cpp |
p03053 | #include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
typedef long long ll;
// typedef pair<ll, ll> P;
typedef pair<int, int> P;
#define MOD 1000000007
#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 ... | #include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
typedef long long ll;
// typedef pair<ll, ll> P;
typedef pair<int, int> P;
#define MOD 1000000007
#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 ... | [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 868,957 | 868,958 | u722397179 | cpp |
p03053 | #include <iostream>
#include <queue>
using namespace std;
const int INF = (int)1e9;
struct dat {
int x, y, d;
};
int H, W;
char grid[1000][1000];
int dist[1000][1000];
int ans;
int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
queue<dat> que;
cin >> H >... | #include <iostream>
#include <queue>
using namespace std;
const int INF = (int)1e9;
struct dat {
int x, y, d;
};
int H, W;
char grid[1000][1000];
int dist[1000][1000];
int ans = 0;
int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
queue<dat> que;
cin >>... | [
"variable_declaration.value.change",
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 868,961 | 868,960 | u525137785 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
struct P {
int x, y;
};
int h, w, k;
char a[1111][1111];
int o[1111][1111], dx[10] = {1, 0, -1, 0}, dy[10] = {0, 1, 0, -1};
queue<P> q;
int main() {
memset(o, -1, sizeof(o));
scanf("%d %d", &h, &w);
for (int i = 1; i <= h; i++)
scanf("%s", a[i] + 1);
for (in... | #include <bits/stdc++.h>
using namespace std;
struct P {
int x, y;
};
int h, w, k;
char a[1111][1111];
int o[1111][1111], dx[10] = {1, 0, -1, 0}, dy[10] = {0, 1, 0, -1};
queue<P> q;
int main() {
memset(o, -1, sizeof(o));
scanf("%d %d", &h, &w);
for (int i = 1; i <= h; i++)
scanf("%s", a[i] + 1);
for (in... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 868,962 | 868,963 | u428070871 | cpp |
p03053 | /*
こんにちは。あたしはｶｳｶﾞｰﾙ。
redcoderになるためAtCoderを巡る旅をしてます。
＿_
ヽ|＿_|ノ ﾓｫ
||‘‐‘||ﾚ _)_, ―‐ 、
/(Ｙ (ヽ＿ /・ ヽ ￣ヽ
∠ ＿ ゝ ｀^ヽ ﾉ.::::_(ノヽ
_/ヽ /ヽ￣￣/ヽ
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define dump(x) cout << #x << " = " << (x) << endl
#define YES(n) cout <... | /*
こんにちは。あたしはｶｳｶﾞｰﾙ。
redcoderになるためAtCoderを巡る旅をしてます。
＿_
ヽ|＿_|ノ ﾓｫ
||‘‐‘||ﾚ _)_, ―‐ 、
/(Ｙ (ヽ＿ /・ ヽ ￣ヽ
∠ ＿ ゝ ｀^ヽ ﾉ.::::_(ノヽ
_/ヽ /ヽ￣￣/ヽ
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define dump(x) cout << #x << " = " << (x) << endl
#define YES(n) cout <... | [] | 868,966 | 868,967 | u038027079 | cpp |
p03053 | /*
こんにちは。あたしはｶｳｶﾞｰﾙ。
redcoderになるためAtCoderを巡る旅をしてます。
＿_
ヽ|＿_|ノ ﾓｫ
||‘‐‘||ﾚ _)_, ―‐ 、
/(Ｙ (ヽ＿ /・ ヽ ￣ヽ
∠ ＿ ゝ ｀^ヽ ﾉ.::::_(ノヽ
_/ヽ /ヽ￣￣/ヽ
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define dump(x) cout << #x << " = " << (x) << endl
#define YES(n) cout <... | /*
こんにちは。あたしはｶｳｶﾞｰﾙ。
redcoderになるためAtCoderを巡る旅をしてます。
＿_
ヽ|＿_|ノ ﾓｫ
||‘‐‘||ﾚ _)_, ―‐ 、
/(Ｙ (ヽ＿ /・ ヽ ￣ヽ
∠ ＿ ゝ ｀^ヽ ﾉ.::::_(ノヽ
_/ヽ /ヽ￣￣/ヽ
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define dump(x) cout << #x << " = " << (x) << endl
#define YES(n) cout <... | [
"expression.operation.unary.arithmetic.remove",
"expression.operation.unary.arithmetic.add"
] | 868,968 | 868,967 | u038027079 | cpp |
p03053 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <deque>
#include <functional>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include ... | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <deque>
#include <functional>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include ... | [
"call.arguments.change",
"call.arguments.add",
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 868,995 | 868,996 | u502721867 | cpp |
p03053 | #include <cstdlib>
#include <iostream>
#include <queue>
#include <tuple>
#include <vector>
using namespace std;
int main() {
int h, w;
cin >> h >> w;
queue<pair<int, int>> queue;
vector<vector<int>> dmap;
for (int i = 0; i < h; i++) {
char c;
dmap.emplace(dmap.end(), w, -1);
for (int j = 0; j <... | #include <cstdlib>
#include <iostream>
#include <queue>
#include <tuple>
#include <vector>
using namespace std;
int main() {
int h, w;
cin >> h >> w;
queue<pair<int, int>> queue;
vector<vector<int>> dmap;
for (int i = 0; i < h; i++) {
char c;
dmap.emplace(dmap.end(), w, -1);
for (int j = 0; j <... | [] | 869,000 | 869,001 | u321226359 | cpp |
p03053 | #include <bits/stdc++.h>
#include <numeric>
#include <vector>
#define PI 3.14159265358979323846
#define MAXINF 1e18L
#define INF 1e9L
#define EPS 1e-9
#define REP(i, n) for (int i = 0; i < int(n); ++i)
#define Rep(i, sta, n) for (int i = sta; i < n; i++)
#define RREP(i, n) for (int i = int(n) - 1; i >= 0; --i)
#define ... | #include <bits/stdc++.h>
#include <numeric>
#include <vector>
#define PI 3.14159265358979323846
#define MAXINF 1e18L
#define INF 1e9L
#define EPS 1e-9
#define REP(i, n) for (int i = 0; i < int(n); ++i)
#define Rep(i, sta, n) for (int i = sta; i < n; i++)
#define RREP(i, n) for (int i = int(n) - 1; i >= 0; --i)
#define ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 869,002 | 869,003 | u528720841 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
const int dirx[4] = {1, 0, -1, 0};
const int diry[4] = {0, 1, 0, -1};
char s[1005][1005];
int used[1005][1005];
queue<tuple<int, int, int>> q;
int h, w;
bool check(int x, int y) { return x >= 1 && x <= h && y >= 1 && y <= h; }
int main() {
int ans, x, y, d, x0, y0;
... | #include <bits/stdc++.h>
using namespace std;
const int dirx[4] = {1, 0, -1, 0};
const int diry[4] = {0, 1, 0, -1};
char s[1005][1005];
int used[1005][1005];
queue<tuple<int, int, int>> q;
int h, w;
bool check(int x, int y) { return x >= 1 && x <= h && y >= 1 && y <= w; }
int main() {
int ans, x, y, d, x0, y0;
... | [
"identifier.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 869,009 | 869,010 | u593031180 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
string s[1005];
struct node {
int x, y;
int step;
node(int x, int y, int step) : x(x), y(y), step(step) {}
};
queue<node> q;
int vis[1005][1005];
int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
int main() {
ios::sync_with_stdio(false);
ci... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
string s[1005];
struct node {
int x, y;
int step;
node(int x, int y, int step) : x(x), y(y), step(step) {}
};
queue<node> q;
int vis[1005][1005];
int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
int main() {
ios::sync_with_stdio(false);
ci... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 869,024 | 869,025 | u976418120 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i <= n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end()... | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i <= n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end()... | [] | 869,028 | 869,029 | u986276444 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
const int N = 5e6;
const int X[4] = {0, 1, 0, -1}, Y[4] = {1, 0, -1, 0};
int n, m, l, r;
int q[N], v[N];
#define C getchar()
void in() {
cin >> n >> m;
C;
for (int i = 0; ++i <= n; C)
for (int j = 0; ++j <= m;)
if (C == '#')
v[q[++r] = i * m + j] = ... | #include <bits/stdc++.h>
using namespace std;
const int N = 5e6;
const int X[4] = {0, 1, 0, -1}, Y[4] = {1, 0, -1, 0};
int n, m, l, r;
int q[N], v[N];
#define C getchar()
void in() {
cin >> n >> m;
C;
for (int i = 0; ++i <= n; C)
for (int j = 0; ++j <= m;)
if (C == '#')
v[q[++r] = i * m + j] = ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 869,030 | 869,031 | u350552300 | cpp |
p03053 | #include <algorithm>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <str... | #include <algorithm>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <str... | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 869,045 | 869,046 | u500496457 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
int n, m;
char a[1005][1005];
bool check(int x, int y) {
return x >= 0 && x < n && y >= 0 && y < m && a[x][y] == '.';
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
struct node {
int x, y, step;
};
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i... | #include <bits/stdc++.h>
using namespace std;
int n, m;
char a[1005][1005];
bool check(int x, int y) {
return x >= 0 && x < n && y >= 0 && y < m && a[x][y] == '.';
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
struct node {
int x, y, step;
};
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i... | [] | 869,049 | 869,050 | u699602362 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
int n, m;
char a[1005][1005];
bool check(int x, int y) {
return x >= 0 && x < n && y >= 0 && y < m && a[x][y] == '.';
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
struct node {
int x, y, step;
};
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i... | #include <bits/stdc++.h>
using namespace std;
int n, m;
char a[1005][1005];
bool check(int x, int y) {
return x >= 0 && x < n && y >= 0 && y < m && a[x][y] == '.';
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
struct node {
int x, y, step;
};
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i... | [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 869,051 | 869,050 | u699602362 | cpp |
p03053 | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
// a
int h, w;
cin >> h >> w;
static char in[1400][1400] = {};
static int dist[1400][1400];
memset(dist, -1, sizeof(dist));
queue<pair<int, int>> que;
for (int i = 0; i < ... | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
// a
int h, w;
cin >> h >> w;
static char in[1400][1400] = {};
static int dist[1400][1400];
memset(dist, -1, sizeof(dist));
queue<pair<int, int>> que;
for (int i = 0; i < ... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 869,058 | 869,059 | u817760251 | cpp |
p03053 | #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 h, w;
bool a[1001][1001];
int main(void) {
vector<pair<lin, lin>> q;
cin >> h >> w;
rep(i,... | #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 h, w;
bool a[1001][1001];
int main(void) {
vector<pair<lin, lin>> q;
cin >> h >> w;
rep(i,... | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"assignment.variable.change"
] | 869,060 | 869,061 | u762193256 | cpp |
p03053 | #include <iostream>
#include <queue>
using namespace std;
const int INF = 100000;
typedef pair<int, int> P;
int main() {
int H, W;
char A[1000][1000];
int dist[1000][1000];
cin >> H >> W;
queue<P> que;
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
cin >> A[i][j];
if (A[i][... | #include <iostream>
#include <queue>
using namespace std;
const int INF = 100000;
typedef pair<int, int> P;
int main() {
int H, W;
char A[1000][1000];
int dist[1000][1000];
cin >> H >> W;
queue<P> que;
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
cin >> A[i][j];
if (A[i][... | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 869,062 | 869,063 | u693133807 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int c, r;
cin >> r >> c;
vector<string> g(r);
queue<tuple<int, int, int>> q;
for (int i = 0; i < r; ++i) {
cin >> g[i];
for (int j = 0; j < c; ++j) {
if (g[i][j] == '#') {
... | #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int c, r;
cin >> r >> c;
vector<string> g(r);
queue<tuple<int, int, int>> q;
for (int i = 0; i < r; ++i) {
cin >> g[i];
for (int j = 0; j < c; ++j) {
if (g[i][j] == '#') {
... | [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 869,069 | 869,070 | u499656581 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
#define y1 adfasfafa
const int maxn = 1e3 + 7;
typedef long long ll;
int n, m;
int ar[maxn];
char ch[maxn][maxn];
int vis[maxn][maxn];
queue<pair<int, int>> qu;
int desll[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i ... | #include <bits/stdc++.h>
using namespace std;
#define y1 adfasfafa
const int maxn = 1e3 + 7;
typedef long long ll;
int n, m;
int ar[maxn];
char ch[maxn][maxn];
int vis[maxn][maxn];
queue<pair<int, int>> qu;
int desll[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i ... | [
"literal.number.change",
"variable_declaration.value.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 869,089 | 869,090 | u662513110 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
using lint = long long;
const lint mod = 1e9 + 7;
#define all(x) (x).begin(), (x).end()
#define bitcount(n) __builtin_popcountl((lint)(n))
#define fcout cout << fixed << setprecision(15)
#define highest(x) (63 - __builtin_clzl(x))
template <class T> inline void YES(T condit... | #include <bits/stdc++.h>
using namespace std;
using lint = long long;
const lint mod = 1e9 + 7;
#define all(x) (x).begin(), (x).end()
#define bitcount(n) __builtin_popcountl((lint)(n))
#define fcout cout << fixed << setprecision(15)
#define highest(x) (63 - __builtin_clzl(x))
template <class T> inline void YES(T condit... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 869,097 | 869,098 | u115888500 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
#define SZ(x) ((int)(x).size())
typedef long long ll;
typedef pair<int, int> pii;
const int N = 1003;
int n, m;
char a[N][N];
bool vis[N][N];
queue<pii> Q;
int di[] = {-1, 0, 0, 1};
int dj[] = {0, -1, 1, 0};
int main() {
std::ios_base::sync_with_stdio(false), cin.tie(... | #include <bits/stdc++.h>
using namespace std;
#define SZ(x) ((int)(x).size())
typedef long long ll;
typedef pair<int, int> pii;
const int N = 1003;
int n, m;
char a[N][N];
bool vis[N][N];
queue<pii> Q;
int di[] = {-1, 0, 0, 1};
int dj[] = {0, -1, 1, 0};
int main() {
std::ios_base::sync_with_stdio(false), cin.tie(... | [
"expression.operation.binary.add"
] | 869,099 | 869,100 | u362821344 | cpp |
p03053 | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = (a); i <= (b); i++)
#define per(i, a, b) for (int i = (a); i >= (b); i--)
#define REP(i, n) for (int i = (0); i < (n); i++)
#define fi first
#define se second
#define pb push_back
#define mp make_pair
using namespace std;
typedef pair<int, int> pii;
typedef vec... | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = (a); i <= (b); i++)
#define per(i, a, b) for (int i = (a); i >= (b); i--)
#define REP(i, n) for (int i = (0); i < (n); i++)
#define fi first
#define se second
#define pb push_back
#define mp make_pair
using namespace std;
typedef pair<int, int> pii;
typedef vec... | [
"identifier.change",
"call.arguments.change"
] | 869,107 | 869,108 | u603486542 | cpp |
p03053 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
const int INF = 1e9;
const int diff[4][2] = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};
int main(int argc, c... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
const int INF = 1e9;
const int diff[4][2] = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};
int main(int argc, c... | [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 869,113 | 869,114 | u801610392 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
int main() {
int h, w, inf = 10000, ans = 0;
char tmp;
cin >> h >> w;
vector<vector<int>> a(h + 2, vector<int>(w + 2));
for (int i = 0; i < h + 2; i++) {
a[i][0] = inf;
a[i][w + 1] = inf;
}
for (int j = 0; j < w + 2; j++) {
a[0][j] = inf;
a[h ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int h, w, inf = 10000, ans = 0;
char tmp;
cin >> h >> w;
vector<vector<int>> a(h + 2, vector<int>(w + 2));
for (int i = 0; i < h + 2; i++) {
a[i][0] = inf;
a[i][w + 1] = inf;
}
for (int j = 0; j < w + 2; j++) {
a[0][j] = inf;
a[h ... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 869,123 | 869,124 | u576357314 | cpp |
p03053 | #include <algorithm>
#include <climits>
#include <cstdio>
#include <iostream>
#include <map>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class ... | #include <algorithm>
#include <climits>
#include <cstdio>
#include <iostream>
#include <map>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class ... | [
"call.remove"
] | 869,129 | 869,130 | u784838174 | cpp |
p03053 | #include <algorithm>
#include <climits>
#include <cstdio>
#include <iostream>
#include <map>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class ... | #include <algorithm>
#include <climits>
#include <cstdio>
#include <iostream>
#include <map>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class ... | [] | 869,131 | 869,130 | u784838174 | cpp |
p03053 | #include <iostream>
struct point {
int x, y;
} p1[1000001], p2[1000001], *cur, *last;
int len1, len2;
char mp[1001][1001];
int main() {
int h, w;
std::cin >> h >> w;
cur = p2;
last = p1;
for (int i = 0; i < h; i++) {
std::cin >> mp[i];
for (int j = 0; mp[i][j] != '\0'; j++) {
if (mp[i][j] ==... | #include <iostream>
struct point {
int x, y;
} p1[1000001], p2[1000001], *cur, *last;
int len1, len2;
char mp[1001][1001];
int main() {
int h, w;
std::cin >> h >> w;
cur = p2;
last = p1;
for (int i = 0; i < h; i++) {
std::cin >> mp[i];
for (int j = 0; mp[i][j] != '\0'; j++) {
if (mp[i][j] ==... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 869,137 | 869,138 | u339554233 | cpp |
p03053 |
// vim: set fdm=marker:
// {{{
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <utility>
#include <vector>
using namespace std;
typedef long l... |
// vim: set fdm=marker:
// {{{
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <utility>
#include <vector>
using namespace std;
typedef long l... | [
"assignment.variable.change",
"variable_access.subscript.index.change"
] | 869,141 | 869,142 | u839680500 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const double PI = acos(-1);
const int inf = 2e9;
const ll INF = 2e18;
const ll MOD = 1e9 + 7;
#define sz(s) (s).size()
#define pb push_back
#define fi first
#define se second
#define REP(i, n) for (int i = 0; i < n; i... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const double PI = acos(-1);
const int inf = 2e9;
const ll INF = 2e18;
const ll MOD = 1e9 + 7;
#define sz(s) (s).size()
#define pb push_back
#define fi first
#define se second
#define REP(i, n) for (int i = 0; i < n; i... | [
"variable_declaration.type.change",
"call.arguments.change",
"call.arguments.add"
] | 869,162 | 869,163 | u511344501 | cpp |
p03053 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
constexpr long long MOD = 1000000007;
struct State {
int i, j, d;
};
... | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
constexpr long long MOD = 1000000007;
struct State {
int i, j, d;
};
... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 869,164 | 869,165 | u866733412 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define fi first
#define se second
#define pb push_back
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, l... | #include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define fi first
#define se second
#define pb push_back
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, l... | [
"expression.operation.binary.remove"
] | 869,168 | 869,169 | u829956284 | cpp |
p03050 | #include <bits/stdc++.h>
using namespace std;
#define fr(i, a, b) for (int i = (a), _b = (b); i <= _b; i++)
#define frr(i, a, b) for (int i = (a), _b = (b); i >= _b; i--)
#define rep(i, n) for (long long i = 0, _n = (n); i < _n; i++)
#define repr(i, n) for (long long i = (n)-1; i >= 0; i--)
#define foreach(it, ar) ... | #include <bits/stdc++.h>
using namespace std;
#define fr(i, a, b) for (int i = (a), _b = (b); i <= _b; i++)
#define frr(i, a, b) for (int i = (a), _b = (b); i >= _b; i--)
#define rep(i, n) for (long long i = 0, _n = (n); i < _n; i++)
#define repr(i, n) for (long long i = (n)-1; i >= 0; i--)
#define foreach(it, ar) ... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 869,176 | 869,177 | u795058347 | cpp |
p03050 | #include <algorithm>
#include <cstdio>
#include <cstring>
#define ll long long
using namespace std;
ll n, ans;
int main() {
scanf("%lld", &n);
if (n == 1) {
printf("0\n");
return 0;
}
for (ll i = 2; i * i <= n; i++) {
if (n % i)
continue;
ll d = i;
if (n / (d - 1) * d == n)
ans +... | #include <algorithm>
#include <cstdio>
#include <cstring>
#define ll long long
using namespace std;
ll n, ans;
int main() {
scanf("%lld", &n);
if (n == 1 || n == 2) {
printf("0\n");
return 0;
}
for (ll i = 2; i * i <= n; i++) {
if (n % i)
continue;
ll d = i;
if (n / (d - 1) * d == n)
... | [
"control_flow.branch.if.condition.change"
] | 869,182 | 869,183 | u656762776 | cpp |
p03050 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, n, m) for (int i = n; i < m; i++)
#define ll long long int
using namespace std;
int main() {
ll ans = 0;
ll n;
cin >> n;
REP(i, int(sqrt(n)) + 1) {
if (n % (i + 1) == 0) {
ll m = n / (i + 1);
ll l = i + 1;
... | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, n, m) for (int i = n; i < m; i++)
#define ll long long int
using namespace std;
int main() {
ll ans = 0;
ll n;
cin >> n;
REP(i, int(sqrt(n)) + 1) {
if (n % (i + 1) == 0) {
ll m = n / (i + 1);
ll l = i + 1;
... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 869,184 | 869,185 | u620059302 | cpp |
p03050 | #include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <chrono>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <s... | #include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <chrono>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <s... | [
"control_flow.loop.for.condition.change"
] | 869,186 | 869,187 | u483814783 | cpp |
p03051 | #include <bits/stdc++.h>
#define For(i, x, y) for (register int i = (x); i <= (y); i++)
#define FOR(i, x, y) for (register int i = (x); i < (y); i++)
#define Dow(i, x, y) for (register int i = (x); i >= (y); i--)
#define Debug(v) \
for (auto i : v) ... | #include <bits/stdc++.h>
#define For(i, x, y) for (register int i = (x); i <= (y); i++)
#define FOR(i, x, y) for (register int i = (x); i < (y); i++)
#define Dow(i, x, y) for (register int i = (x); i >= (y); i--)
#define Debug(v) \
for (auto i : v) ... | [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"assignment.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 869,198 | 869,199 | u026342954 | cpp |
p03051 | #include <bits/stdc++.h>
#include <omp.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef double ld;
#define int ll
#define rand shittttty_shit
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rng_64(chrono::steady_clock::now().time_since_epoch().coun... | #include <bits/stdc++.h>
#include <omp.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef double ld;
#define int ll
#define rand shittttty_shit
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rng_64(chrono::steady_clock::now().time_since_epoch().coun... | [
"assignment.value.change",
"call.arguments.change"
] | 869,200 | 869,201 | u350388631 | cpp |
p03051 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctype.h>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <unordered_map>
#include <vector>
using... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctype.h>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <unordered_map>
#include <vector>
using... | [
"literal.number.change",
"variable_declaration.value.change"
] | 869,204 | 869,203 | u277153875 | cpp |
p03051 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
typedef long long... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
typedef long long... | [] | 869,205 | 869,206 | u820262277 | cpp |
p03051 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
int N;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++)
scanf("%d", &A[i]);
vector<vector<int>> accum(1 << 20);
int now = 0;
vector<ll> zero(N + 1, 0);
for (int i = 0; i < N; i++) {
now ^= A[i];
accum[no... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
int N;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++)
scanf("%d", &A[i]);
vector<vector<int>> accum(1 << 20);
int now = 0;
vector<ll> zero(N + 1, 0);
for (int i = 0; i < N; i++) {
now ^= A[i];
accum[no... | [
"identifier.change",
"io.output.change"
] | 869,209 | 869,210 | u548834738 | cpp |
p03051 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
int N;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++)
scanf("%d", &A[i]);
vector<vector<int>> accum(1 << 20);
int now = 0;
vector<ll> zero(N + 1, 0);
for (int i = 0; i < N; i++) {
now ^= A[i];
accum[no... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
int N;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++)
scanf("%d", &A[i]);
vector<vector<int>> accum(1 << 20);
int now = 0;
vector<ll> zero(N + 1, 0);
for (int i = 0; i < N; i++) {
now ^= A[i];
accum[no... | [
"identifier.change",
"io.output.change"
] | 869,211 | 869,210 | u548834738 | cpp |
p03051 | #pragma GCC optimize("O3")
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <chrono>
#include <cmath>
#include <complex>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>... | #pragma GCC optimize("O3")
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <chrono>
#include <cmath>
#include <complex>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>... | [] | 869,228 | 869,229 | u495699318 | cpp |
p03051 | #include <bits/stdc++.h>
#define WHOLE(v) (v).begin(), (v).end()
#define REV_WHOLE(v) (v).rbegin(), (v).rend()
using i64 = int64_t;
using namespace std;
template <size_t I, class H, class... T> struct TupleReaderWriter {
static tuple<H, T...> r(istream &i) {
H v;
i >> v;
return tuple_cat(tuple<H>(v),
... | #include <bits/stdc++.h>
#define WHOLE(v) (v).begin(), (v).end()
#define REV_WHOLE(v) (v).rbegin(), (v).rend()
using i64 = int64_t;
using namespace std;
template <size_t I, class H, class... T> struct TupleReaderWriter {
static tuple<H, T...> r(istream &i) {
H v;
i >> v;
return tuple_cat(tuple<H>(v),
... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 869,233 | 869,234 | u936555566 | cpp |
p03051 | #include <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;
int modPow(int a, int p) {
if (p == 0)
return 1;
long long half = modPow(a, p / 2);
long long res = (half * half) % MOD;
if (p % 2)
res = (res * a) % MOD;
return res;
}
int main() {
int N;
while (cin >> N) {... | #include <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;
int modPow(int a, int p) {
if (p == 0)
return 1;
long long half = modPow(a, p / 2);
long long res = (half * half) % MOD;
if (p % 2)
res = (res * a) % MOD;
return res;
}
int main() {
int N;
while (cin >> N) {... | [
"assignment.value.change",
"identifier.change"
] | 869,240 | 869,241 | u002023395 | cpp |
p03051 | #include <bits/stdc++.h>
using namespace std;
using LL = long long;
template <typename T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
// std::vector Declaration
t... | #include <bits/stdc++.h>
using namespace std;
using LL = long long;
template <typename T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
// std::vector Declaration
t... | [
"literal.number.change",
"expression.operation.binary.change"
] | 869,248 | 869,249 | u960524878 | cpp |
p03053 | #include <algorithm>
#include <cstdio>
#include <queue>
#include <utility>
using namespace std;
const int INF = 100000000;
int main() {
typedef pair<int, int> P;
int H, W, i, j, n = 0;
scanf("%d%d", &H, &W);
queue<P> que;
char A[1000][1000];
int d[1000][1000];
for (i = 0; i < H; i++)
for (j = 0; ... | #include <algorithm>
#include <cstdio>
#include <queue>
#include <utility>
using namespace std;
const int INF = 100000000;
int main() {
typedef pair<int, int> P;
int H, W, i, j, n = 0;
scanf("%d%d", &H, &W);
queue<P> que;
char A[1000][1000];
int d[1000][1000];
for (i = 0; i < H; i++)
for (j = 0; ... | [
"call.arguments.change",
"call.arguments.add",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 869,262 | 869,263 | u203033720 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
int H, W;
string s[1024];
int di[4] = {1, 0, -1, 0};
int dj[4] = {0, -1, 0, 1};
int main() {
cin >> H >> W;
for (int i = 1; i <= H; i++) {
cin >> s[i];
s[i] = "#" + s[i] + "#";
}
for (int j = 0; j < W + 2; j++) {
s[0] += '*';
s[H + 1] += '*';
}
... | #include <bits/stdc++.h>
using namespace std;
int H, W;
string s[1024];
int di[4] = {1, 0, -1, 0};
int dj[4] = {0, -1, 0, 1};
int main() {
cin >> H >> W;
for (int i = 1; i <= H; i++) {
cin >> s[i];
s[i] = "*" + s[i] + "*";
}
for (int j = 0; j < W + 2; j++) {
s[0] += '*';
s[H + 1] += '*';
}
... | [
"literal.string.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 869,264 | 869,265 | u628262476 | cpp |
p03053 | // Darker and Darker
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
struct Point {
int x;
int y;
int number;
};
int H, W;
int move(int met[1000][1000], Point p, queue<Point> &q, int x1, int y1,
int count) {
int x2 = x1 + p.x;
int y... | // Darker and Darker
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
struct Point {
int x;
int y;
int number;
};
int H, W;
int move(int met[1000][1000], Point p, queue<Point> &q, int x1, int y1,
int count) {
int x2 = x1 + p.x;
int y... | [
"assignment.value.change",
"identifier.change"
] | 869,268 | 869,269 | u362209280 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 5;
const int dx[] = {-1, 0, 1, 0}, dy[] = {0, -1, 0, 1};
char a[maxn][maxn];
int v[maxn][maxn];
int n, m;
int ans;
struct Node {
int x;
int y;
int d;
};
queue<Node> q;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
scan... | #include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 5;
const int dx[] = {-1, 0, 1, 0}, dy[] = {0, -1, 0, 1};
char a[maxn][maxn];
int v[maxn][maxn];
int n, m;
int ans;
struct Node {
int x;
int y;
int d;
};
queue<Node> q;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
scan... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 869,274 | 869,275 | u174678554 | cpp |
p03053 | #include <bits/stdc++.h>
#define REP(i, n) for (long i = 0; i < (n); i++)
#define FOR(i, a, b) for (long i = (a); i < (b); i++)
#define dump(x) cerr << #x << " => " << (x) << endl
#define MIN(vec) *min_element(vec.begin(), vec.end())
#define MAX(vec) *max_element(vec.begin(), vec.end())
#define UNIQ(vec) ... | #include <bits/stdc++.h>
#define REP(i, n) for (long i = 0; i < (n); i++)
#define FOR(i, a, b) for (long i = (a); i < (b); i++)
#define dump(x) cerr << #x << " => " << (x) << endl
#define MIN(vec) *min_element(vec.begin(), vec.end())
#define MAX(vec) *max_element(vec.begin(), vec.end())
#define UNIQ(vec) ... | [] | 869,290 | 869,291 | u925364229 | cpp |
p03053 | #include <bits/stdc++.h>
#define int long long
#define ld long double
#define endl "\n"
#define fastio \
ios_base::sync_with_stdio(0); \
cin.tie(0); ... | #include <bits/stdc++.h>
#define int long long
#define ld long double
#define endl "\n"
#define fastio \
ios_base::sync_with_stdio(0); \
cin.tie(0); ... | [
"identifier.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 869,294 | 869,295 | u179760090 | cpp |
p03053 | #include <iostream>
#include <queue>
#include <string.h>
using namespace std;
int dx[8] = {-1, 1, 0, 0, 1, -1, 1, -1};
int dy[8] = {0, 0, -1, 1, 1, -1, -1, 1};
int score[1010][1010];
queue<pair<int, int>> que;
int h, w;
void bfs() {
while (que.empty() != true) {
pair<int, int> temp = que.front();
que.pop();
... | #include <iostream>
#include <queue>
#include <string.h>
using namespace std;
int dx[8] = {-1, 1, 0, 0, 1, -1, 1, -1};
int dy[8] = {0, 0, -1, 1, 1, -1, -1, 1};
int score[1010][1010];
queue<pair<int, int>> que;
int h, w;
void bfs() {
while (que.empty() != true) {
pair<int, int> temp = que.front();
que.pop();
... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 869,306 | 869,307 | u271153916 | cpp |
p03053 | #include <iostream>
#include <queue>
#include <string.h>
using namespace std;
int dx[8] = {-1, 1, 0, 0, 1, -1, 1, -1};
int dy[8] = {0, 0, -1, 1, 1, -1, -1, 1};
int score[1001][1001];
queue<pair<int, int>> que;
int h, w;
void bfs() {
while (que.empty() != true) {
pair<int, int> temp = que.front();
que.pop();
... | #include <iostream>
#include <queue>
#include <string.h>
using namespace std;
int dx[8] = {-1, 1, 0, 0, 1, -1, 1, -1};
int dy[8] = {0, 0, -1, 1, 1, -1, -1, 1};
int score[1010][1010];
queue<pair<int, int>> que;
int h, w;
void bfs() {
while (que.empty() != true) {
pair<int, int> temp = que.front();
que.pop();
... | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"identifier.change",
"control_flow.branch.if.condition.change"
] | 869,308 | 869,307 | u271153916 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
#define P pair<int, int>
int main() {
queue<P> que;
int H, W;
long long INF = 1000000000, x, y;
cin >> H >> W;
char a[H][W];
int S[H][W], dx[] = {0, 0, 1, -1}, dy[] = {1, -1, 0, 0};
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
cin >> ... | #include <bits/stdc++.h>
using namespace std;
#define P pair<int, int>
int main() {
queue<P> que;
int H, W;
long long INF = 1000000000, x, y;
cin >> H >> W;
char a[H][W];
int S[H][W], dx[] = {0, 0, 1, -1}, dy[] = {1, -1, 0, 0};
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
cin >> ... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 869,313 | 869,314 | u441250130 | cpp |
p03053 | #include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
int main() {
int H, W;
vector<string> A;
vector<vector<int>> d;
cin >> H >> W;
for (int i = 0; i < H; i++) {
string tmp;
cin >> tmp;
A.push_back(tmp);
}
for (int i = 0; i < H; i++)
d.push_back... | #include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
int main() {
int H, W;
vector<string> A;
vector<vector<int>> d;
cin >> H >> W;
for (int i = 0; i < H; i++) {
string tmp;
cin >> tmp;
A.push_back(tmp);
}
for (int i = 0; i < H; i++)
d.push_back... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 869,317 | 869,318 | u090436701 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
namespace io {
const int l = 1 << 19;
char *s, *t, buf[l], c;
char gc() {
if (s == t) {
t = (s = buf) + fread(buf, 1, l, stdin);
return s == t ? EOF : *s++;
}
return *s++;
}
template <class IT> void gi(IT &x) {
x = 0;
c = gc();
while... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
namespace io {
const int l = 1 << 19;
char *s, *t, buf[l], c;
char gc() {
if (s == t) {
t = (s = buf) + fread(buf, 1, l, stdin);
return s == t ? EOF : *s++;
}
return *s++;
}
template <class IT> void gi(IT &x) {
x = 0;
c = gc();
while... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 869,319 | 869,320 | u108493359 | cpp |
p03053 | #include <array>
#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <utility>
using namespace std;
int main() {
/*
int W, H;
cin >> W >> H;
vector<array<int, 1000>> arr(H);
int MAX = 0;
for(int y = 0; y < H; y++){
for(int x = 0; x < W; x++){
char buf;
... | #include <array>
#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <utility>
using namespace std;
int main() {
int W, H;
cin >> H >> W;
char buf;
queue<pair<int, int>> que;
vector<array<int, 1000>> arr(H);
int MAX = 0;
for (int y = 0; y < H; y++) {
for (int x = 0;... | [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 869,325 | 869,324 | u331948661 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pi;
#define INF 1LL << 60
#define MOD 1000000007;
#define pb push_back
#define REP(i, n) for (int i = 0; i < (n); i++)
#define REPR(i, b, e) for (int i = (b); i <= (e); i++)
#define DEBUG(x) cout << #x << ": " << (x) << endl
#d... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pi;
#define INF 1LL << 60
#define MOD 1000000007;
#define pb push_back
#define REP(i, n) for (int i = 0; i < (n); i++)
#define REPR(i, b, e) for (int i = (b); i <= (e); i++)
#define DEBUG(x) cout << #x << ": " << (x) << endl
#d... | [
"identifier.change",
"call.arguments.change",
"assignment.variable.change"
] | 869,336 | 869,337 | u703272444 | cpp |
p03053 | //
// main.cpp
// Atcoder
//
#include <algorithm>
#include <cstdio>
#include <queue>
using namespace std;
int H, W;
const int maxn = 1000 + 10;
char A[maxn][maxn];
struct Node {
int i, j, level;
};
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
bool check(int x, int y) { return x > 0 && x <= H && y > 0 && y... | //
// main.cpp
// Atcoder
//
#include <algorithm>
#include <cstdio>
#include <queue>
using namespace std;
int H, W;
const int maxn = 1000 + 10;
char A[maxn][maxn];
struct Node {
int i, j, level;
};
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
bool check(int x, int y) { return x > 0 && x <= H && y > 0 && y... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 869,372 | 869,373 | u797983470 | cpp |
p03053 | #include <bits/stdc++.h>
#define ft first
#define sc second
#define lb lower_bound
#define ub upper_bound
#define pb push_back
#define pt(sth) cout << sth << "\n"
#define chmax(a, b) \
{ ... | #include <bits/stdc++.h>
#define ft first
#define sc second
#define lb lower_bound
#define ub upper_bound
#define pb push_back
#define pt(sth) cout << sth << "\n"
#define chmax(a, b) \
{ ... | [
"variable_declaration.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 869,374 | 869,375 | u768152935 | cpp |
p03053 | #define _USE_MATH_DEFINES
#include <bits/stdc++.h> //////////////////////////////////////////
#define deb(...) /////////////////////////////////////////////////
#define DBP(...) /////////////////////////////////////////////////
#ifdef LOC ///////////////////////////////////////////////////... | #define _USE_MATH_DEFINES
#include <bits/stdc++.h> //////////////////////////////////////////
#define deb(...) /////////////////////////////////////////////////
#define DBP(...) /////////////////////////////////////////////////
#ifdef LOC ///////////////////////////////////////////////////... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 869,503 | 869,504 | u018915813 | cpp |
p03054 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define PI 3.14159265359
#define INF 1000100100 // 000000000
#define MOD 1000000007
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define P pair<int, int>
#define PP pair<P, P>
#define T tuple<int, int, int> // tuple<ll,ll,ll>
#define ... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define PI 3.14159265359
#define INF 1000100100 // 000000000
#define MOD 1000000007
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define P pair<int, int>
#define PP pair<P, P>
#define T tuple<int, int, int> // tuple<ll,ll,ll>
#define ... | [
"assignment.value.change",
"identifier.change",
"call.arguments.change"
] | 869,513 | 869,514 | u437779154 | cpp |
p03054 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define PI 3.14159265359
#define INF 1000100100 // 000000000
#define MOD 1000000007
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define P pair<int, int>
#define PP pair<P, P>
#define T tuple<int, int, int> // tuple<ll,ll,ll>
#define ... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define PI 3.14159265359
#define INF 1000100100 // 000000000
#define MOD 1000000007
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define P pair<int, int>
#define PP pair<P, P>
#define T tuple<int, int, int> // tuple<ll,ll,ll>
#define ... | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"assignment.change"
] | 869,515 | 869,514 | u437779154 | cpp |
p03054 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
// const ll mod = ... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
// const ll mod = ... | [
"control_flow.branch.if.condition.change"
] | 869,521 | 869,522 | u702582248 | cpp |
p03054 | #include <bits/stdc++.h>
#define pb push_back
#define pll pair<ll, ll>
#define mp make_pair
#define pyshnapyshnakaa \
ios_base ::sync_with_stdio(0); \
cin.tie(0); ... | #include <bits/stdc++.h>
#define pb push_back
#define pll pair<ll, ll>
#define mp make_pair
#define pyshnapyshnakaa \
ios_base ::sync_with_stdio(0); \
cin.tie(0); ... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 869,528 | 869,529 | u051270344 | cpp |
p03054 | //
// main.cpp
// test130
//
// Created by on 2019/06/16.
// Copyright © 2 All rights reserved.
//
//
// main.cpp
// new
//
// Created on 2019/06/09.
// Copyright All rights reserved.
//
// C++ includes used for precompiling -*- C++ -*-
// Copyright (C) 2003-2013 Free Software Foundation, Inc.
//
// This fi... | //
// main.cpp
// test130
//
// Created by on 2019/06/16.
// Copyright © 2 All rights reserved.
//
//
// main.cpp
// new
//
// Created on 2019/06/09.
// Copyright All rights reserved.
//
// C++ includes used for precompiling -*- C++ -*-
// Copyright (C) 2003-2013 Free Software Foundation, Inc.
//
// This fi... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 869,537 | 869,538 | u943070796 | cpp |
p03054 | #include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
int main(void) {
ios::sync_with_stdio(false);
int H, W, N;
cin >> H >> W >> N;
int r, c;
cin >> r >> c;
string S, T;
cin >> S >> T;
int left = 1;
int right = W;
int up = 1;
int down = H;
... | #include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
int main(void) {
ios::sync_with_stdio(false);
int H, W, N;
cin >> H >> W >> N;
int r, c;
cin >> r >> c;
string S, T;
cin >> S >> T;
int left = 1;
int right = W;
int up = 1;
int down = H;
... | [
"misc.opposites",
"control_flow.branch.if.condition.change"
] | 869,541 | 869,542 | u004707990 | cpp |
p03054 | // Author:xht37
#include <bits/stdc++.h>
#define ui unsigned int
#define ll long long
#define ul unsigned ll
#define ld long double
#define pi pair<int, int>
#define fi first
#define se second
#define mp make_pair
#define ls (p << 1)
#define rs (ls | 1)
#define md ((t[p].l + t[p].r) >> 1)
#define vi vector<int>
#de... | // Author:xht37
#include <bits/stdc++.h>
#define ui unsigned int
#define ll long long
#define ul unsigned ll
#define ld long double
#define pi pair<int, int>
#define fi first
#define se second
#define mp make_pair
#define ls (p << 1)
#define rs (ls | 1)
#define md ((t[p].l + t[p].r) >> 1)
#define vi vector<int>
#de... | [
"literal.string.change",
"literal.string.case.change",
"call.arguments.change",
"function.return_value.change",
"io.output.change"
] | 869,543 | 869,544 | u185303454 | cpp |
p03054 | #include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
using namespace std;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
#define REP(i, l, n) for (int i = (l), i##_len = (n); i < i##_len; ++i)
#define ALL(x) (x).begin(), (x).end()
#define pb push_back
ll gcd(ll a, ll b) { return b ? gcd(b, a... | #include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
using namespace std;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
#define REP(i, l, n) for (int i = (l), i##_len = (n); i < i##_len; ++i)
#define ALL(x) (x).begin(), (x).end()
#define pb push_back
ll gcd(ll a, ll b) { return b ? gcd(b, a... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 869,545 | 869,546 | u639426108 | cpp |
p03054 | #include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
using namespace std;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
#define REP(i, l, n) for (int i = (l), i##_len = (n); i < i##_len; ++i)
#define ALL(x) (x).begin(), (x).end()
#define pb push_back
ll gcd(ll a, ll b) { return b ? gcd(b, a... | #include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
using namespace std;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
#define REP(i, l, n) for (int i = (l), i##_len = (n); i < i##_len; ++i)
#define ALL(x) (x).begin(), (x).end()
#define pb push_back
ll gcd(ll a, ll b) { return b ? gcd(b, a... | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"control_flow.branch.if.condition.change"
] | 869,547 | 869,546 | u639426108 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.