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 |
|---|---|---|---|---|---|---|---|
p02927 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string.h>
using namespace std;
#define MAX 9
int main(void) {
int M, D, answer = 0, i, j;
cin >> M >> D;
for (i = 2; i < D / 10; i++) {
for (j = 2; j <= MAX; j++) {
if (i * j <= M) {
answer++;
} else {
break;
... | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string.h>
using namespace std;
#define MAX 9
int main(void) {
int M, D, answer = 0, i, j;
cin >> M >> D;
for (i = 2; i < D / 10; i++) {
for (j = 2; j <= MAX; j++) {
if (i * j <= M) {
answer++;
} else {
break;
... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 730,108 | 730,109 | u499078067 | cpp |
p02927 | #include <iostream>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
int cnt = 0;
for (int im = 1; im <= M; ++im) {
for (int id = 1; id <= D; ++id) {
int d10 = id / 10;
int d1 = id % 10;
if (d1 < 1) {
continue;
}
if (d10 < 1) {
continue;
}
... | #include <iostream>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
int cnt = 0;
for (int im = 4; im <= M; ++im) {
for (int id = 22; id <= D; ++id) {
int d10 = id / 10;
int d1 = id % 10;
if (d1 < 2) {
continue;
}
if (d10 < 2) {
continue;
}
... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"control_flow.branch.if.condition.change"
] | 730,110 | 730,111 | u160952711 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
#define DEBUG 0
#define nl '\n'
#if DEBUG
#define trace(var) \
{ cerr << "Line " << __LINE__ << ": " << #var << "=" << var << nl; }
#else
#define trace(var) ... | #include <bits/stdc++.h>
using namespace std;
#define DEBUG 0
#define nl '\n'
#if DEBUG
#define trace(var) \
{ cerr << "Line " << __LINE__ << ": " << #var << "=" << var << nl; }
#else
#define trace(var) ... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 730,112 | 730,113 | u899116900 | cpp |
p02927 | #include <iostream>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
int ans = 0;
int d_1, d_10;
for (int i = 4; i <= M; i++) {
for (int d_ini = 22; d_ini <= D; d_ini++) {
d_10 = d_ini / 10;
d_1 = d_ini % 10;
if (d_1 * d_10 == i)
ans++;
}
}
cout << ans <<... | #include <iostream>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
int ans = 0;
int d_1, d_10;
for (int i = 4; i <= M; i++) {
for (int d_ini = 22; d_ini <= D; d_ini++) {
d_10 = d_ini / 10;
d_1 = d_ini % 10;
if (d_1 * d_10 == i && d_1 > 1)
ans++;
}
}
cou... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 730,124 | 730,125 | u609182361 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
signed main() {
int M;
int D1;
int D2;
int count = 0;
cin >> M >> D1;
D2 = D1 % 10;
D1 = D1 / 10;
if (M <= 3) {
cout << "0"
<< "\n";
}
for (int i = 2; i <= M; i++) {
for (int j = 2; j <= D1; j++) {
if (D1 != j) {
for (int k... | #include <bits/stdc++.h>
using namespace std;
signed main() {
int M;
int D1;
int D2;
int count = 0;
cin >> M >> D1;
D2 = D1 % 10;
D1 = D1 / 10;
if (M <= 3) {
cout << "0"
<< "\n";
} else {
for (int i = 4; i <= M; i++) {
for (int j = 2; j <= D1; j++) {
if (D1 != j) {
... | [
"control_flow.branch.else.add",
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change"
] | 730,126 | 730,127 | u111405656 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, d;
long long count = 0;
cin >> m >> d;
int o = d / 10;
int s = d % 10;
for (int i = 1; i <= m; i++) {
int s = 0;
for (int j = 2; j <= o; j++) {
if (i % j == 0 && i / j < 10 && i / j >= 2) {
count++;
if (j == o &&... | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, d;
long long count = 0;
cin >> m >> d;
int o = d / 10;
int s = d % 10;
for (int i = 1; i <= m; i++) {
for (int j = 2; j <= o; j++) {
if (i % j == 0 && i / j < 10 && i / j >= 2) {
count++;
if (j == o && i / j > s)
... | [
"variable_declaration.remove"
] | 730,130 | 730,131 | u161616073 | cpp |
p02927 | #include <algorithm>
#include <array>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#de... | #include <algorithm>
#include <array>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#de... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 730,136 | 730,137 | u643747754 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, d, count = 0;
cin >> m >> d;
for (int i = 4; i <= m; i++) {
for (int j = 22; j < d; j++) {
int d1 = j % 10;
int d10 = j / 10;
if (d1 < 2) {
continue;
}
if (d1 * d10 == i) {
count++;
}
}
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, d, count = 0;
cin >> m >> d;
for (int i = 4; i <= m; i++) {
for (int j = 22; j <= d; j++) {
int d1 = j % 10;
int d10 = j / 10;
if (d1 < 2) {
continue;
}
if (d1 * d10 == i) {
count++;
}
}
... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 730,138 | 730,139 | u203527087 | cpp |
p02927 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (ll(i) = 0; (i) < (n); (i)++)
#define repf(i, m, n) for (ll(i) = m; (i) < n; (i)++)
#define all(v... | #include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (ll(i) = 0; (i) < (n); (i)++)
#define repf(i, m, n) for (ll(i) = m; (i) < n; (i)++)
#define all(v... | [
"expression.operation.binary.add"
] | 730,142 | 730,143 | u190234543 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main(void) {
ll m, d;
cin >> m >> d;
ll cnt = 0;
for (int i = 0; i < d; i++) {
ll a = i % 10, b = i / 10;
if (a >= 2 && b >= 2 && a * b <= m)
cnt++;
}
cout << cnt << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main(void) {
ll m, d;
cin >> m >> d;
ll cnt = 0;
for (int i = 1; i <= d; i++) {
ll a = i % 10, b = i / 10;
if (a >= 2 && b >= 2 && a * b <= m)
cnt++;
}
cout << cnt << endl;
return 0;
} | [
"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"
] | 730,154 | 730,155 | u030848580 | cpp |
p02927 |
// include
//------------------------------------------
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
... |
// include
//------------------------------------------
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 730,158 | 730,159 | u874996917 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define LLINF 9223372036854775807
#define MOD ll(1e9 + 7)
#define all(x) (x).begin(), (x).end()
#define dbg(x) cerr << #x << ": " << x << endl
int main() {
int m, d;
cin >> m >> d;
int ans =... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define LLINF 9223372036854775807
#define MOD ll(1e9 + 7)
#define all(x) (x).begin(), (x).end()
#define dbg(x) cerr << #x << ": " << x << endl
int main() {
int m, d;
cin >> m >> d;
int ans =... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 730,162 | 730,163 | u677421794 | cpp |
p02927 | #include <iostream>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
int maxD10 = D / 10;
int ans = 0;
for (int d10 = 2; d10 <= maxD10; ++d10) {
int maxD1 = D - d10 * 10;
for (int d1 = 2; d1 < 9 && d1 <= maxD1; ++d1) {
if (d1 * d10 <= M) {
++ans;
}
}
}
cout <<... | #include <iostream>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
int maxD10 = D / 10;
int ans = 0;
for (int d10 = 2; d10 <= maxD10; ++d10) {
int maxD1 = D - d10 * 10;
for (int d1 = 2; d1 <= 9 && d1 <= maxD1; ++d1) {
if (d1 * d10 <= M) {
++ans;
}
}
}
cout <... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 730,164 | 730,165 | u851470173 | cpp |
p02927 | #include <algorithm>
#include <climits>
#include <cmath>
#include <csignal>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using ll = long long;
using namespace std;
int main() {
int m = 0, d = 0;
cin >> m >> d;
int cnt = 0;
for... | #include <algorithm>
#include <climits>
#include <cmath>
#include <csignal>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using ll = long long;
using namespace std;
int main() {
int m = 0, d = 0;
cin >> m >> d;
int cnt = 0;
for... | [
"expression.operation.binary.change"
] | 730,170 | 730,171 | u324549724 | cpp |
p02927 | //↓template↓
#include "bits/stdc++.h"
using namespace std;
#define Would
#define you
#define all(n) n.begin(), n.end()
#define rall(n) n.rbegin(), n.rend()
typedef long long ll;
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
const double EPS = 1e-10;
const double pi = acos(-1); // 3.1415926535897932384626433832795028...... | //↓template↓
#include "bits/stdc++.h"
using namespace std;
#define Would
#define you
#define all(n) n.begin(), n.end()
#define rall(n) n.rbegin(), n.rend()
typedef long long ll;
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
const double EPS = 1e-10;
const double pi = acos(-1); // 3.1415926535897932384626433832795028...... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 730,172 | 730,173 | u539402331 | cpp |
p02927 | #include <algorithm>
#include <iostream>
#include <map>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (int i = 0; i <= int(n); i++)
typedef long long ll;
using namespace std;
int main() {
int M, D;
cin >> M >> D;
int ans = 0;
for (int x = 2; x <= 9; x++) {
for (int y = 2; y <= ... | #include <algorithm>
#include <iostream>
#include <map>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (int i = 0; i <= int(n); i++)
typedef long long ll;
using namespace std;
int main() {
int M, D;
cin >> M >> D;
int ans = 0;
for (int x = 2; x <= 9; x++) {
for (int y = 2; y <= ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 730,174 | 730,175 | u539675863 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
using ll = long long int;
const int MAX = (int)(1e5 + 5);
const ll INF = (ll)(1e10 + 5);
int m, d;
int ans;
int main(void) {
// Here your code !
scanf("%d %d", &m, &d);
ans = 0;
for (int i = 1; i <= m; ++i) {
for (int j = 1; j <= d; ++j) {
int d1 = ... | #include <bits/stdc++.h>
using namespace std;
using ll = long long int;
const int MAX = (int)(1e5 + 5);
const ll INF = (ll)(1e10 + 5);
int m, d;
int ans;
int main(void) {
// Here your code !
scanf("%d %d", &m, &d);
ans = 0;
for (int i = 1; i <= m; ++i) {
for (int j = 1; j <= d; ++j) {
int d1 = ... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 730,176 | 730,177 | u497422208 | cpp |
p02927 | #include <algorithm>
#include <cstdio>
using namespace std;
#define N 105
#define ll long long
int M, D, ans;
inline int rd() {
int f = 1, x = 0;
char c = getchar();
while (c < '0' || '9' < c) {
if (c == '-')
f = -1;
c = getchar();
}
while ('0' <= c && c <= '9')
x = (x << 3) + (x << 1) + (c ... | #include <algorithm>
#include <cstdio>
using namespace std;
#define N 105
#define ll long long
int M, D, ans;
inline int rd() {
int f = 1, x = 0;
char c = getchar();
while (c < '0' || '9' < c) {
if (c == '-')
f = -1;
c = getchar();
}
while ('0' <= c && c <= '9')
x = (x << 3) + (x << 1) + (c ... | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 730,178 | 730,179 | u158378528 | cpp |
p02927 | #include <iostream>
using namespace std;
int main() {
int m, d;
cin >> m >> d;
int ans = 0;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= d; j++) {
int d1, d2;
d1 = d / 10;
d2 = d % 10;
if (d1 > 1 && d2 > 1) {
if (d1 * d2 == i)
ans++;
}
}
}
cout ... | #include <iostream>
using namespace std;
int main() {
int m, d;
cin >> m >> d;
int ans = 0;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= d; j++) {
int d1, d2;
d1 = j / 10;
d2 = j % 10;
if (d1 > 1 && d2 > 1) {
if (d1 * d2 == i)
ans++;
}
}
}
cout ... | [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 730,180 | 730,181 | u313043608 | cpp |
p02927 | #include <iostream>
using namespace std;
int main() {
int m, d;
cin >> m >> d;
int ans = 0;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= d; j++) {
int d1, d2;
d1 = d / 10;
d2 = d % 10;
if (d1 > 1 && d2 > 1) {
if (d1 * d2 == m)
ans++;
}
}
}
cout ... | #include <iostream>
using namespace std;
int main() {
int m, d;
cin >> m >> d;
int ans = 0;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= d; j++) {
int d1, d2;
d1 = j / 10;
d2 = j % 10;
if (d1 > 1 && d2 > 1) {
if (d1 * d2 == i)
ans++;
}
}
}
cout ... | [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change"
] | 730,182 | 730,181 | u313043608 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, d;
cin >> m >> d;
int cnt = 0;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= d; j++) {
int d1 = j % 10, d2 = j / 10;
if (d1 >= 2 && d2 >= 2 && d1 * d2 == m)
cnt++;
}
}
cout << cnt << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, d;
cin >> m >> d;
int cnt = 0;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= d; j++) {
int d1 = j % 10, d2 = j / 10;
if (d1 >= 2 && d2 >= 2 && d1 * d2 == i)
cnt++;
}
}
cout << cnt << endl;
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 730,187 | 730,188 | u218759384 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, d;
cin >> m >> d;
int cnt = 0;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= d; j++) {
int d1 = d % 10, d2 = d / 10;
if (d1 >= 2 && d2 >= 2 && d1 * d2 == m)
cnt++;
}
}
cout << cnt << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, d;
cin >> m >> d;
int cnt = 0;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= d; j++) {
int d1 = j % 10, d2 = j / 10;
if (d1 >= 2 && d2 >= 2 && d1 * d2 == i)
cnt++;
}
}
cout << cnt << endl;
} | [
"identifier.change",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change"
] | 730,189 | 730,188 | u218759384 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
int m, d;
int main() {
scanf("%d%d", &m, &d);
int res = 0;
for (int d1 = 2; d1 <= 100; ++d1)
for (int d2 = 2; d2 <= 100; ++d2)
if (d1 * d2 <= m && d1 + d2 * 10 <= d)
++res;
printf("%d\n", res);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int m, d;
int main() {
scanf("%d%d", &m, &d);
int res = 0;
for (int d1 = 2; d1 <= 9; ++d1)
for (int d2 = 2; d2 <= 9; ++d2)
if (d1 * d2 <= m && d1 + d2 * 10 <= d)
++res;
printf("%d\n", res);
return 0;
}
| [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 730,201 | 730,202 | u075739430 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, cnt = 0, ones, tens;
cin >> a >> b;
for (int j = 22; j < b; j++) {
ones = j % 10;
int c = j;
c = c / 10;
tens = c % 10;
if (ones * tens <= a && ones * tens != 0 && ones >= 2) {
cnt++;
}
}
cout << cnt;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, cnt = 0, ones, tens;
cin >> a >> b;
for (int j = 22; j <= b; j++) {
ones = j % 10;
int c = j;
c = c / 10;
tens = c % 10;
if (ones * tens <= a && ones * tens != 0 && ones >= 2) {
cnt++;
}
}
cout << cnt;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 730,205 | 730,206 | u692691097 | cpp |
p02927 | #include <bits/stdc++.h>
#include <chrono>
#define watch(x) cout << (#x) << " is " << (x) << endl
#define eps 1e-9
typedef long long ll;
using namespace std;
const ll inf = 1e18;
const int mod = 1e9 + 7;
const int N = 1e5 + 5;
// int a[N];
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.ti... | #include <bits/stdc++.h>
#include <chrono>
#define watch(x) cout << (#x) << " is " << (x) << endl
#define eps 1e-9
typedef long long ll;
using namespace std;
const ll inf = 1e18;
const int mod = 1e9 + 7;
const int N = 1e5 + 5;
// int a[N];
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.ti... | [
"control_flow.loop.for.condition.change"
] | 730,210 | 730,211 | u409343817 | cpp |
p02927 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#inc... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#inc... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 730,212 | 730,213 | u313994303 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int M, D;
cin >> M >> D;
int ans = 0;
for (int m = 1; m <= M; m++) {
for (int t = 2; t <= 9; t++) {
if (m % t)
continue;
auto o = m / t;
if (o < 2)
continue;
... | #include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int M, D;
cin >> M >> D;
int ans = 0;
for (int m = 1; m <= M; m++) {
for (int t = 2; t <= 9; t++) {
if (m % t)
continue;
auto o = m / t;
if (o < 2 or o > 9)
cont... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 730,227 | 730,228 | u500092662 | cpp |
p02927 | ///**Bismillahir Rahmanir Rahim.**
#include <bits/stdc++.h>
#define clr(a, v) memset(a, v, sizeof a)
#define all(v) v.begin(), v.end()
#define ast(v) sort(v.begin(), v.end())
#define dst(v) sort(v.begin(), v.end(), greater<int>())
#define fast \
ios_b... | ///**Bismillahir Rahmanir Rahim.**
#include <bits/stdc++.h>
#define clr(a, v) memset(a, v, sizeof a)
#define all(v) v.begin(), v.end()
#define ast(v) sort(v.begin(), v.end())
#define dst(v) sort(v.begin(), v.end(), greater<int>())
#define fast \
ios_b... | [
"identifier.change",
"control_flow.loop.condition.change"
] | 730,229 | 730,230 | u912245812 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
int m, d, d1, d10, ans;
int main() {
cin >> m >> d;
for (int i = 1; i <= m; i++) {
for (int j = 10; j < d; j++) {
d1 = j % 10;
d10 = j / 10;
if (d1 * d10 == i && d1 >= 2 && d10 >= 2)
ans++;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int m, d, d1, d10, ans;
int main() {
cin >> m >> d;
for (int i = 1; i <= m; i++) {
for (int j = 10; j <= d; j++) {
d1 = j % 10;
d10 = j / 10;
if (d1 * d10 == i && d1 >= 2 && d10 >= 2)
ans++;
}
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 730,241 | 730,242 | u576357314 | cpp |
p02927 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int m, d;
cin >> m >> d;
if (d < 22) {
cout << "0" << endl;
return 0;
}
int ans = 0;
int d1 = d % 10;
int d10 = d / 10;
for (int k = 1; k <= m; k++) {
for (int i = 2; i < d10;... | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int m, d;
cin >> m >> d;
if (d < 22) {
cout << "0" << endl;
return 0;
}
int ans = 0;
int d1 = d % 10;
int d10 = d / 10;
for (int k = 1; k <= m; k++) {
for (int i = 2; i < d10;... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 730,247 | 730,248 | u442057402 | cpp |
p02927 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int m, d;
cin >> m >> d;
if (d < 22) {
cout << "0" << endl;
return 0;
}
int ans = 0;
int d1 = d % 10;
int d10 = d / 10;
for (int k = 1; k <= m; k++) {
for (int i = 2; i < d10;... | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int m, d;
cin >> m >> d;
if (d < 22) {
cout << "0" << endl;
return 0;
}
int ans = 0;
int d1 = d % 10;
int d10 = d / 10;
for (int k = 1; k <= m; k++) {
for (int i = 2; i < d10;... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"identifier.change"
] | 730,249 | 730,248 | u442057402 | cpp |
p02927 | #include <bits/stdc++.h>
#define reg register
using namespace std;
typedef long long ll;
const int maxn = 100005;
inline ll read() {
reg ll s = 0, t = 0;
reg char ch = getchar();
while (!isdigit(ch))
t |= ch == '-', ch = getchar();
while (isdigit(ch))
s = (s << 1) + (s << 3) + (ch ^ 48), ch = getchar... | #include <bits/stdc++.h>
#define reg register
using namespace std;
typedef long long ll;
const int maxn = 100005;
inline ll read() {
reg ll s = 0, t = 0;
reg char ch = getchar();
while (!isdigit(ch))
t |= ch == '-', ch = getchar();
while (isdigit(ch))
s = (s << 1) + (s << 3) + (ch ^ 48), ch = getchar... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 730,252 | 730,253 | u023223236 | cpp |
p02927 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#define repd(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) repd(i, 0, n)
typedef long long ll;
using namespace std;
... | #include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#define repd(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) repd(i, 0, n)
typedef long long ll;
using namespace std;
... | [
"expression.operation.binary.add"
] | 730,256 | 730,257 | u647592933 | cpp |
p02927 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <vector>
long gcd(long a, long b) {
long count = 0;
for (long i = 22; i < b; i++) {
long d1 = i % 10;
long d10 = i / 10;
if (d1 * d10 == a) {
if (d1 >= 2 && d10 >= 2) {
count++;
}
}
}
re... | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <vector>
long gcd(long a, long b) {
long count = 0;
for (long i = 22; i <= b; i++) {
long d1 = i % 10;
long d10 = i / 10;
if (d1 * d10 == a) {
if (d1 >= 2 && d10 >= 2) {
count++;
}
}
}
r... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 730,260 | 730,261 | u329731898 | cpp |
p02927 | #include <iostream>
using namespace std;
int main() {
int M, D;
cin >> M;
cin >> D;
int days = 0;
for (int i = 4; i <= M; i++) {
for (int j = 22; j <= D; j++) {
if (j % 10 >= 2 && j % 10 * j / 10 == M) {
days++;
}
}
}
cout << days;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int M, D;
cin >> M;
cin >> D;
int days = 0;
for (int i = 4; i <= M; i++) {
for (int j = 22; j <= D; j++) {
if (j % 10 >= 2 && (j % 10) * (j / 10) == i) {
days++;
}
}
}
cout << days;
return 0;
} | [
"control_flow.branch.if.condition.change",
"identifier.change"
] | 730,262 | 730,263 | u846661778 | cpp |
p02927 | #include <iostream>
using namespace std;
int main() {
int M, D;
cin >> M;
cin >> D;
int days = 0;
for (int i = 4; i <= M; i++) {
for (int j = 22; j <= D; j++) {
if (j / 10 >= 2 && j % 10 * j / 10 == M) {
days++;
}
}
}
cout << days;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int M, D;
cin >> M;
cin >> D;
int days = 0;
for (int i = 4; i <= M; i++) {
for (int j = 22; j <= D; j++) {
if (j % 10 >= 2 && (j % 10) * (j / 10) == i) {
days++;
}
}
}
cout << days;
return 0;
} | [
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change",
"identifier.change"
] | 730,264 | 730,263 | u846661778 | cpp |
p02927 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int m, d, cnt = 0;
cin >> m >> d;
if (d < 22) {
cout << 0 << "\n";
return 0;
}
// int a = d %10;
// int b = ((d/10)%10)*10;
// if(a==0) a+=10;
// cout<<"a b "<<a<<" "<<b<<endl;
for (... | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int m, d, cnt = 0;
cin >> m >> d;
if (d < 22) {
cout << 0 << "\n";
return 0;
}
// int a = d %10;
// int b = ((d/10)%10)*10;
// if(a==0) a+=10;
// cout<<"a b "<<a<<" "<<b<<endl;
for (... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 730,268 | 730,269 | u930494948 | cpp |
p02927 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int m, d, cnt = 0;
cin >> m >> d;
if (d < 22) {
cout << 0 << "\n";
return 0;
}
// int a = d %10;
// int b = ((d/10)%10)*10;
// if(a==0) a+=10;
// cout<<"a b "<<a<<" "<<b<<endl;
for (... | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int m, d, cnt = 0;
cin >> m >> d;
if (d < 22) {
cout << 0 << "\n";
return 0;
}
// int a = d %10;
// int b = ((d/10)%10)*10;
// if(a==0) a+=10;
// cout<<"a b "<<a<<" "<<b<<endl;
for (... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 730,270 | 730,269 | u930494948 | cpp |
p02926 | #include <bits/stdc++.h>
#define PI 3.1415926535897932384626433832795029L
using namespace std;
const int INF = (int)2e9 + 1;
const long long LINF = (long long)9e18 + 1;
long double check_rad(long double rad) {
if (rad <= -PI) {
rad += 2 * PI;
} else if (rad > PI) {
rad -= 2 * PI;
}
return rad;
}
bool ... | #include <bits/stdc++.h>
#define PI 3.1415926535897932384626433832795029L
using namespace std;
const int INF = (int)2e9 + 1;
const long long LINF = (long long)9e18 + 1;
long double check_rad(long double rad) {
if (rad <= -PI) {
rad += 2 * PI;
} else if (rad > PI) {
rad -= 2 * PI;
}
return rad;
}
bool ... | [
"io.output.change"
] | 730,279 | 730,280 | u480117549 | cpp |
p02926 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#incl... | #define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#incl... | [
"control_flow.loop.for.condition.change"
] | 730,286 | 730,287 | u811004127 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
#define int ll
#define ll long long int
#define ff first
#define ss second
#define u128 __int128
#define pb push_back
#define N 200010
#define MOD 1000000007
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(20);
int n;
cin >> n;
pair... | #include <bits/stdc++.h>
using namespace std;
#define int ll
#define ll long long int
#define ff first
#define ss second
#define u128 __int128
#define pb push_back
#define N 200010
#define MOD 1000000007
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(20);
int n;
cin >> n;
pair... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 730,297 | 730,298 | u060049558 | cpp |
p02926 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string.h>
#include <string>
#include <unistd.h>
#inclu... | #include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string.h>
#include <string>
#include <unistd.h>
#inclu... | [
"literal.number.change"
] | 730,301 | 730,300 | u159208574 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define pi acos(-1)
#define eps 1e-8
pair<int, int> a[100001];
bool cmp(pair<int, int> a, pair<int, int> b) {
return atan2(1.0 * a.second, 1.0 * a.first) <
atan2(1.0 * b.second, 1.0 * b.first);
}
signed main() {
int n;
scanf("%lld", &n);... | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define pi acos(-1)
#define eps 1e-8
pair<int, int> a[100001];
bool cmp(pair<int, int> a, pair<int, int> b) {
return atan2(1.0 * a.second, 1.0 * a.first) <
atan2(1.0 * b.second, 1.0 * b.first);
}
signed main() {
int n;
scanf("%lld", &n);... | [
"control_flow.loop.for.condition.change"
] | 730,309 | 730,310 | u413057858 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
bool compare(const vector<long long> &a, const vector<long long> &b) {
return atan2(a[1], a[0]) < atan2(b[1], b[0]);
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
vector<vector<long long>> coords;
for (int i = 0; i < N; i++) {... | #include <bits/stdc++.h>
using namespace std;
bool compare(const vector<long long> &a, const vector<long long> &b) {
return atan2(a[1], a[0]) < atan2(b[1], b[0]);
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
vector<vector<long long>> coords;
for (int i = 0; i < N; i++) {... | [
"control_flow.loop.for.condition.change",
"assignment.change"
] | 730,314 | 730,315 | u475008359 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2000, INF = 0x3f3f3f3f, M = 2e6 + 5;
const ll LNF = 0x3f3f3f3f3f3f3f3f;
#define rep(i, l, r) for (int i = l; i <= r; i++)
#define per(i, r, l) for (int i = r; i >= l; i--)
#define repe(i, u) for (int i = head[u]; i; i = nxt[i])
const dou... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2000, INF = 0x3f3f3f3f, M = 2e6 + 5;
const ll LNF = 0x3f3f3f3f3f3f3f3f;
#define rep(i, l, r) for (int i = l; i <= r; i++)
#define per(i, r, l) for (int i = r; i >= l; i--)
#define repe(i, u) for (int i = head[u]; i; i = nxt[i])
const dou... | [
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 730,327 | 730,328 | u667714875 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2000, INF = 0x3f3f3f3f, M = 2e6 + 5;
const ll LNF = 0x3f3f3f3f3f3f3f3f;
#define rep(i, l, r) for (int i = l; i <= r; i++)
#define per(i, r, l) for (int i = r; i >= l; i--)
#define repe(i, u) for (int i = head[u]; i; i = nxt[i])
const dou... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2000, INF = 0x3f3f3f3f, M = 2e6 + 5;
const ll LNF = 0x3f3f3f3f3f3f3f3f;
#define rep(i, l, r) for (int i = l; i <= r; i++)
#define per(i, r, l) for (int i = r; i >= l; i--)
#define repe(i, u) for (int i = head[u]; i; i = nxt[i])
const dou... | [
"literal.number.change",
"io.output.change",
"call.arguments.change",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 730,329 | 730,328 | u667714875 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2000, INF = 0x3f3f3f3f, M = 2e6 + 5;
const ll LNF = 0x3f3f3f3f3f3f3f3f;
#define rep(i, l, r) for (int i = l; i <= r; i++)
#define per(i, r, l) for (int i = r; i >= l; i--)
#define repe(i, u) for (int i = head[u]; i; i = nxt[i])
const dou... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2000, INF = 0x3f3f3f3f, M = 2e6 + 5;
const ll LNF = 0x3f3f3f3f3f3f3f3f;
#define rep(i, l, r) for (int i = l; i <= r; i++)
#define per(i, r, l) for (int i = r; i >= l; i--)
#define repe(i, u) for (int i = head[u]; i; i = nxt[i])
const dou... | [
"literal.number.change",
"io.output.change",
"call.arguments.change",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 730,330 | 730,328 | u667714875 | cpp |
p02926 | #include <cmath>
#include <iostream>
using namespace std;
#define df 1
const double pi = acos(-1.0);
bool foword(double dx, double dy, int x, int y) { return dx * x + dy * y > 0; }
long int norm(long int x, long int y) { return x * x + y * y; }
int main() {
if (df)
printf("*debug mode*\n");
int n;
cin >> ... | #include <cmath>
#include <iostream>
using namespace std;
#define df 0
const double pi = acos(-1.0);
bool foword(double dx, double dy, int x, int y) { return dx * x + dy * y > 0; }
long int norm(long int x, long int y) { return x * x + y * y; }
int main() {
if (df)
printf("*debug mode*\n");
int n;
cin >> ... | [
"preprocessor.define.value.change",
"literal.integer.change"
] | 730,336 | 730,337 | u014847113 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const double pi = 3.141592653589793238462643383279;
int main() {
int N;
cin >> N;
vector<double> x(N);
vector<double> y(N);
for (int i = 0; i < N; i++) {
cin >> x[i] >> y[i];
}
double ans = 0.0;
for (int i = 0; i < 4000; i++) {
... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const double pi = 3.141592653589793238462643383279;
int main() {
int N;
cin >> N;
vector<double> x(N);
vector<double> y(N);
for (int i = 0; i < N; i++) {
cin >> x[i] >> y[i];
}
double ans = 0.0;
for (int i = 0; i < 4000; i++) {
... | [
"io.output.change"
] | 730,340 | 730,341 | u904123392 | cpp |
p02926 | #include <bits/stdc++.h>
int main() {
using namespace std;
unsigned long N;
cin >> N;
vector<pair<long, long>> eng(N);
for (auto &i : eng)
cin >> i.first >> i.second;
auto d = static_cast<unsigned long>(partition(eng.begin(), eng.end(),
[](auto i) {
... | #include <bits/stdc++.h>
int main() {
using namespace std;
unsigned long N;
cin >> N;
vector<pair<long, long>> eng(N);
for (auto &i : eng)
cin >> i.first >> i.second;
auto d = static_cast<unsigned long>(partition(eng.begin(), eng.end(),
[](auto i) {
... | [
"control_flow.loop.for.condition.change"
] | 730,347 | 730,348 | u462437857 | cpp |
p02926 | #include <bits/stdc++.h>
int main() {
using namespace std;
unsigned long N;
cin >> N;
vector<pair<long, long>> eng(N);
for (auto &i : eng)
cin >> i.first >> i.second;
auto d = static_cast<unsigned long>(partition(eng.begin(), eng.end(),
[](auto i) {
... | #include <bits/stdc++.h>
int main() {
using namespace std;
unsigned long N;
cin >> N;
vector<pair<long, long>> eng(N);
for (auto &i : eng)
cin >> i.first >> i.second;
auto d = static_cast<unsigned long>(partition(eng.begin(), eng.end(),
[](auto i) {
... | [
"misc.opposites",
"expression.operator.compare.change",
"function.return_value.change",
"expression.operation.binary.change",
"control_flow.loop.for.condition.change"
] | 730,349 | 730,348 | u462437857 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
tuple<double, double, double> t[2 * n];
for (int i = 0; i < n; ++i) {
double x, y;
cin >> x >> y;
double arg = atan(y / x);
t[i] = t[i + n] = make_tuple(arg, x, y);
}
sort(t, t + n);
sort(t + n, t + 2 * n);
// f... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
tuple<double, double, double> t[2 * n];
for (int i = 0; i < n; ++i) {
double x, y;
cin >> x >> y;
double arg = atan2(y, x);
t[i] = t[i + n] = make_tuple(arg, x, y);
}
sort(t, t + n);
sort(t + n, t + 2 * n);
// f... | [
"identifier.change",
"call.function.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 730,359 | 730,360 | u918753189 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// #define int long long
#define SZ(x) ((int)(x).size())
#define ALL(x) (x).begin(), (x).end()
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define REP(i, x) for (int i = 0; i < (int)(x); i++)
#define REPS(i, x) for (int i = 1; i <=... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// #define int long long
#define SZ(x) ((int)(x).size())
#define ALL(x) (x).begin(), (x).end()
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define REP(i, x) for (int i = 0; i < (int)(x); i++)
#define REPS(i, x) for (int i = 1; i <=... | [
"io.output.change"
] | 730,365 | 730,366 | u027861917 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
const int OO = 1e9;
const double EPS = 1e-9;
#define ndl cout << '\n'
#define sz(v) int(v.size())
#define pb push_back
#define mp make_pair
#define fs first
#define sc second
#define present(a, x) (a.find(x) != a.end())
#ifdef LOCAL
#define db(...) ... | #include <bits/stdc++.h>
using namespace std;
const int OO = 1e9;
const double EPS = 1e-9;
#define ndl cout << '\n'
#define sz(v) int(v.size())
#define pb push_back
#define mp make_pair
#define fs first
#define sc second
#define present(a, x) (a.find(x) != a.end())
#ifdef LOCAL
#define db(...) ... | [
"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"
] | 730,367 | 730,368 | u935316779 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
#define int long long
typedef vector<int> vint;
typedef pair<int, int> pint;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
template <typename T, typename U> inline bool ... | #include <bits/stdc++.h>
using namespace std;
#define int long long
typedef vector<int> vint;
typedef pair<int, int> pint;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
template <typename T, typename U> inline bool ... | [
"literal.number.change",
"assignment.value.change"
] | 730,380 | 730,381 | u450832845 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
#define int long long
typedef vector<int> vint;
typedef pair<int, int> pint;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
template <typename T, typename U> inline bool ... | #include <bits/stdc++.h>
using namespace std;
#define int long long
typedef vector<int> vint;
typedef pair<int, int> pint;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
template <typename T, typename U> inline bool ... | [
"literal.number.change",
"assignment.value.change"
] | 730,380 | 730,382 | u450832845 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int i = 0; i < N; i++)
using ll = long long int;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
// Modulo.h start----------------------------------------
#pragma once
#include <iostream>
#include <vector>
unsigned int mod;
struct Modint;
... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int i = 0; i < N; i++)
using ll = long long int;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
// Modulo.h start----------------------------------------
#pragma once
#include <iostream>
#include <vector>
unsigned int mod;
struct Modint;
... | [
"assignment.variable.change",
"identifier.change"
] | 730,390 | 730,391 | u378945900 | cpp |
p02926 | #include <bits/stdc++.h>
using std::make_pair;
using std::pair;
typedef pair<int, int> Pair;
#define update_max(a, b) \
if ((a) < (b)) \
(a) = (b)
#define update_min(a, b) ... | #include <bits/stdc++.h>
using std::make_pair;
using std::pair;
typedef pair<int, int> Pair;
#define update_max(a, b) \
if ((a) < (b)) \
(a) = (b)
#define update_min(a, b) ... | [
"expression.operation.binary.remove"
] | 730,396 | 730,397 | u685085662 | cpp |
p02926 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const long double PI = 3.141592653589793;
const long double eps = 1e-9;
struct point {
long double theta, x, y;
bool operator<(const point &r) const { return theta < r.theta - ep... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const long double PI = 3.141592653589793;
const long double eps = 1e-9;
struct point {
long double theta, x, y;
bool operator<(const point &r) const { return theta < r.theta - ep... | [
"control_flow.branch.if.condition.change"
] | 730,398 | 730,399 | u623954643 | cpp |
p02926 | #include <bits/stdc++.h>
// #include <boost/multiprecision/cpp_int.hpp>
#define int long long
#define inf 1000000007
#define pa pair<int, int>
#define ll long long
#define pal pair<double, double>
#define ppap pair<pa, int>
#define PI 3.14159265358979323846
#define paa pair<int, char>
#define mp make_pair
#define p... | #include <bits/stdc++.h>
// #include <boost/multiprecision/cpp_int.hpp>
#define int long long
#define inf 1000000007
#define pa pair<int, int>
#define ll long long
#define pal pair<double, double>
#define ppap pair<pa, int>
#define PI 3.14159265358979323846
#define paa pair<int, char>
#define mp make_pair
#define p... | [
"control_flow.branch.if.condition.change"
] | 730,400 | 730,401 | u834777932 | cpp |
p02926 | #include <bits/stdc++.h>
// #include <boost/multiprecision/cpp_int.hpp>
#define int long long
#define inf 1000000007
#define pa pair<int, int>
#define ll long long
#define pal pair<double, double>
#define ppap pair<pa, int>
#define PI 3.14159265358979323846
#define paa pair<int, char>
#define mp make_pair
#define p... | #include <bits/stdc++.h>
// #include <boost/multiprecision/cpp_int.hpp>
#define int long long
#define inf 1000000007
#define pa pair<int, int>
#define ll long long
#define pal pair<double, double>
#define ppap pair<pa, int>
#define PI 3.14159265358979323846
#define paa pair<int, char>
#define mp make_pair
#define p... | [
"control_flow.branch.if.condition.change",
"literal.number.change",
"variable_declaration.value.change"
] | 730,402 | 730,401 | u834777932 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using uint = unsigned int;
using pcc = pair<char, char>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using tuplis = pair<ll, pll>;
using tuplis2 = pair<... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using uint = unsigned int;
using pcc = pair<char, char>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using tuplis = pair<ll, pll>;
using tuplis2 = pair<... | [
"expression.operation.binary.remove"
] | 730,403 | 730,404 | u874644572 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using uint = unsigned int;
using pcc = pair<char, char>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using tuplis = pair<ll, pll>;
using tuplis2 = pair<... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using uint = unsigned int;
using pcc = pair<char, char>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using tuplis = pair<ll, pll>;
using tuplis2 = pair<... | [
"expression.operation.binary.remove",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 730,405 | 730,404 | u874644572 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define fast_io \
ios::sync_with_stdio(0); \
cin.tie(0)
#define infl 1e18L + 9
#define inf 1e9L + 9
#define sz... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define fast_io \
ios::sync_with_stdio(0); \
cin.tie(0)
#define infl 1e18L + 9
#define inf 1e9L + 9
#define sz... | [
"assignment.change"
] | 730,418 | 730,419 | u586524249 | cpp |
p02926 | #include <bits/stdc++.h>
#define FI first
#define SE second
#define EPS 1e-9
#define ALL(a) a.begin(), a.end()
#define SZ(a) int((a).size())
#define MS(s, n) memset(s, n, sizeof(s))
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define FORE(i, a, b) for (int i = (a); i >= (b); i--)
#define FORALL(it, a) ... | #include <bits/stdc++.h>
#define FI first
#define SE second
#define EPS 1e-9
#define ALL(a) a.begin(), a.end()
#define SZ(a) int((a).size())
#define MS(s, n) memset(s, n, sizeof(s))
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define FORE(i, a, b) for (int i = (a); i >= (b); i--)
#define FORALL(it, a) ... | [
"assignment.change"
] | 730,426 | 730,427 | u131020584 | cpp |
p02926 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using ll = long long;
using namespace std;
using P = pair<double, double>;
int main() {
int n;
cin >> n;
P en[n];
for (auto &ei : en)
cin >> ei.first >> ei.second;
double b... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using ll = long long;
using namespace std;
using P = pair<double, double>;
int main() {
int n;
cin >> n;
P en[n];
for (auto &ei : en)
cin >> ei.first >> ei.second;
double b... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 730,428 | 730,429 | u956758464 | cpp |
p02926 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using ll = long long;
using namespace std;
using P = pair<double, double>;
int main() {
int n;
cin >> n;
P en[n];
for (auto &ei : en)
cin >> ei.first >> ei.second;
double b... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using ll = long long;
using namespace std;
using P = pair<double, double>;
int main() {
int n;
cin >> n;
P en[n];
for (auto &ei : en)
cin >> ei.first >> ei.second;
double b... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 730,430 | 730,431 | u956758464 | cpp |
p02926 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using ll = long long;
using namespace std;
using P = pair<double, double>;
int main() {
int n;
cin >> n;
P en[n];
for (auto &ei : en)
cin >> ei.first >> ei.second;
double b... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using ll = long long;
using namespace std;
using P = pair<double, double>;
int main() {
int n;
cin >> n;
P en[n];
for (auto &ei : en)
cin >> ei.first >> ei.second;
double b... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 730,432 | 730,431 | u956758464 | cpp |
p02926 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using ll = long long;
using namespace std;
using P = pair<double, double>;
int main() {
int n;
cin >> n;
P en[n];
for (auto &ei : en)
cin >> ei.first >> ei.second;
double b... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using ll = long long;
using namespace std;
using P = pair<double, double>;
int main() {
int n;
cin >> n;
P en[n];
for (auto &ei : en)
cin >> ei.first >> ei.second;
double b... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 730,430 | 730,433 | u956758464 | cpp |
p02926 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using ll = long long;
using namespace std;
using P = pair<double, double>;
int main() {
int n;
cin >> n;
P en[n];
for (auto &ei : en)
cin >> ei.first >> ei.second;
double b... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using ll = long long;
using namespace std;
using P = pair<double, double>;
int main() {
int n;
cin >> n;
P en[n];
for (auto &ei : en)
cin >> ei.first >> ei.second;
double b... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 730,432 | 730,433 | u956758464 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef pair<ll, P> P3;
typedef pair<P, P> PP;
constexpr ll MOD = ll(1e9 + 7);
constexpr int IINF = INT_MAX;
constexpr ll LLINF = LLONG_MAX;
constexpr int MAX_N = int(1e5) + 5;
constexpr double ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef pair<ll, P> P3;
typedef pair<P, P> PP;
constexpr ll MOD = ll(1e9 + 7);
constexpr int IINF = INT_MAX;
constexpr ll LLINF = LLONG_MAX;
constexpr int MAX_N = int(1e5) + 5;
constexpr double ... | [
"call.function.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 730,448 | 730,449 | u271063202 | cpp |
p02927 | #include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define rep(i, b, n) for (int(i) = (b); (i) < (n); (i)++)
#define anin(ans) printf("%d\n", ans);
int main(void) {
int i, I, M, D, ans(0);
scanf("%d %d", &M, &D);
for (I = 2; I <= M; I++) {
for (i = 2; i <= D / 10; i++) {
if (... | #include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define rep(i, b, n) for (int(i) = (b); (i) < (n); (i)++)
#define anin(ans) printf("%d\n", ans);
int main(void) {
int i, I, M, D, ans(0);
scanf("%d %d", &M, &D);
for (I = 2; I <= M; I++) {
for (i = 2; i <= D / 10; i++) {
if (... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 730,452 | 730,453 | u456658814 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, d;
int result = 0;
scanf("%d%d", &m, &d);
for (int dd = 22; dd < d; dd++) {
int d1 = dd % 10;
int d10 = dd / 10;
if (d1 * d10 >= 4) {
for (int mm = 4; mm <= m; mm++) {
if (d1 * d10 == mm) {
// printf... | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, d;
int result = 0;
scanf("%d%d", &m, &d);
for (int dd = 22; dd <= d; dd++) {
int d1 = dd % 10;
int d10 = dd / 10;
if (d1 >= 2 && d10 >= 2) {
for (int mm = 4; mm <= m; mm++) {
if (d1 * d10 == mm) {
// ... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change",
"literal.number.change"
] | 730,456 | 730,455 | u283907492 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define float double
#define INF 1ll << 60
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int M, D, count = 0;
cin >> M >> D;
for (int i = 0; i < D; i++) {
if (i >= 10 && (i % 10) >= 2 && (i / 10) >= 2)... | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define float double
#define INF 1ll << 60
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int M, D, count = 0;
cin >> M >> D;
for (int i = 1; i <= D; i++) {
if (i >= 10 && (i % 10) >= 2 && (i / 10) >= 2... | [
"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"
] | 730,457 | 730,458 | u128065625 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define float double
#define INF 1ll << 60
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int M, D, count = 0;
cin >> M >> D;
for (int j = 1; j <= M; j++) {
for (int i = 1; i < D; i++) {
if (i >= ... | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define float double
#define INF 1ll << 60
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int M, D, count = 0;
cin >> M >> D;
for (int j = 1; j <= M; j++) {
for (int i = 1; i <= D; i++) {
if (i >=... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 730,459 | 730,460 | u128065625 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
int loop, loop2;
int ans = 0;
for (loop = 4; loop <= M; loop++) {
if (loop > 18 || D < 22)
break;
for (loop2 = 2; loop2 < 10; loop2++) {
if (loop % loop2) {
if (loop / loop2) {
continue;
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
int loop, loop2;
int ans = 0;
for (loop = 4; loop <= M; loop++) {
if (loop > 81 || D < 22)
break;
for (loop2 = 2; loop2 < 10; loop2++) {
if (loop % loop2) {
if (loop / loop2) {
continue;
... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 730,481 | 730,482 | u541263126 | cpp |
p02927 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
int cou = 0;
for (int i = 22; i < D; i++) {
int d10 = i / 10;
int d1 = i - (d10 * 10);
int sum = d10 * d1;
if (sum <= M && d10 >= 2 && d1 >= 2) {
cou++;
... | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
int cou = 0;
for (int i = 22; i < D + 1; i++) {
int d10 = i / 10;
int d1 = i - (d10 * 10);
int sum = d10 * d1;
if (sum <= M && d10 >= 2 && d1 >= 2) {
cou... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 730,487 | 730,488 | u927933718 | cpp |
p02927 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
#define rep(i, n) for (int i = 0, i##_len = (n); i ... | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
#define rep(i, n) for (int i = 0, i##_len = (n); i ... | [
"identifier.change"
] | 730,500 | 730,501 | u576106056 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, d, a = 0;
cin >> m >> d;
if (d == 1 || m < 4)
cout << 0 << endl;
else {
for (int i = 1; i <= m; i++) {
for (int j = 2; j <= d; j++) {
int k = j % 10, l = j / 10;
if (k * l == m && k != 1 && l != 1)
a++;
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, d, a = 0;
cin >> m >> d;
if (d == 1 || m < 4)
cout << 0 << endl;
else {
for (int i = 1; i <= m; i++) {
for (int j = 2; j <= d; j++) {
int k = j % 10, l = j / 10;
if (k * l == i && k != 1 && l != 1)
a++;
... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 730,502 | 730,503 | u072080927 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
int main() {
int M, D, count = 0;
cin >> M >> D;
for (int i = 1; i < M + 1; i++) {
for (int j = 1; j < D + 1; j++) {
if (j / 10 >= 2 && j % 10 >= 2) {
if ((j / 10) * (j % 10) == i) {
count++;
}
}
}
}
cout << count - 1... | #include <bits/stdc++.h>
using namespace std;
int main() {
int M, D, count = 0;
cin >> M >> D;
for (int i = 1; i < M + 1; i++) {
for (int j = 1; j < D + 1; j++) {
if (j / 10 >= 2 && j % 10 >= 2) {
if ((j / 10) * (j % 10) == i) {
count++;
}
}
}
}
cout << count << ... | [
"expression.operation.binary.remove"
] | 730,514 | 730,515 | u361557064 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
int main() {
int M, D, count = 0;
cin >> M >> D;
for (int i = 1; i < M + 1; i++) {
for (int j = 1; j < D + 1; j++) {
if (j >= 22 && j % 10 >= 2) {
if ((j / 10) * (j % 10) == i) {
count++;
}
}
}
}
cout << count - 1 << ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int M, D, count = 0;
cin >> M >> D;
for (int i = 1; i < M + 1; i++) {
for (int j = 1; j < D + 1; j++) {
if (j / 10 >= 2 && j % 10 >= 2) {
if ((j / 10) * (j % 10) == i) {
count++;
}
}
}
}
cout << count << ... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"literal.number.change",
"expression.operation.binary.remove"
] | 730,516 | 730,515 | u361557064 | cpp |
p02927 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int m, d;
cin >> m >> d;
vector<int> a;
for (int i = 22; i <= d; i++) {
int j_10 = i / 10;
int j = i % 10;
if (j * j_10 <= 100)
a.push_back(j_10 * j);
}
int cou... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int m, d;
cin >> m >> d;
vector<int> a;
for (int i = 22; i <= d; i++) {
int j_10 = i / 10;
int j = i % 10;
if (j > 1 && j_10 > 1)
a.push_back(j_10 * j);
}
int c... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 730,517 | 730,518 | u115819033 | cpp |
p02927 | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
int max_d10 = D / 10;
int max_d1 = D % 10;
if (D < 22 || M < 4)
cout << 0 << endl;
else {
int c = 0;
for (int i = 2; i < max_d10; i++) {
c += min(8, min(M / i - 1, 0));
}
for (int ... | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
int max_d10 = D / 10;
int max_d1 = D % 10;
if (D < 22 || M < 4)
cout << 0 << endl;
else {
int c = 0;
for (int i = 2; i < max_d10; i++) {
c += min(8, max(M / i - 1, 0));
}
for (int ... | [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change",
"call.arguments.change"
] | 730,519 | 730,520 | u552137999 | cpp |
p02927 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
int count = 0;
for (int i = 1; i <= M; i++) {
for (int j = 0; j <= D / 10; j++) {
for (int k = 0; k <= 10; k++) {
if (10 * j + k > D)
break;
if (j * k == M) {
count++;... | #include <iostream>
#include <vector>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
int count = 0;
for (int i = 1; i <= M; i++) {
for (int j = 2; j <= D / 10; j++) {
for (int k = 2; k <= 9; k++) {
if (10 * j + k > D)
break;
if (j * k == i) {
count++;
... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"identifier.change",
"control_flow.branch.if.condition.change"
] | 730,521 | 730,522 | u022890424 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
int main() {
int M, D, cnt = 0, i, j, k, l;
cin >> M >> D;
for (l = 1; l <= M; l++)
for (k = 22; k <= D; k++) {
i = k / 10;
j = k % 10;
if (i >= 2 && j >= 2) {
if (i * j == M)
cnt++;
}
}
cout << cnt;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int M, D, cnt = 0, i, j, k, l;
cin >> M >> D;
for (l = 4; l <= M; l++) {
for (k = 22; k <= D; k++) {
i = k / 10;
j = k % 10;
if (i >= 2 && j >= 2) {
if (i * j == l)
cnt++;
}
}
}
cout << cnt;
return... | [
"literal.number.change",
"assignment.value.change",
"control_flow.loop.for.initializer.change",
"identifier.change",
"control_flow.branch.if.condition.change"
] | 730,530 | 730,531 | u228943017 | cpp |
p02927 | #include <algorithm>
#include <iostream>
#include <string>
#define SIZE_OF_ARRAY(array) (sizeof(array) / sizeof(array[0]))
using namespace std;
#include <fstream>
#include <iostream>
using namespace std;
int main() {
int m, n;
cin >> m >> n;
int count = 0;
int hairetu[n] = {0};
for (int i = 0; i < n; i... | #include <algorithm>
#include <iostream>
#include <string>
#define SIZE_OF_ARRAY(array) (sizeof(array) / sizeof(array[0]))
using namespace std;
#include <fstream>
#include <iostream>
using namespace std;
int main() {
int m, n;
cin >> m >> n;
int count = 0;
int hairetu[n] = {0};
for (int i = 0; i < n; i... | [
"assignment.change"
] | 730,536 | 730,537 | u259590403 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
int main() {
int M, D, ans = 0, dt, dd;
cin >> M >> D;
for (int m = 4; m <= M; m++) {
for (int d = 22; d <= D; d++) {
dt = d / 10;
dd = d - dt * 10;
if (dd < 3)
continue;
if (dt * dd == m)
ans++;
}
}
cout << ans << ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int M, D, ans = 0, dt, dd;
cin >> M >> D;
for (int m = 4; m <= M; m++) {
for (int d = 22; d <= D; d++) {
dt = d / 10;
dd = d - dt * 10;
if (dd < 2)
continue;
if (dt * dd == m)
ans++;
}
}
cout << ans << ... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 730,540 | 730,541 | u158628538 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
#define rep2(i, a, b) for (int i = (a); i < (b); i++)
int main() {
int m, d;
cin >> m >> d;
int count = 0;
int D = 0;
rep2(i, 1, d) {
if ((i / 10) >= 2 && (i % 10) >= 2) {
D = (i / 10) * (i % 10);
} else {
D = -1;
}
if (1 <= D && D ... | #include <bits/stdc++.h>
using namespace std;
#define rep2(i, a, b) for (int i = (a); i < (b); i++)
int main() {
int m, d;
cin >> m >> d;
int count = 0;
int D = 0;
rep2(i, 1, d + 1) {
if ((i / 10) >= 2 && (i % 10) >= 2) {
D = (i / 10) * (i % 10);
} else {
D = -1;
}
if (1 <= D &... | [
"expression.operation.binary.add"
] | 730,544 | 730,545 | u010806195 | cpp |
p02927 | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <string>
using namespace std;
int main() {
int M, D, d1, d10, S = 0;
string day;
cin >> M;
cin >> D;
for (int i = 4; i <= M; i++) {
for (int j = 22; j <= D; j++) {
d1 = j / 10;
d10 = j ... | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <string>
using namespace std;
int main() {
int M, D, d1, d10, S = 0;
string day;
cin >> M;
cin >> D;
for (int i = 4; i <= M; i++) {
for (int j = 22; j <= D; j++) {
d1 = j / 10;
d10 = j ... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 730,546 | 730,547 | u480117549 | cpp |
p02927 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define MOD 1000000007
using namespace std;
t... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define MOD 1000000007
using namespace std;
t... | [
"control_flow.loop.for.condition.change"
] | 730,560 | 730,561 | u997325490 | cpp |
p02927 | #include <bits/stdc++.h>
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
using namespace std;
typedef long long ll;
const ll mod = 1e9 + 7;
#define all(x) (x).begin(), (x).end()
template <class T> inline void chmin(T &a, T b) {
if (a > b) {
a = b;
}
}
template <class T> inline void chmax(T &a, T b) {
i... | #include <bits/stdc++.h>
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
using namespace std;
typedef long long ll;
const ll mod = 1e9 + 7;
#define all(x) (x).begin(), (x).end()
template <class T> inline void chmin(T &a, T b) {
if (a > b) {
a = b;
}
}
template <class T> inline void chmax(T &a, T b) {
i... | [] | 730,562 | 730,563 | u017078415 | cpp |
p02927 | #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(), a.end()
#define rrng(a) a.rbegin()... | #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(), a.end()
#define rrng(a) a.rbegin()... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 730,564 | 730,565 | u520791604 | cpp |
p02927 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
int result = 0;
for (int i = 0; i < D; i++) {
int d1 = i % 10;
int d2 = i / 1... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
int result = 0;
for (int i = 0; i <= D; i++) {
int d1 = i % 10;
int d2 = i / ... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 730,566 | 730,567 | u376998218 | cpp |
p02927 | #include <algorithm>
#include <deque>
#include <iostream>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define endl "\n"
using namespace std;
template <typename T> void printArray(T a) {
for (auto i : a)
cout << i << " ";
cout <<... | #include <algorithm>
#include <deque>
#include <iostream>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define endl "\n"
using namespace std;
template <typename T> void printArray(T a) {
for (auto i : a)
cout << i << " ";
cout <<... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 730,575 | 730,576 | u282549895 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define vi vector<int>
#define ll long long
#define vl vector<ll>
#define vll vector<vl>
const int INF = 1e9;
int main() {
int m, d;
cin >> m >> d;
int ans = 0;
rep(i, m) rep(j, d) {
int a = i + 1;
int b = j ... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define vi vector<int>
#define ll long long
#define vl vector<ll>
#define vll vector<vl>
const int INF = 1e9;
int main() {
int m, d;
cin >> m >> d;
int ans = 0;
rep(i, m) rep(j, d) {
int a = i + 1;
int b = j ... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 730,580 | 730,581 | u517935400 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)n; ++i)
#define FOR(i, a, b) for (int i = a; i < (int)b; ++i)
typedef long long ll;
const int Inf = 1e9;
const double EPS = 1e-9;
int gcd(int a, int b) {
if (b == 0) {
return a;
} else {
return gcd(b, a % b);
}
}... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)n; ++i)
#define FOR(i, a, b) for (int i = a; i < (int)b; ++i)
typedef long long ll;
const int Inf = 1e9;
const double EPS = 1e-9;
int gcd(int a, int b) {
if (b == 0) {
return a;
} else {
return gcd(b, a % b);
}
}... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 730,592 | 730,593 | u940569542 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, m, n) for (int i = m; i < n; i++)
int main() {
// ここに処理を記述
int M, D;
cin >> M >> D;
int ans = 0;
FOR(i, 1, M + 1) {
FOR(j, 1, D) {
int d1 = j % 10;
int d2... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, m, n) for (int i = m; i < n; i++)
int main() {
// ここに処理を記述
int M, D;
cin >> M >> D;
int ans = 0;
FOR(i, 1, M + 1) {
FOR(j, 1, D + 1) {
int d1 = j % 10;
in... | [
"expression.operation.binary.add"
] | 730,594 | 730,595 | u633451629 | cpp |
p02927 | #include <bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define pii pair<int, int>
#define fi first
#define sc second
#define ALL(x) x.begin(), x.end()
#define RALL(X) x.begin(), x.end()
#define FOR(i, n, k) for (i = 0; i < n; i += k)
#define FO(i, n, k) for (i = 1; i <= n; i += k)
#define CLEAR(a, b) memset... | #include <bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define pii pair<int, int>
#define fi first
#define sc second
#define ALL(x) x.begin(), x.end()
#define RALL(X) x.begin(), x.end()
#define FOR(i, n, k) for (i = 0; i < n; i += k)
#define FO(i, n, k) for (i = 1; i <= n; i += k)
#define CLEAR(a, b) memset... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 730,600 | 730,601 | u724515098 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long m, d, ans = 0;
cin >> m >> d;
for (int i = 2; i <= d; i++) {
for (int j = 2; j <= d; j++) {
long long z = i * j;
if (i * 10 + j <= d && z <= m) {
ans++;
}
}
}
cout << ans;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long m, d, ans = 0;
cin >> m >> d;
for (int i = 2; i <= 9; i++) {
for (int j = 2; j <= 9; j++) {
long long z = i * j;
if (i * 10 + j <= d && z <= m) {
ans++;
}
}
}
cout << ans;
return 0;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 730,602 | 730,603 | u206580411 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
#define INF 2147483647
#define INFF 9223372036854775807
#define ll long long
#define REP(i, n) for (long long i = 0; i < n; i++)
#define REPP(i, m, n) for (long long i = m; i < n; i++)
#define ALL(N) (N.begin(), N.end())
#define de cout << "line : " << __LINE__ << " debug" ... | #include <bits/stdc++.h>
using namespace std;
#define INF 2147483647
#define INFF 9223372036854775807
#define ll long long
#define REP(i, n) for (long long i = 0; i < n; i++)
#define REPP(i, m, n) for (long long i = m; i < n; i++)
#define ALL(N) (N.begin(), N.end())
#define de cout << "line : " << __LINE__ << " debug" ... | [
"control_flow.branch.if.condition.change"
] | 730,604 | 730,605 | u901397311 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.