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 |
|---|---|---|---|---|---|---|---|
p03037 |
#include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
const ll INF = 1ll << 60;
const ll MOD = 1e9 + 7;
bool greaterSecond(const pair<int, int> &f, const pair<int, int> &s) {
return f.second > s.second;
}
int main(void) {
int n, m;
cin >> n >> m;
int largestL = 0;
int smallestR = 1e9;
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
largestL = max(largestL, l);
smallestR = min(smallestR, r);
}
if (smallestR <= largestL) {
cout << smallestR - largestL + 1 << endl;
} else {
cout << 0 << endl;
}
}
|
#include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
const ll INF = 1ll << 60;
const ll MOD = 1e9 + 7;
bool greaterSecond(const pair<int, int> &f, const pair<int, int> &s) {
return f.second > s.second;
}
int main(void) {
int n, m;
cin >> n >> m;
int largestL = 0;
int smallestR = 1e9;
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
largestL = max(largestL, l);
smallestR = min(smallestR, r);
}
if (largestL <= smallestR) {
cout << smallestR - largestL + 1 << endl;
} else {
cout << 0 << endl;
}
}
| [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 851,373 | 851,374 | u845000384 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int n, m;
cin >> n >> m;
int l[m];
int r[m];
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
}
int l_max = INT_MIN;
int r_min = INT_MAX;
for (int i = 0; i < m; i++) {
l_max = max(l[i], l_max);
r_min = min(r[i], r_min);
}
cout << min(r_min - l_max + 1, 0) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int n, m;
cin >> n >> m;
int l[m];
int r[m];
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
}
int l_max = INT_MIN;
int r_min = INT_MAX;
for (int i = 0; i < m; i++) {
l_max = max(l[i], l_max);
r_min = min(r[i], r_min);
}
cout << max(r_min - l_max + 1, 0) << endl;
} | [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 851,375 | 851,376 | u680087927 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int n, m;
cin >> n >> m;
int l[m];
int r[m];
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
}
int l_max = INT_MIN;
int r_min = INT_MAX;
for (int i = 0; i < m; i++) {
l_max = max(l[i], l_max);
r_min = min(r[i], r_min);
}
cout << r_min - l_max + 1 << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int n, m;
cin >> n >> m;
int l[m];
int r[m];
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
}
int l_max = INT_MIN;
int r_min = INT_MAX;
for (int i = 0; i < m; i++) {
l_max = max(l[i], l_max);
r_min = min(r[i], r_min);
}
cout << max(r_min - l_max + 1, 0) << endl;
} | [
"call.add",
"call.arguments.add"
] | 851,377 | 851,376 | u680087927 | cpp |
p03037 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
#define lpsbd(i, s, b, d) for (size_t i = (s); i < (b); i += (d))
#define lpsb(i, s, b) for (size_t i = (s); i < (b); i++)
#define lpn(i, n) for (size_t i = 0; i < (n); i++)
#define fa(i, x) for (auto &i : x)
#define vcd(t, n, d) vector<t>(n, d)
#define vc(t, n) vector<t>(n)
using namespace std;
using ull = unsigned long long;
const ull MOD = 1000000007;
int main(void) {
int N, M, L, R;
cin >> N >> M;
int l = 1, r = N;
lpn(i, M) {
cin >> L >> R;
l = max(l, L);
r = min(r, R);
}
cout << (l >= r ? l - r + 1 : 0) << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
#define lpsbd(i, s, b, d) for (size_t i = (s); i < (b); i += (d))
#define lpsb(i, s, b) for (size_t i = (s); i < (b); i++)
#define lpn(i, n) for (size_t i = 0; i < (n); i++)
#define fa(i, x) for (auto &i : x)
#define vcd(t, n, d) vector<t>(n, d)
#define vc(t, n) vector<t>(n)
using namespace std;
using ull = unsigned long long;
const ull MOD = 1000000007;
int main(void) {
int N, M, L, R;
cin >> N >> M;
int l = 1, r = N;
lpn(i, M) {
cin >> L >> R;
l = max(l, L);
r = min(r, R);
}
cout << (l <= r ? r - l + 1 : 0) << endl;
return 0;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"io.output.change",
"expression.operation.binary.remove"
] | 851,385 | 851,384 | u330913290 | cpp |
p03037 | #include <iostream>
using namespace std;
int N, M, L[100000], R[100000];
int main() {
cin >> N >> M;
int l = 1, r = N;
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i];
l = max(l, L[i]);
r = min(r, R[i]);
}
cout << r - l + 1 << endl;
}
| #include <iostream>
using namespace std;
int N, M, L[100000], R[100000];
int main() {
cin >> N >> M;
int l = 1, r = N;
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i];
l = max(l, L[i]);
r = min(r, R[i]);
}
cout << max(0, r - l + 1) << endl;
}
| [
"call.add",
"call.arguments.change"
] | 851,392 | 851,393 | u425351967 | cpp |
p03037 | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int L[100010], R[100010];
for (int i = 1; i <= M; i++) {
cin >> L[i] >> R[i];
}
sort(L - 1, L + M - 1);
sort(R - 1, R + M - 1);
int ans = 0;
for (int i = 1; i <= N; i++) {
if (i <= R[1] && i >= L[M])
ans++;
}
cout << ans;
} | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int L[100010], R[100010];
for (int i = 1; i <= M; i++) {
cin >> L[i] >> R[i];
}
sort(L + 1, L + M + 1);
sort(R + 1, R + M + 1);
int ans = 0;
for (int i = 1; i <= N; i++) {
if (i <= R[1] && i >= L[M])
ans++;
}
cout << ans;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 851,398 | 851,399 | u582357587 | cpp |
p03037 | #include <algorithm>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int vector_max(vector<int> &vec) {
int maximum = vec.at(0);
for (int i = 1; i < vec.size(); i++) {
maximum = max(maximum, vec.at(i));
}
return maximum;
}
int vector_min(vector<int> &vec) {
int minimum = vec.at(0);
for (int i = 1; i < vec.size(); i++) {
minimum = min(minimum, vec.at(i));
}
return minimum;
}
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M), R(M);
int mini, maxi;
for (int i = 0; i < M; i++) {
cin >> L.at(i) >> R.at(i);
if (i == 0) {
maxi = L.at(0);
mini = R.at(0);
} else {
maxi = max(maxi, L.at(i));
mini = min(mini, L.at(i));
}
}
int c = 0;
for (int i = maxi; i <= mini; i++) {
c++;
}
cout << c << endl;
}
| #include <algorithm>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int vector_max(vector<int> &vec) {
int maximum = vec.at(0);
for (int i = 1; i < vec.size(); i++) {
maximum = max(maximum, vec.at(i));
}
return maximum;
}
int vector_min(vector<int> &vec) {
int minimum = vec.at(0);
for (int i = 1; i < vec.size(); i++) {
minimum = min(minimum, vec.at(i));
}
return minimum;
}
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M), R(M);
int mini, maxi;
for (int i = 0; i < M; i++) {
cin >> L.at(i) >> R.at(i);
if (i == 0) {
maxi = L.at(0);
mini = R.at(0);
} else {
maxi = max(maxi, L.at(i));
mini = min(mini, R.at(i));
}
}
int c = 0;
for (int i = maxi; i <= mini; i++) {
c++;
}
cout << c << endl;
}
| [
"assignment.value.change",
"identifier.change",
"call.arguments.change"
] | 851,401 | 851,402 | u366651777 | cpp |
p03037 | #include <iostream>
using namespace std;
int main() {
int n, m, i, l, r;
cin >> n >> m;
int begin = 1, end = n;
for (i = 1; i <= m; i++) {
cin >> l >> r;
begin = max(begin, l);
end = min(end, r);
}
cout << end - begin + 1;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, m, i, l, r;
cin >> n >> m;
int begin = 1, end = n;
for (i = 1; i <= m; i++) {
cin >> l >> r;
begin = max(begin, l);
end = min(end, r);
}
cout << max(end - begin + 1, 0);
return 0;
} | [
"call.add",
"call.arguments.add"
] | 851,412 | 851,413 | u526990197 | cpp |
p03037 | //**KEEP IT SHORT AND SIMPLE**
#include <bits/stdc++.h>
#define IO \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define FILES \
freopen("input.txt", "r", stdin); \
freopen("output.txt", "w", stdout);
#define REP(i, a, b) for (int i = a; i < b; i++)
#define NL '\n'
#define F first
#define S second
#define dot(a, b) (conj(a) * (b)).real()
#define cross(a, b) (conj(a) * (b)).imag()
using namespace std;
typedef long long ll;
typedef long double ld;
typedef bool bl;
typedef vector<vector<long long>> vvl;
typedef vector<long long> vll;
typedef pair<long long, long long> pll;
typedef map<long long, long long> mll;
typedef map<long long, bool> mlb;
typedef priority_queue<long long, vector<long long>, greater<long long>> minPq;
typedef tuple<ll, ll, ll> line;
typedef complex<double> point;
const double pi = 2 * acos(0.0);
const int OO = 0x3f3f3f3f;
int main() {
IO ll n, m;
cin >> n >> m;
vector<pll> v(m);
REP(i, 0, m)
cin >> v[i].F >> v[i].S;
sort(v.begin(), v.end());
ll a = v[0].F, b = v[0].S;
REP(i, 1, m) {
a = max(v[i].F, a);
b = min(v[i].S, b);
}
cout << b - a + 1;
return 0;
}
| //**KEEP IT SHORT AND SIMPLE**
#include <bits/stdc++.h>
#define IO \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define FILES \
freopen("input.txt", "r", stdin); \
freopen("output.txt", "w", stdout);
#define REP(i, a, b) for (int i = a; i < b; i++)
#define NL '\n'
#define F first
#define S second
#define dot(a, b) (conj(a) * (b)).real()
#define cross(a, b) (conj(a) * (b)).imag()
using namespace std;
typedef long long ll;
typedef long double ld;
typedef bool bl;
typedef vector<vector<long long>> vvl;
typedef vector<long long> vll;
typedef pair<long long, long long> pll;
typedef map<long long, long long> mll;
typedef map<long long, bool> mlb;
typedef priority_queue<long long, vector<long long>, greater<long long>> minPq;
typedef tuple<ll, ll, ll> line;
typedef complex<double> point;
const double pi = 2 * acos(0.0);
const int OO = 0x3f3f3f3f;
int main() {
IO ll n, m;
cin >> n >> m;
vector<pll> v(m);
REP(i, 0, m) cin >> v[i].F >> v[i].S;
sort(v.begin(), v.end());
ll a = v[0].F, b = v[0].S;
REP(i, 1, m) {
a = max(v[i].F, a);
b = min(v[i].S, b);
}
cout << max(b - a + 1, 0ll);
return 0;
}
| [
"call.add",
"call.arguments.add"
] | 851,432 | 851,433 | u089049901 | cpp |
p03037 | #include <iostream>
#define INF 1e9
using namespace std;
int n, m;
int main() {
cin >> n >> m;
int l_max = -INF;
int r_min = INF;
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
l_max = max(l, l_max);
r_min = min(r, r_min);
}
if (r_min > l_max)
cout << (r_min - l_max + 1) << endl;
else
cout << 0 << endl;
} | #include <iostream>
#define INF 1e9
using namespace std;
int n, m;
int main() {
cin >> n >> m;
int l_max = -INF;
int r_min = INF;
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
l_max = max(l, l_max);
r_min = min(r, r_min);
}
if (r_min >= l_max)
cout << (r_min - l_max + 1) << endl;
else
cout << 0 << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 851,442 | 851,443 | u194268736 | cpp |
p03037 | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int n, m, l, r, lmax = 0, rmin;
cin >> n >> m;
rmin = n;
for (int i = 0; i < m; i++) {
cin >> l >> r;
if (l > lmax)
lmax = l;
if (r < rmin)
rmin = r;
}
cout << rmin - lmax + 1;
return 0;
}
| #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int n, m, l, r, lmax = 0, rmin;
cin >> n >> m;
rmin = n;
for (int i = 0; i < m; i++) {
cin >> l >> r;
if (l > lmax)
lmax = l;
if (r < rmin)
rmin = r;
}
cout << max(rmin - lmax + 1, 0);
return 0;
}
| [
"call.add",
"call.arguments.add"
] | 851,448 | 851,449 | u340494803 | cpp |
p03037 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using ll = long long;
void _cin() {}
template <class Head, class... Tail> void _cin(Head &&head, Tail &&...tail) {
cin >> head;
_cin(forward<Tail>(tail)...);
}
void _cout() { cout << "\n"; }
template <class Head, class... Tail> void _cout(Head &&head, Tail &&...tail) {
cout << head;
_cout(forward<Tail>(tail)...);
}
int gcd(int a, int b) { return (b == 0) ? a : gcd(b, a % b); }
#define Sq(x) (x) * (x)
#define For(i, n) for (int i = 0; i < (n); i++)
#define Rep(n) For(_, n)
#define Range(c) c.begin(), c.end()
#define RevRange(c) c.rbegin(), c.rend()
#define Contains(c, x) (find(Range(c), x) != c.end())
#define Search(rb, re, x) distance(rb, find(rb, re, x))
#define Sort(a) sort(Range(a))
#define DeSort(a) sort(RevRange(a))
#define Reverse(c) reverse(Range(c))
#define Unique(a) a.erase(unique(Range(a)), a.end())
#define Vec2(T, n, m, xs) vector<vector<T>> xs(n, vector<T>(m))
#define Sum(a) accumulate(Range(a), 0)
#define Cusum(T, xs, sxs) \
vector<T> sxs(xs.size() + 1); \
For(i, (int)xs.size()) sxs[i + 1] = sxs[i] + xs[i]
#define Cin(T, ...) \
T __VA_ARGS__; \
_cin(__VA_ARGS__)
#define Cins(T, n, xs) \
vector<T> xs(n); \
For(i, n) cin >> xs[i]
#define Cins2(T, n, xs, ys) \
vector<T> xs(n), ys(n); \
For(i, n) cin >> xs[i] >> ys[i]
#define Cins3(T, n, xs, ys, zs) \
vector<T> xs(n), ys(n), zs(n); \
For(i, n) cin >> xs[i] >> ys[i] >> zs[i]
#define Cinss(T, n, m, xs) \
Vec2(T, n, m, xs); \
For(i, n) For(j, m) cin >> xs[i][j]
#define Cinm(T, n, map) \
unordered_map<T, int> map; \
Rep(n) { \
Cin(T, x); \
map[x]++; \
}
#define Cout(...) _cout(__VA_ARGS__)
#define Couts(xs) \
for (const auto &e : xs) \
cout << e << " "; \
cout << "\n"
#define Coutyn(cond) Cout((cond) ? "yes" : "no")
#define CoutYn(cond) Cout((cond) ? "Yes" : "No")
#define CoutYN(cond) Cout((cond) ? "YES" : "NO")
// constexpr int MOD = 1e9+7;
int main(void) {
Cin(int, n, m);
int l = 1, r = n;
Rep(m) {
Cin(int, a, b);
l = max(l, a);
r = min(r, b);
}
Cout(r - l + 1);
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using ll = long long;
void _cin() {}
template <class Head, class... Tail> void _cin(Head &&head, Tail &&...tail) {
cin >> head;
_cin(forward<Tail>(tail)...);
}
void _cout() { cout << "\n"; }
template <class Head, class... Tail> void _cout(Head &&head, Tail &&...tail) {
cout << head;
_cout(forward<Tail>(tail)...);
}
int gcd(int a, int b) { return (b == 0) ? a : gcd(b, a % b); }
#define Sq(x) (x) * (x)
#define For(i, n) for (int i = 0; i < (n); i++)
#define Rep(n) For(_, n)
#define Range(c) c.begin(), c.end()
#define RevRange(c) c.rbegin(), c.rend()
#define Contains(c, x) (find(Range(c), x) != c.end())
#define Search(rb, re, x) distance(rb, find(rb, re, x))
#define Sort(a) sort(Range(a))
#define DeSort(a) sort(RevRange(a))
#define Reverse(c) reverse(Range(c))
#define Unique(a) a.erase(unique(Range(a)), a.end())
#define Vec2(T, n, m, xs) vector<vector<T>> xs(n, vector<T>(m))
#define Sum(a) accumulate(Range(a), 0)
#define Cusum(T, xs, sxs) \
vector<T> sxs(xs.size() + 1); \
For(i, (int)xs.size()) sxs[i + 1] = sxs[i] + xs[i]
#define Cin(T, ...) \
T __VA_ARGS__; \
_cin(__VA_ARGS__)
#define Cins(T, n, xs) \
vector<T> xs(n); \
For(i, n) cin >> xs[i]
#define Cins2(T, n, xs, ys) \
vector<T> xs(n), ys(n); \
For(i, n) cin >> xs[i] >> ys[i]
#define Cins3(T, n, xs, ys, zs) \
vector<T> xs(n), ys(n), zs(n); \
For(i, n) cin >> xs[i] >> ys[i] >> zs[i]
#define Cinss(T, n, m, xs) \
Vec2(T, n, m, xs); \
For(i, n) For(j, m) cin >> xs[i][j]
#define Cinm(T, n, map) \
unordered_map<T, int> map; \
Rep(n) { \
Cin(T, x); \
map[x]++; \
}
#define Cout(...) _cout(__VA_ARGS__)
#define Couts(xs) \
for (const auto &e : xs) \
cout << e << " "; \
cout << "\n"
#define Coutyn(cond) Cout((cond) ? "yes" : "no")
#define CoutYn(cond) Cout((cond) ? "Yes" : "No")
#define CoutYN(cond) Cout((cond) ? "YES" : "NO")
// constexpr int MOD = 1e9+7;
int main(void) {
Cin(int, n, m);
int l = 1, r = n;
Rep(m) {
Cin(int, a, b);
l = max(l, a);
r = min(r, b);
}
Cout(max(r - l + 1, 0));
} | [
"call.arguments.add"
] | 851,454 | 851,455 | u375405838 | cpp |
p03037 | #include <iostream>
using namespace std;
int main() {
int n, m;
int lmax, rmin;
int l, r;
int i;
cin >> n >> m;
cin >> l >> r;
lmax = l;
rmin = r;
for (i = 1; i < m; i++) {
cin >> l >> r;
if (lmax < l)
lmax = l;
if (r < rmin)
rmin = r;
}
if (lmax < rmin)
i = rmin - lmax + 1;
else
i = 0;
cout << i;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int n, m;
int lmax, rmin;
int l, r;
int i;
cin >> n >> m;
cin >> l >> r;
lmax = l;
rmin = r;
for (i = 1; i < m; i++) {
cin >> l >> r;
if (lmax < l)
lmax = l;
if (r < rmin)
rmin = r;
}
if (lmax <= rmin)
i = rmin - lmax + 1;
else
i = 0;
cout << i;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 851,474 | 851,475 | u417817281 | cpp |
p03037 | #include <iostream>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int L[100000], R[100000];
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i];
}
int a = 0, b = 0;
for (int i = 0; i < M; i++) {
if (i == 0) {
a = L[i];
b = R[i];
} else {
if (a <= L[i]) {
if (b <= R[i]) {
a = L[i];
} else {
b = R[i];
a = L[i];
}
} else {
if (b <= R[i]) {
} else {
b = R[i];
}
}
}
}
cout << b - a + 1 << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int L[100000], R[100000];
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i];
}
int a = 0, b = 0;
for (int i = 0; i < M; i++) {
if (i == 0) {
a = L[i];
b = R[i];
} else {
if (a <= L[i]) {
if (b <= R[i]) {
a = L[i];
} else {
b = R[i];
a = L[i];
}
} else {
if (b <= R[i]) {
} else {
b = R[i];
}
}
}
}
cout << max(0, b - a + 1) << endl;
return 0;
} | [
"call.add",
"call.arguments.change"
] | 851,476 | 851,477 | u367177642 | cpp |
p03037 | #include <algorithm>
#include <iostream>
using namespace std;
int N, M, L, R;
int l, r;
int main() {
cin >> N >> M;
l = 1, r = N;
bool zero = false;
while (M--) {
cin >> L >> R;
if (zero)
continue;
if (r < L || l > R) {
zero = true;
continue;
}
l = max(l, L);
r = min(r, R);
}
cout << zero ? 0 : r - l + 1;
} | #include <algorithm>
#include <iostream>
using namespace std;
int N, M, L, R;
int l, r;
int main() {
cin >> N >> M;
l = 1, r = N;
bool zero = false;
while (M--) {
cin >> L >> R;
if (zero)
continue;
if (r < L || l > R) {
zero = true;
continue;
}
l = max(l, L);
r = min(r, R);
}
cout << (zero ? 0 : r - l + 1);
} | [] | 851,499 | 851,500 | u416526752 | cpp |
p03037 | #include <algorithm>
#include <iostream>
using namespace std;
int N, M, L, R;
int l, r;
int main() {
cin >> N >> M;
l = 1, r = N;
bool zero = false;
while (M--) {
cin >> L >> R;
if (zero)
continue;
if (r < L) {
zero = true;
continue;
}
l = max(l, L);
r = min(r, R);
}
cout << zero ? 0 : r - l + 1;
} | #include <algorithm>
#include <iostream>
using namespace std;
int N, M, L, R;
int l, r;
int main() {
cin >> N >> M;
l = 1, r = N;
bool zero = false;
while (M--) {
cin >> L >> R;
if (zero)
continue;
if (r < L || l > R) {
zero = true;
continue;
}
l = max(l, L);
r = min(r, R);
}
cout << (zero ? 0 : r - l + 1);
} | [
"control_flow.branch.if.condition.change"
] | 851,501 | 851,500 | u416526752 | cpp |
p03037 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> l(M);
vector<int> r(M);
for (int i = 0; i < M; i++)
cin >> l[i] >> r[i];
int ma = l[0];
int mi = r[0];
for (int i = 1; i < M; i++) {
ma = max(l[i], ma);
mi = min(r[i], mi);
}
int ans = mi - ma + 1;
cout << ans << endl;
} | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> l(M);
vector<int> r(M);
for (int i = 0; i < M; i++)
cin >> l[i] >> r[i];
int ma = l[0];
int mi = r[0];
for (int i = 1; i < M; i++) {
ma = max(l[i], ma);
mi = min(r[i], mi);
}
int ans = max(mi - ma + 1, 0);
cout << ans << endl;
}
| [
"call.add",
"call.arguments.add"
] | 851,508 | 851,509 | u640827947 | cpp |
p03037 | // Author: Rahul Purohit
#include <bits/stdc++.h>
#define vi vector<int>
#define rep(i, a, b) for (ll i = a; i < b; ++i)
#define ll long long int
#define pi pair<ll, ll>
#define f first
#define mp make_pair
#define mod 1000000007
#define s second
#define pb push_back
#define mp make_pair
using namespace std;
int gcd(int a, int b) {
if (b == 0)
return a;
else
return (b, a % b);
}
/*ll isp[N]={1};
void sieve(int n)
{
isp[0]=isp[1]=0;
for(int i=2;i<=n;i++)
{
if(isp[i]==1)
{
for(int j=i*i;j<=n;j+=i)
{
isp[j]==0;
}
}
}
}*/
ll pow(int x, int y, int m) {
ll ans = 1;
while (y != 0) {
if (y % 2 == 1) {
ans = (ans * x) % m;
}
x = (x * x) % m;
y /= 2;
}
return ans;
}
template <class x> void swap(x &a, x &b) {
x tp;
tp = a;
a = b;
b = tp;
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll n, m;
cin >> n >> m;
ll l, r, l1 = -1, r1 = n + 1;
for (auto i = 0; i < m; ++i) {
cin >> l >> r;
l1 = max(l, l1);
r1 = min(r, r1);
}
if (l1 < r1)
cout << r1 - l1 + 1;
else
cout << "0\n";
return 0;
}
| // Author: Rahul Purohit
#include <bits/stdc++.h>
#define vi vector<int>
#define rep(i, a, b) for (ll i = a; i < b; ++i)
#define ll long long int
#define pi pair<ll, ll>
#define f first
#define mp make_pair
#define mod 1000000007
#define s second
#define pb push_back
#define mp make_pair
using namespace std;
int gcd(int a, int b) {
if (b == 0)
return a;
else
return (b, a % b);
}
/*ll isp[N]={1};
void sieve(int n)
{
isp[0]=isp[1]=0;
for(int i=2;i<=n;i++)
{
if(isp[i]==1)
{
for(int j=i*i;j<=n;j+=i)
{
isp[j]==0;
}
}
}
}*/
ll pow(int x, int y, int m) {
ll ans = 1;
while (y != 0) {
if (y % 2 == 1) {
ans = (ans * x) % m;
}
x = (x * x) % m;
y /= 2;
}
return ans;
}
template <class x> void swap(x &a, x &b) {
x tp;
tp = a;
a = b;
b = tp;
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll n, m;
cin >> n >> m;
ll l, r, l1 = -1, r1 = n + 1;
for (auto i = 0; i < m; ++i) {
cin >> l >> r;
l1 = max(l, l1);
r1 = min(r, r1);
}
if (l1 <= r1)
cout << r1 - l1 + 1;
else
cout << "0\n";
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 851,510 | 851,511 | u707655771 | cpp |
p03037 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <iostream>
#include <math.h>
#include <string>
#include <utility>
#include <vector>
#define INF 1000000000;
using namespace std;
int points[100009];
int allp;
pair<int, int> gate;
vector<int> counto;
int main() {
int n = 0, m = 0;
cin >> n >> m;
int ama = 0;
int bmi = INF;
for (int i = 0; i < m; i++) {
cin >> gate.first >> gate.second;
ama = max(ama, gate.first);
bmi = min(bmi, gate.second);
}
if (bmi - ama <= 0) {
cout << '0' << endl;
} else {
cout << bmi - ama << endl;
}
return 0;
} | #include <algorithm>
#include <cassert>
#include <cmath>
#include <iostream>
#include <math.h>
#include <string>
#include <utility>
#include <vector>
#define INF 1000000000;
using namespace std;
int points[100009];
int allp;
pair<int, int> gate;
vector<int> counto;
int main() {
int n = 0, m = 0;
cin >> n >> m;
int ama = 0;
int bmi = INF;
for (int i = 0; i < m; i++) {
cin >> gate.first >> gate.second;
ama = max(ama, gate.first);
bmi = min(bmi, gate.second);
}
if (bmi - ama + 1 <= 0) {
cout << '0' << endl;
} else {
cout << bmi - ama + 1 << endl;
}
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 851,518 | 851,519 | u019465635 | cpp |
p03037 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> L(m);
vector<int> R(m);
for (int i = 0; i < m; i++) {
cin >> L[i] >> R[i];
}
cout << min(0, (*min_element(R.begin(), R.end()) -
*max_element(L.begin(), L.end()) + 1))
<< endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> L(m);
vector<int> R(m);
for (int i = 0; i < m; i++) {
cin >> L[i] >> R[i];
}
cout << max(0, (*min_element(R.begin(), R.end()) -
*max_element(L.begin(), L.end()) + 1))
<< endl;
return 0;
} | [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 851,526 | 851,527 | u382176401 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int lb = 0, ub = n;
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
lb = max(lb, l);
ub = min(ub, r + 1);
}
cout << max(ub - lb, 0) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int lb = 0, ub = n;
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
l--;
lb = max(lb, l);
ub = min(ub, r);
}
cout << max(ub - lb, 0) << endl;
return 0;
} | [
"expression.unary.arithmetic.add",
"expression.operation.binary.remove"
] | 851,541 | 851,542 | u283229916 | cpp |
p03037 | #include <iostream>
using namespace std;
int main(void) {
int n, m;
cin >> n >> m;
int l[m], r[m];
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
if (i > 0) {
l[0] = max(l[i], l[0]);
r[0] = min(r[i], r[0]);
}
}
int distance;
distance = (r[0] > l[0]) ? (r[0] - l[0] + 1) : 0;
cout << distance << endl;
return 0;
} | #include <iostream>
using namespace std;
int main(void) {
int n, m;
cin >> n >> m;
int l[m], r[m];
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
if (i > 0) {
l[0] = max(l[i], l[0]);
r[0] = min(r[i], r[0]);
}
}
int distance;
distance = (r[0] >= l[0]) ? (r[0] - l[0] + 1) : 0;
cout << distance << endl;
return 0;
} | [
"expression.operator.compare.change",
"assignment.value.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 851,543 | 851,544 | u360765331 | cpp |
p03037 | //
// main.cpp
// prison
//
// Created by Dong Truong on 5/28/19.
// Copyright © 2019 Dong Truong. All rights reserved.
//
#include <algorithm>
#include <fstream>
#include <iostream>
#include <stdio.h>
using namespace std;
#define maxn 1000001
struct elem {
int l, r;
};
int n, m;
elem a[maxn];
bool cmp(elem a, elem b) { return (a.l < b.l); }
void nhap() {
cin >> n >> m;
for (int i = 1; i <= m; ++i)
cin >> a[i].l >> a[i].r;
sort(a + 1, a + m + 1, cmp);
}
void sol() {
int left = a[1].l, right = a[1].r;
for (int i = 2; i <= m; ++i) {
left = max(left, a[i].l);
right = min(right, a[i].r);
}
if (left > right)
cout << 0;
cout << min(right - left + 1, n);
}
int main(int argc, const char *argv[]) {
// insert code here...
// std::cout << "Hello, World!\n";
// freopen("a.inp","r",stdin);
nhap();
sol();
return 0;
}
| //
// main.cpp
// prison
//
// Created by Dong Truong on 5/28/19.
// Copyright © 2019 Dong Truong. All rights reserved.
//
#include <algorithm>
#include <fstream>
#include <iostream>
#include <stdio.h>
using namespace std;
#define maxn 1000001
struct elem {
int l, r;
};
int n, m;
elem a[maxn];
bool cmp(elem a, elem b) { return (a.l < b.l); }
void nhap() {
cin >> n >> m;
for (int i = 1; i <= m; ++i)
cin >> a[i].l >> a[i].r;
sort(a + 1, a + m + 1, cmp);
}
void sol() {
int left = a[1].l, right = a[1].r;
for (int i = 2; i <= m; ++i) {
left = max(left, a[i].l);
right = min(right, a[i].r);
}
if (left > right)
cout << 0;
else
cout << min(right - left + 1, n);
}
int main(int argc, const char *argv[]) {
// insert code here...
// std::cout << "Hello, World!\n";
// freopen("a.inp","r",stdin);
nhap();
sol();
return 0;
}
| [
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add"
] | 851,551 | 851,552 | u293313826 | cpp |
p03037 | #include <iostream>
#include <stdio.h>
using namespace std;
const int N = 1e5 + 5;
int a[N], b[N];
int L, R, n, m;
int pointer[N];
void enter() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a[i], &b[i]);
pointer[a[i]]++;
}
}
void qsort(int l, int r, int a[], int b[]) {
int i = l, j = r, x = a[(l + r) / 2];
while (i <= j) {
while (a[i] < x)
i++;
while (x < a[j])
j--;
if (i <= j) {
swap(a[i], a[j]);
swap(b[i], b[j]);
i++;
j--;
}
}
if (l < j)
qsort(l, j, a, b);
if (i < r)
qsort(i, r, a, b);
}
void prepa() {
qsort(1, m, a, b);
for (int i = 1; i <= m; i += pointer[a[i]]) {
int temp = pointer[a[i]];
qsort(i, i + temp - 1, b, a);
}
}
void solve() {
L = a[1], R = b[1];
for (int i = 2; i <= m; i++) {
L = max(a[i], L);
R = min(b[i], R);
}
printf("%d", R - L + 1);
}
int main() {
enter();
prepa();
solve();
return 0;
}
| #include <iostream>
#include <stdio.h>
using namespace std;
const int N = 1e5 + 5;
int a[N], b[N];
int L, R, n, m;
int pointer[N];
void enter() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a[i], &b[i]);
pointer[a[i]]++;
}
}
void qsort(int l, int r, int a[], int b[]) {
int i = l, j = r, x = a[(l + r) / 2];
while (i <= j) {
while (a[i] < x)
i++;
while (x < a[j])
j--;
if (i <= j) {
swap(a[i], a[j]);
swap(b[i], b[j]);
i++;
j--;
}
}
if (l < j)
qsort(l, j, a, b);
if (i < r)
qsort(i, r, a, b);
}
void prepa() {
qsort(1, m, a, b);
for (int i = 1; i <= m; i += pointer[a[i]]) {
int temp = pointer[a[i]];
qsort(i, i + temp - 1, b, a);
}
}
void solve() {
L = a[1], R = b[1];
for (int i = 2; i <= m; i++) {
L = max(a[i], L);
R = min(b[i], R);
}
printf("%d", max(R - L + 1, 0));
}
int main() {
enter();
prepa();
solve();
return 0;
}
| [
"call.add",
"call.arguments.add"
] | 851,553 | 851,554 | u287877771 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int N, M;
int L, R;
int ans = 0;
int main() {
cin >> N >> M;
vector<int> le(M + 1);
vector<int> ri(M + 1);
for (int i = 0; i < M; i++) {
cin >> le.at(i) >> ri.at(i);
}
L = le.at(0);
R = ri.at(0);
for (int i = 1; i < M; i++) {
// if(ri.at(i)>=L || le.at(i)<=R){
if (L < le.at(i)) {
L = le.at(i);
}
if (R > ri.at(i)) {
R = ri.at(i);
}
}
// }
if (L < R) {
ans = R - L + 1;
}
cout << ans;
}
| #include <bits/stdc++.h>
using namespace std;
int N, M;
int L, R;
int ans = 0;
int main() {
cin >> N >> M;
vector<int> le(M + 1);
vector<int> ri(M + 1);
for (int i = 0; i < M; i++) {
cin >> le.at(i) >> ri.at(i);
}
L = le.at(0);
R = ri.at(0);
for (int i = 1; i < M; i++) {
// if(ri.at(i)>=L || le.at(i)<=R){
if (L < le.at(i)) {
L = le.at(i);
}
if (R > ri.at(i)) {
R = ri.at(i);
}
}
// }
if (L <= R) {
ans = R - L + 1;
}
cout << ans;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 851,555 | 851,556 | u955422652 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int N, M;
int L, R;
int ans = 0;
int main() {
cin >> N >> M;
vector<int> le(M + 1);
vector<int> ri(M + 1);
for (int i = 0; i < M; i++) {
cin >> le.at(i) >> ri.at(i);
}
L = le.at(0);
R = ri.at(0);
for (int i = 1; i < M; i++) {
// if(ri.at(i)>=L || le.at(i)<=R){
if (L < le.at(i)) {
L = le.at(i);
}
if (R > ri.at(i)) {
R = ri.at(i);
}
}
// }
if (L < R) {
ans = R - L + 1;
}
cout << ans;
}
| #include <bits/stdc++.h>
using namespace std;
int N, M;
int L, R;
int ans = 0;
int main() {
cin >> N >> M;
vector<int> le(M + 1);
vector<int> ri(M + 1);
for (int i = 0; i < M; i++) {
cin >> le.at(i) >> ri.at(i);
}
L = le.at(0);
R = ri.at(0);
for (int i = 1; i < M; i++) {
// if(ri.at(i)>=L || le.at(i)<=R){
if (L < le.at(i)) {
L = le.at(i);
}
if (R > ri.at(i)) {
R = ri.at(i);
}
}
// }
if (L <= R) {
ans = R - L + 1;
}
cout << ans;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 851,555 | 851,558 | u955422652 | cpp |
p03037 | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
for (int i = 0; i < M; ++i) {
cin >> L[i] >> R[i];
}
sort(L.rbegin(), L.rend());
sort(R.begin(), R.end());
cout << 1 + R[0] - L[0] << endl;
} | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
for (int i = 0; i < M; ++i) {
cin >> L[i] >> R[i];
}
sort(L.rbegin(), L.rend());
sort(R.begin(), R.end());
cout << max(1 + R[0] - L[0], 0) << endl;
} | [
"call.add",
"call.arguments.add"
] | 851,568 | 851,569 | u976560086 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
using ll = long long;
int u, v, k, d, c, n, m, dp[N][19], ans[N], tc;
pair<int, int> a[N];
int main() {
scanf("%d%d", &n, &m);
int l = 1, r = n;
for (int i = 0; i < m; i++) {
scanf("%d%d", &a[i].first, &a[i].second);
l = max(a[i].first, l);
r = min(a[i].second, r);
}
printf("%d\n", r - l + 1);
}
| #include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
using ll = long long;
int u, v, k, d, c, n, m, dp[N][19], ans[N], tc;
pair<int, int> a[N];
int main() {
scanf("%d%d", &n, &m);
int l = 1, r = n;
for (int i = 0; i < m; i++) {
scanf("%d%d", &a[i].first, &a[i].second);
l = max(a[i].first, l);
r = min(a[i].second, r);
}
printf("%d\n", max(r - l + 1, 0));
}
| [
"call.add",
"call.arguments.add"
] | 851,572 | 851,573 | u318875010 | cpp |
p03037 | #pragma GCC optimize(3, "Ofast", "inline")
#include <bits/stdc++.h>
#if __cplusplus >= 201103L
#include <chrono>
using namespace std::chrono;
#endif
using namespace std;
#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define pb push_back
#define fi first
#define se second
#ifdef LOCAL
#define prln(x) (cout << #x << ' ' << x << endl)
#define pr(x) (cout << #x << ' ' << x << ' ')
#define prv(x) (cout << x << ' ')
#else
#define prln(x)
#define pr(x)
#define prv(x)
#endif
#define clr(x) memset((x), 0, sizeof((x)))
#define clr1(x) memset((x), -1, sizeof((x)))
#define endl "\n"
#define pi acos(-1)
#define rep(i, st, ed) for (int i = (st); i <= (ed); ++i)
#define rep0(i, st, ed) for (int i = (st); i < (ed); ++i)
#define per(i, st, ed) for (int i = (st); i >= ed; --i)
template <class T> void _sf(T &x) { cin >> x; }
void _sf(int &x) { scanf("%d", &x); }
void _sf(ll &x) { scanf("%lld", &x); }
void _sf(double &x) { scanf("%lf", &x); }
void _sf(char &x) { scanf(" %c", &x); }
void _sf(char *x) { scanf("%s", x); }
void sf() {}
template <class T, class... U> void sf(T &head, U &...tail) {
_sf(head);
sf(tail...);
}
const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-')
f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int main() {
#ifdef LOCAL
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
#if __cplusplus >= 201103L
auto start = steady_clock::now();
#endif
#endif
int n = read(), m = read();
int l = 0, r = n;
while (m--) {
int a = read(), b = read();
l = max(l, a);
r = min(r, b);
}
if (r >= l) {
cout << r - l << endl;
} else
cout << 0 << endl;
#ifdef LOCAL
#if __cplusplus >= 201103L
auto end = steady_clock::now();
duration<double> time_span = duration_cast<duration<double>>(end - start);
;
printf("Total time: %.6fs\n", time_span.count());
#endif
#endif
return 0;
} | #pragma GCC optimize(3, "Ofast", "inline")
#include <bits/stdc++.h>
#if __cplusplus >= 201103L
#include <chrono>
using namespace std::chrono;
#endif
using namespace std;
#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define pb push_back
#define fi first
#define se second
#ifdef LOCAL
#define prln(x) (cout << #x << ' ' << x << endl)
#define pr(x) (cout << #x << ' ' << x << ' ')
#define prv(x) (cout << x << ' ')
#else
#define prln(x)
#define pr(x)
#define prv(x)
#endif
#define clr(x) memset((x), 0, sizeof((x)))
#define clr1(x) memset((x), -1, sizeof((x)))
#define endl "\n"
#define pi acos(-1)
#define rep(i, st, ed) for (int i = (st); i <= (ed); ++i)
#define rep0(i, st, ed) for (int i = (st); i < (ed); ++i)
#define per(i, st, ed) for (int i = (st); i >= ed; --i)
template <class T> void _sf(T &x) { cin >> x; }
void _sf(int &x) { scanf("%d", &x); }
void _sf(ll &x) { scanf("%lld", &x); }
void _sf(double &x) { scanf("%lf", &x); }
void _sf(char &x) { scanf(" %c", &x); }
void _sf(char *x) { scanf("%s", x); }
void sf() {}
template <class T, class... U> void sf(T &head, U &...tail) {
_sf(head);
sf(tail...);
}
const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-')
f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int main() {
#ifdef LOCAL
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
#if __cplusplus >= 201103L
auto start = steady_clock::now();
#endif
#endif
int n = read(), m = read();
int l = 0, r = n;
while (m--) {
int a = read(), b = read();
l = max(l, a);
r = min(r, b);
}
if (r >= l) {
cout << r - l + 1 << endl;
} else
cout << 0 << endl;
#ifdef LOCAL
#if __cplusplus >= 201103L
auto end = steady_clock::now();
duration<double> time_span = duration_cast<duration<double>>(end - start);
;
printf("Total time: %.6fs\n", time_span.count());
#endif
#endif
return 0;
} | [
"expression.operation.binary.add"
] | 851,577 | 851,578 | u625893557 | cpp |
p03037 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> left, right;
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
left.push_back(l);
right.push_back(r);
}
sort(left.rbegin(), left.rend());
sort(right.begin(), right.end());
if (right.at(0) <= left.at(0))
cout << right.at(0) - left.at(0) + 1 << endl;
else
cout << 0 << endl;
}
| #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> left, right;
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
left.push_back(l);
right.push_back(r);
}
sort(left.rbegin(), left.rend());
sort(right.begin(), right.end());
if (left.at(0) <= right.at(0))
cout << right.at(0) - left.at(0) + 1 << endl;
else
cout << 0 << endl;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 851,588 | 851,589 | u479371430 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int l[m], r[m];
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
}
cout << *min_element(r, r + m) - *max_element(l, l + m) + 1 << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int l[m], r[m];
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
}
cout << max(*min_element(r, r + m) - *max_element(l, l + m) + 1, 0) << endl;
return 0;
} | [
"call.add",
"call.arguments.add"
] | 851,596 | 851,597 | u336130820 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
vector<int> xx, yy;
const int maxn = 1e5 + 7;
struct q {
int x, y;
} N[maxn];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
xx.push_back(x);
yy.push_back(y);
}
sort(xx.begin(), xx.end());
sort(yy.begin(), yy.end());
cout << -xx[m - 1] + yy[0] + 1 << endl;
} | #include <bits/stdc++.h>
using namespace std;
vector<int> xx, yy;
const int maxn = 1e5 + 7;
struct q {
int x, y;
} N[maxn];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
xx.push_back(x);
yy.push_back(y);
}
sort(xx.begin(), xx.end());
sort(yy.begin(), yy.end());
cout << max(-xx[m - 1] + yy[0] + 1, 0) << endl;
} | [
"call.add",
"call.arguments.add"
] | 851,628 | 851,629 | u491404948 | cpp |
p03037 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
#define REP(i, limit) for (int i = 0; i < limit; ++i)
#define FOR(i, j, limit) for (int i = j; i < limit; ++i)
#define DUMP(a) \
REP(d, a.size()) { \
cout << a[d]; \
if (d != a.size() - 1) \
cout << " "; \
else \
cout << endl; \
}
#define ECHO(x) cout << x << endl;
#define LL long long
int INF = 2147483647;
LL LINF = 9223372036854775807;
LL MOD = 1000000007;
typedef pair<int, int> P;
typedef pair<LL, LL> PL;
typedef vector<int> vi;
typedef vector<LL> vl;
int main() {
int n, m;
cin >> n >> m;
int lin, rin;
int lmax = 1, rmin = n;
REP(i, m) {
cin >> lin >> rin;
lmax = max(lmax, lin);
rmin = min(rmin, rin);
}
cout << (rmin - lmax + 1) << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
#define REP(i, limit) for (int i = 0; i < limit; ++i)
#define FOR(i, j, limit) for (int i = j; i < limit; ++i)
#define DUMP(a) \
REP(d, a.size()) { \
cout << a[d]; \
if (d != a.size() - 1) \
cout << " "; \
else \
cout << endl; \
}
#define ECHO(x) cout << x << endl;
#define LL long long
int INF = 2147483647;
LL LINF = 9223372036854775807;
LL MOD = 1000000007;
typedef pair<int, int> P;
typedef pair<LL, LL> PL;
typedef vector<int> vi;
typedef vector<LL> vl;
int main() {
int n, m;
cin >> n >> m;
int lin, rin;
int lmax = 1, rmin = n;
REP(i, m) {
cin >> lin >> rin;
lmax = max(lmax, lin);
rmin = min(rmin, rin);
}
cout << max(0, rmin - lmax + 1) << endl;
return 0;
}
| [
"call.add",
"call.arguments.add"
] | 851,634 | 851,635 | u111742294 | cpp |
p03037 | #include <bits/stdc++.h>
#define int long long
using namespace std;
// typedef
//------------------------------------------
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef vector<bool> VB;
typedef vector<PII> VP;
// REPEAT
//------------------------------------------
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define RFOR(i, m, n) for (int i = m; i > n; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, m) RFOR(i, m, 0)
// container util
//------------------------------------------
#define pb(a) push_back(a)
#define fst first
#define snd second
#define SORT(V) sort((V).begin(), (V).end())
#define REV(V) reverse((V).begin(), (V).end())
// constant
//------------------------------------------
const int MOD = 1000000007;
const int INF = 1061109567;
const double EPS = 1e-10;
const double PI = acos(-1.0);
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
// grobal variable
//------------------------------------------
// def function, class
//------------------------------------------
// main
//------------------------------------------
signed main() {
int N, M;
cin >> N >> M;
int gate[M + 10][2];
REP(i, M) cin >> gate[i][0] >> gate[i][1];
int lgate = 1, rgate = N;
REP(i, M) {
if (lgate < gate[i][0])
lgate = gate[i][0];
if (rgate > gate[i][1])
rgate = gate[i][1];
}
if (rgate == lgate) {
cout << 0 << endl;
} else {
cout << rgate - lgate + 1 << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define int long long
using namespace std;
// typedef
//------------------------------------------
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef vector<bool> VB;
typedef vector<PII> VP;
// REPEAT
//------------------------------------------
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define RFOR(i, m, n) for (int i = m; i > n; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, m) RFOR(i, m, 0)
// container util
//------------------------------------------
#define pb(a) push_back(a)
#define fst first
#define snd second
#define SORT(V) sort((V).begin(), (V).end())
#define REV(V) reverse((V).begin(), (V).end())
// constant
//------------------------------------------
const int MOD = 1000000007;
const int INF = 1061109567;
const double EPS = 1e-10;
const double PI = acos(-1.0);
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
// grobal variable
//------------------------------------------
// def function, class
//------------------------------------------
// main
//------------------------------------------
signed main() {
int N, M;
cin >> N >> M;
int gate[M + 10][2];
REP(i, M) cin >> gate[i][0] >> gate[i][1];
int lgate = 1, rgate = N;
REP(i, M) {
if (lgate < gate[i][0])
lgate = gate[i][0];
if (rgate > gate[i][1])
rgate = gate[i][1];
}
if (lgate > rgate) {
cout << 0 << endl;
} else {
cout << rgate - lgate + 1 << endl;
}
return 0;
}
| [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 851,638 | 851,639 | u055131803 | cpp |
p03037 | #include <bits/stdc++.h>
#define int long long
using namespace std;
// typedef
//------------------------------------------
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef vector<bool> VB;
typedef vector<PII> VP;
// REPEAT
//------------------------------------------
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define RFOR(i, m, n) for (int i = m; i > n; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, m) RFOR(i, m, 0)
// container util
//------------------------------------------
#define pb(a) push_back(a)
#define fst first
#define snd second
#define SORT(V) sort((V).begin(), (V).end())
#define REV(V) reverse((V).begin(), (V).end())
// constant
//------------------------------------------
const int MOD = 1000000007;
const int INF = 1061109567;
const double EPS = 1e-10;
const double PI = acos(-1.0);
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
// grobal variable
//------------------------------------------
// def function, class
//------------------------------------------
// main
//------------------------------------------
signed main() {
int N, M;
cin >> N >> M;
int gate[M + 10][1];
REP(i, M) cin >> gate[i][0] >> gate[i][1];
int lgate = 1, rgate = N;
REP(i, M) {
if (lgate < gate[i][0])
lgate = gate[i][0];
if (rgate > gate[i][1])
rgate = gate[i][1];
}
if (rgate == lgate) {
cout << 0 << endl;
} else {
cout << rgate - lgate + 1 << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define int long long
using namespace std;
// typedef
//------------------------------------------
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef vector<bool> VB;
typedef vector<PII> VP;
// REPEAT
//------------------------------------------
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define RFOR(i, m, n) for (int i = m; i > n; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, m) RFOR(i, m, 0)
// container util
//------------------------------------------
#define pb(a) push_back(a)
#define fst first
#define snd second
#define SORT(V) sort((V).begin(), (V).end())
#define REV(V) reverse((V).begin(), (V).end())
// constant
//------------------------------------------
const int MOD = 1000000007;
const int INF = 1061109567;
const double EPS = 1e-10;
const double PI = acos(-1.0);
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
// grobal variable
//------------------------------------------
// def function, class
//------------------------------------------
// main
//------------------------------------------
signed main() {
int N, M;
cin >> N >> M;
int gate[M + 10][2];
REP(i, M) cin >> gate[i][0] >> gate[i][1];
int lgate = 1, rgate = N;
REP(i, M) {
if (lgate < gate[i][0])
lgate = gate[i][0];
if (rgate > gate[i][1])
rgate = gate[i][1];
}
if (lgate > rgate) {
cout << 0 << endl;
} else {
cout << rgate - lgate + 1 << endl;
}
return 0;
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 851,640 | 851,639 | u055131803 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
int n, m, l, r, a, b, i;
cin >> n >> m;
a = 0, b = n + 1;
for (i = 0; i < m; i++) {
cin >> l >> r;
a = max(a, l);
b = min(b, r);
}
if (b >= a)
cout << b - a << endl;
else
cout << 0 << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
int n, m, l, r, a, b, i;
cin >> n >> m;
a = 0, b = n + 1;
for (i = 0; i < m; i++) {
cin >> l >> r;
a = max(a, l);
b = min(b, r);
}
if (b >= a)
cout << b - a + 1 << endl;
else
cout << 0 << endl;
} | [
"expression.operation.binary.add"
] | 851,641 | 851,642 | u388528458 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define el '\n'
#define MOD 1000000007
int n, m;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
int lmax = -1;
int rmin = 1000000000;
while (m--) {
int a, b;
cin >> a >> b;
lmax = max(lmax, a);
rmin = min(rmin, b);
}
int res;
if (lmax < rmin) {
res = 0;
} else {
res = rmin - lmax + 1;
}
cout << res << el;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define el '\n'
#define MOD 1000000007
int n, m;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
int lmax = -1;
int rmin = 1000000000;
while (m--) {
int a, b;
cin >> a >> b;
lmax = max(lmax, a);
rmin = min(rmin, b);
}
int res;
if (rmin < lmax) {
res = 0;
} else {
res = rmin - lmax + 1;
}
cout << res << el;
return 0;
} | [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 851,643 | 851,644 | u673706514 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int s[m][2];
for (int i = 0; i < m; i++) {
for (int j = 0; j < 2; j++) {
cin >> s[i][j];
}
}
int minimum = INT_MAX;
int maximum = 1;
for (int i = 0; i < m; i++) {
minimum = min(s[i][1], minimum);
maximum = max(s[i][0], maximum);
}
int ans = minimum - maximum + 1;
if (ans > n) {
cout << n << endl;
} else {
cout << ans << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int s[m][2];
for (int i = 0; i < m; i++) {
for (int j = 0; j < 2; j++) {
cin >> s[i][j];
}
}
int minimum = INT_MAX;
int maximum = 1;
for (int i = 0; i < m; i++) {
minimum = min(s[i][1], minimum);
maximum = max(s[i][0], maximum);
}
int ans = minimum - maximum + 1;
if (ans < 0) {
cout << 0 << endl;
} else {
cout << ans << endl;
}
} | [
"identifier.replace.remove",
"literal.replace.add",
"io.output.change"
] | 851,649 | 851,650 | u489117389 | cpp |
p03037 | // https://atcoder.jp/contests/abc127/tasks/abc127_c
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
#define INF (1e9)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOREACH(x, a) for (auto &(x) : (a))
#define ALL(obj) (obj).begin(), (obj).end()
#define ALLR(obj) (obj).rbegin(), (obj).rend()
// int gcd(long a, long b) { return b ? gcd(b, a % b) : a; }
// int lcm(long a, long b) { return a * b / gcd(a, b); }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n, m, l, r, ansmin = 0, ansmax = INF;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> l >> r;
ansmin = max(ansmin, l);
ansmax = min(ansmax, r);
}
cout << ansmax - ansmin + 1 << endl;
return 0;
} | // https://atcoder.jp/contests/abc127/tasks/abc127_c
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
#define INF (1e9)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOREACH(x, a) for (auto &(x) : (a))
#define ALL(obj) (obj).begin(), (obj).end()
#define ALLR(obj) (obj).rbegin(), (obj).rend()
// int gcd(long a, long b) { return b ? gcd(b, a % b) : a; }
// int lcm(long a, long b) { return a * b / gcd(a, b); }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n, m, l, r, ansmin = 0, ansmax = INF;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> l >> r;
ansmin = max(ansmin, l);
ansmax = min(ansmax, r);
}
cout << max(0LL, ansmax - ansmin + 1) << endl;
return 0;
} | [
"call.add",
"call.arguments.change"
] | 851,651 | 851,652 | u858107870 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int r = n;
int l = 0;
int R = 0;
int L = n;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
l = max(l, x);
r = min(r, y);
L = min(L, x);
R = max(R, y);
}
cout << (R - L > 0 && r - l >= 0 ? r - l + 1 : 0) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int r = n;
int l = 0;
int R = 0;
int L = n;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
l = max(l, x);
r = min(r, y);
L = min(L, x);
R = max(R, y);
}
cout << (R - L >= 0 && r - l >= 0 ? r - l + 1 : 0) << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"io.output.change"
] | 851,659 | 851,660 | u881647420 | cpp |
p03037 | #include <algorithm>
#include <stdio.h>
#define BUF 200002
#define LIM_N 100001
char str[BUF];
int N, M;
int L[LIM_N];
int R[LIM_N];
void receive_input() {
fgets(str, sizeof(str), stdin);
sscanf(str, "%d %d", &N, &M);
for (size_t i = 0; i < M; i++) {
scanf("%d %d", &L[i], &R[i]);
}
}
int solve() {
int l = 1, r = N;
for (size_t i = 0; i < M; i++) {
r = r > R[i] ? R[i] : r;
l = l < L[i] ? L[i] : l;
}
int ans = r - l + 1;
return ans;
}
int main(void) {
receive_input();
// solve();
printf("%d\n", solve());
return 0;
}
| #include <algorithm>
#include <stdio.h>
#define BUF 200002
#define LIM_N 100001
char str[BUF];
int N, M;
int L[LIM_N];
int R[LIM_N];
void receive_input() {
fgets(str, sizeof(str), stdin);
sscanf(str, "%d %d", &N, &M);
for (size_t i = 0; i < M; i++) {
scanf("%d %d", &L[i], &R[i]);
}
}
int solve() {
int l = 1, r = N;
for (size_t i = 0; i < M; i++) {
r = r > R[i] ? R[i] : r;
l = l < L[i] ? L[i] : l;
}
int ans = r - l + 1;
return 0 < ans ? ans : 0;
}
int main(void) {
receive_input();
// solve();
printf("%d\n", solve());
return 0;
}
| [
"expression.operation.binary.add"
] | 851,661 | 851,662 | u869153175 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, i, n, m, max = 0, min = 100000;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> a;
if (a < min) {
min = a;
}
cin >> a;
if (a > max) {
max = a;
}
}
if (max - min > 0) {
cout << 0;
} else {
cout << max - min + 1;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, i, n, m, max = 1000000, min = 0;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> a;
if (a > min) {
min = a;
}
cin >> a;
if (a < max) {
max = a;
}
}
if (max - min < 0) {
cout << 0;
} else {
cout << max - min + 1;
}
} | [
"literal.number.change",
"variable_declaration.value.change",
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 851,663 | 851,664 | u016726316 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, i, n, m, max = 1000000, min = 0;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> a;
if (a > min) {
min = a;
}
cin >> a;
if (a < max) {
max = a;
}
}
if (max - min < 0) {
cout << 0;
} else {
cout << max - min;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, i, n, m, max = 1000000, min = 0;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> a;
if (a > min) {
min = a;
}
cin >> a;
if (a < max) {
max = a;
}
}
if (max - min < 0) {
cout << 0;
} else {
cout << max - min + 1;
}
} | [
"expression.operation.binary.add"
] | 851,665 | 851,664 | u016726316 | cpp |
p03037 | #include <bits/stdc++.h>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
int L_max = 1;
int R_min = N;
int ans = 0;
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i];
L_max = max(L_max, L[i]);
R_min = min(R_min, R[i]);
}
if (L_max >= R_min) {
ans = 0;
} else {
ans = R_min - (L_max - 1);
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
int L_max = 1;
int R_min = N;
int ans = 0;
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i];
L_max = max(L_max, L[i]);
R_min = min(R_min, R[i]);
}
if (L_max > R_min) {
ans = 0;
} else {
ans = R_min - (L_max - 1);
}
cout << ans << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 851,675 | 851,676 | u774910314 | cpp |
p03037 | #include <bits/stdc++.h>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
int L_max = 1;
int R_min = N;
int ans = 0;
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i];
L_max = max(L_max, L[i]);
R_min = min(R_min, R[i]);
}
if (L_max >= R_min) {
ans = 0;
} else {
ans = R_min - L_max;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
int L_max = 1;
int R_min = N;
int ans = 0;
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i];
L_max = max(L_max, L[i]);
R_min = min(R_min, R[i]);
}
if (L_max > R_min) {
ans = 0;
} else {
ans = R_min - (L_max - 1);
}
cout << ans << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 851,677 | 851,676 | u774910314 | cpp |
p03037 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
// #include <numeric>
using namespace std;
typedef unsigned long ul;
typedef unsigned long long ull;
typedef long long ll;
typedef vector<ll> vint;
typedef vector<vector<ll>> vvint;
typedef vector<string> vstring;
typedef vector<vector<string>> vvstring;
typedef vector<char> vchar;
typedef vector<vector<char>> vvchar;
typedef vector<long double> vdouble;
typedef vector<vector<long double>> vvdouble;
typedef vector<vector<vector<long double>>> vvvdouble;
typedef pair<ll, ll> pint;
typedef vector<pint> vpint;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define repf(i, f, n) for (ll i = f; i < n; i++)
#define repr(i, n) for (ll i = n - 1; i >= 0; i--)
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define pf push_front
#define fi first
#define se second
#define INT_MAX 2147483647
#define LLONG_MAX 9223372036854775807
#define vmax(vec) *max_element(vec.begin(), vec.end())
#define vmin(vec) *min_element(vec.begin(), vec.end())
#define vsort(vec) sort(vec.begin(), vec.end())
#define vsortgr(vec) sort(vec.begin(), vec.end(), greater<ll>())
#define DIVIDER 1000000007
//
// struct Node{
// vint children;
// ll index;
// ll prop;
// };
int dy[] = {0, 0, 1, -1};
int dx[] = {
1,
-1,
0,
0,
};
// ll X,Y,Z,K;
// ll pmax = 30000000000;
// vint A,B,C;
// int binary_search(int key){
// //isOKを満たす要素のうち最小のインデックスを返す。（要ソート）
// int left = -1;
// int right = N;
//
// while(right - left > 1){
// int mid = left + (right - left)/2;
//
// if(isOK(mid, key)) right=mid;
// else left=mid;
// }
//
// return right;
// }
// ll gcd(ll m, ll n){
// if(m<n) swap(m,n);
// if(n==0) return m;
// return gcd(n, m%n);
// }
// ll get_pow(ll x, ll y){
// ll ret=0;
// ll temp = y;
// while(true){
// if(x<=temp) break;
// ret++;
// temp *= 2;
// }
// return ret;
// }
int main() {
cout << fixed << setprecision(10);
ll N, M;
cin >> N >> M;
vint L(M), R(M);
rep(i, M) cin >> L[i] >> R[i];
ll ans = 0;
ll left = 1;
ll right = N;
rep(i, M) {
left = max(left, L[i]);
right = min(right, R[i]);
}
ans = right - left + 1;
cout << ans << endl;
}
//
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
// #include <numeric>
using namespace std;
typedef unsigned long ul;
typedef unsigned long long ull;
typedef long long ll;
typedef vector<ll> vint;
typedef vector<vector<ll>> vvint;
typedef vector<string> vstring;
typedef vector<vector<string>> vvstring;
typedef vector<char> vchar;
typedef vector<vector<char>> vvchar;
typedef vector<long double> vdouble;
typedef vector<vector<long double>> vvdouble;
typedef vector<vector<vector<long double>>> vvvdouble;
typedef pair<ll, ll> pint;
typedef vector<pint> vpint;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define repf(i, f, n) for (ll i = f; i < n; i++)
#define repr(i, n) for (ll i = n - 1; i >= 0; i--)
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define pf push_front
#define fi first
#define se second
#define INT_MAX 2147483647
#define LLONG_MAX 9223372036854775807
#define vmax(vec) *max_element(vec.begin(), vec.end())
#define vmin(vec) *min_element(vec.begin(), vec.end())
#define vsort(vec) sort(vec.begin(), vec.end())
#define vsortgr(vec) sort(vec.begin(), vec.end(), greater<ll>())
#define DIVIDER 1000000007
//
// struct Node{
// vint children;
// ll index;
// ll prop;
// };
int dy[] = {0, 0, 1, -1};
int dx[] = {
1,
-1,
0,
0,
};
// ll X,Y,Z,K;
// ll pmax = 30000000000;
// vint A,B,C;
// int binary_search(int key){
// //isOKを満たす要素のうち最小のインデックスを返す。（要ソート）
// int left = -1;
// int right = N;
//
// while(right - left > 1){
// int mid = left + (right - left)/2;
//
// if(isOK(mid, key)) right=mid;
// else left=mid;
// }
//
// return right;
// }
// ll gcd(ll m, ll n){
// if(m<n) swap(m,n);
// if(n==0) return m;
// return gcd(n, m%n);
// }
// ll get_pow(ll x, ll y){
// ll ret=0;
// ll temp = y;
// while(true){
// if(x<=temp) break;
// ret++;
// temp *= 2;
// }
// return ret;
// }
int main() {
cout << fixed << setprecision(10);
ll N, M;
cin >> N >> M;
vint L(M), R(M);
rep(i, M) cin >> L[i] >> R[i];
ll ans = 0;
ll left = 1;
ll right = N;
rep(i, M) {
left = max(left, L[i]);
right = min(right, R[i]);
}
ans = max(right - left + 1, 0ll);
cout << ans << endl;
}
//
| [
"call.add",
"call.arguments.add"
] | 851,688 | 851,689 | u644070128 | cpp |
p03037 | #include <algorithm>
#include <iostream>
using namespace std;
int N, M;
int l[100005], r[100005];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N >> M;
for (int i = 0; i < M; i++) {
cin >> l[i] >> r[i];
}
int ans = 0;
sort(l, l + M);
sort(r, r + M);
if (l[0] <= r[0])
ans = r[0] - l[M - 1] + 1;
cout << ans << endl;
} | #include <algorithm>
#include <iostream>
using namespace std;
int N, M;
int l[100005], r[100005];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N >> M;
for (int i = 0; i < M; i++) {
cin >> l[i] >> r[i];
}
int ans = 0;
sort(l, l + M);
sort(r, r + M);
if (l[M - 1] <= r[0])
ans = r[0] - l[M - 1] + 1;
cout << ans << endl;
} | [
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 851,697 | 851,698 | u525137785 | cpp |
p03037 | #include <bits/stdc++.h>
#define Rint register int
using namespace std;
int n, m, l, r;
int main() {
scanf("%d%d", &n, &m);
l = 1;
r = n;
for (Rint i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
l = max(x, l);
r = min(y, r);
}
printf("%d\n", r - l + 1);
} | #include <bits/stdc++.h>
#define Rint register int
using namespace std;
int n, m, l, r;
int main() {
scanf("%d%d", &n, &m);
l = 1;
r = n;
for (Rint i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
l = max(x, l);
r = min(y, r);
}
printf("%d\n", max(r - l + 1, 0));
} | [
"call.add",
"call.arguments.add"
] | 851,699 | 851,700 | u680164084 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-')
f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - 48;
ch = getchar();
}
return x * f;
}
int main() {
int n = read(), m = read();
int l = 1, r = n;
while (m--) {
int u = read(), v = read();
l = max(l, u);
r = min(r, v);
}
int ans;
if (l >= r)
ans = 0;
else
ans = r - l + 1;
printf("%d\n", ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-')
f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - 48;
ch = getchar();
}
return x * f;
}
int main() {
int n = read(), m = read();
int l = 1, r = n;
while (m--) {
int u = read(), v = read();
l = max(l, u);
r = min(r, v);
}
int ans;
if (l > r)
ans = 0;
else
ans = r - l + 1;
printf("%d\n", ans);
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 851,701 | 851,702 | u855248478 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define endl '\n'
#define fcin \
ios::sync_with_stdio(false); \
cin.tie(nullptr);
#define inf 0x3f3f3f3f
const int N = 1e5 + 5;
int L[N], R[N];
int main() {
fcin;
int n, m;
cin >> n >> m;
int l = 1, r = n;
for (int i = 0; i < m; i++) {
cin >> L[i] >> R[i];
l = max(l, L[i]);
r = min(r, R[i]);
}
cout << r - l + 1;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define endl '\n'
#define fcin \
ios::sync_with_stdio(false); \
cin.tie(nullptr);
#define inf 0x3f3f3f3f
const int N = 1e5 + 5;
int L[N], R[N];
int main() {
fcin;
int n, m;
cin >> n >> m;
int l = 1, r = n;
for (int i = 0; i < m; i++) {
cin >> L[i] >> R[i];
l = max(l, L[i]);
r = min(r, R[i]);
}
cout << max(r - l + 1, 0);
return 0;
}
| [
"call.add",
"call.arguments.add"
] | 851,707 | 851,708 | u189873906 | cpp |
p03037 | #include <bits/stdc++.h>
#define For(i, a, b) for (int i = a; i <= b; i++)
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define sz(x) ((int)x.size())
#define int ll
using namespace std;
using ll = long long;
using pii = pair<int, int>;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
int lo = 0, hi = n + 1;
int l, r;
while (m--) {
cin >> l >> r;
lo = max(lo, l);
hi = min(hi, r);
}
cout << hi - lo + 1 << "\n";
return 0;
}
| #include <bits/stdc++.h>
#define For(i, a, b) for (int i = a; i <= b; i++)
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define sz(x) ((int)x.size())
#define int ll
using namespace std;
using ll = long long;
using pii = pair<int, int>;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
int lo = 0, hi = n + 1;
int l, r;
while (m--) {
cin >> l >> r;
lo = max(lo, l);
hi = min(hi, r);
}
cout << max(hi - lo + 1, 0ll) << "\n";
return 0;
}
| [
"call.add",
"call.arguments.add"
] | 851,732 | 851,733 | u055148700 | cpp |
p03037 | #include <iostream>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int l[m], r[m];
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
}
int lmax = l[0];
int rmin = r[0];
for (int i = 1; i < m; i++) {
if (lmax < l[i]) {
lmax = l[i];
}
if (rmin > r[i]) {
rmin = r[i];
}
}
cout << min(rmin - lmax + 1, n) << endl;
}
| #include <iostream>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int l[m], r[m];
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
}
int lmax = l[0];
int rmin = r[0];
for (int i = 1; i < m; i++) {
if (lmax < l[i]) {
lmax = l[i];
}
if (rmin > r[i]) {
rmin = r[i];
}
}
cout << max(rmin - lmax + 1, 0) << endl;
}
| [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change",
"identifier.replace.remove",
"literal.replace.add"
] | 851,734 | 851,735 | u815060106 | cpp |
p03037 | #include <iostream>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int l[m], r[m];
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
}
int lmax = l[0];
int rmin = r[0];
for (int i = 1; i < m; i++) {
if (lmax < l[i]) {
lmax = l[i];
}
if (rmin > r[i]) {
rmin = r[i];
}
}
cout << rmin - lmax + 1 << endl;
}
| #include <iostream>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int l[m], r[m];
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
}
int lmax = l[0];
int rmin = r[0];
for (int i = 1; i < m; i++) {
if (lmax < l[i]) {
lmax = l[i];
}
if (rmin > r[i]) {
rmin = r[i];
}
}
cout << max(rmin - lmax + 1, 0) << endl;
}
| [
"call.add",
"call.arguments.add"
] | 851,736 | 851,735 | u815060106 | cpp |
p03037 | #include <iostream>
using namespace std;
int main() {
int N, M;
int l, r;
int l_max, r_min;
cin >> N >> M;
cin >> l_max >> r_min;
for (int i = 1; i < M; i++) {
cin >> l >> r;
if (l > l_max)
l_max = l;
if (r < r_min)
r_min = r;
}
if (r_min < l_max) {
cout << r_min - l_max + 1 << endl;
} else {
cout << 0 << endl;
}
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int N, M;
int l, r;
int l_max, r_min;
cin >> N >> M;
cin >> l_max >> r_min;
for (int i = 1; i < M; i++) {
cin >> l >> r;
if (l > l_max)
l_max = l;
if (r < r_min)
r_min = r;
}
if (r_min >= l_max) {
cout << r_min - l_max + 1 << endl;
} else {
cout << 0 << endl;
}
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 851,739 | 851,740 | u081275802 | cpp |
p03037 | #include <iostream>
using namespace std;
int main() {
int N, M;
int l, r;
int l_max, r_min;
cin >> N >> M;
cin >> l_max >> r_min;
for (int i = 1; i < M; i++) {
cin >> l >> r;
if (l > l_max)
l_max = l;
if (r < r_min)
r_min = r;
}
if (r_min > l_max) {
cout << r_min - l_max + 1 << endl;
} else {
cout << 0 << endl;
}
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int N, M;
int l, r;
int l_max, r_min;
cin >> N >> M;
cin >> l_max >> r_min;
for (int i = 1; i < M; i++) {
cin >> l >> r;
if (l > l_max)
l_max = l;
if (r < r_min)
r_min = r;
}
if (r_min >= l_max) {
cout << r_min - l_max + 1 << endl;
} else {
cout << 0 << endl;
}
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 851,741 | 851,740 | u081275802 | cpp |
p03037 | #include <iostream>
int main() {
int n, m;
std::cin >> n >> m;
int l_max = 0, r_min = 1145141919810;
for (int i = 0; i < m; i++) {
int l_i, r_i;
std::cin >> l_i >> r_i;
l_max = std::max(l_max, l_i);
r_min = std::min(r_min, r_i);
}
if (r_min < l_max) {
std::cout << 0 << std::endl;
} else {
std::cout << r_min - l_max + 1 << std::endl;
}
} | #include <iostream>
int main() {
int n, m;
std::cin >> n >> m;
int l_max = 0, r_min = 10000000;
for (int i = 0; i < m; i++) {
int l_i, r_i;
std::cin >> l_i >> r_i;
l_max = std::max(l_max, l_i);
r_min = std::min(r_min, r_i);
}
if (r_min < l_max) {
std::cout << 0 << std::endl;
} else {
std::cout << r_min - l_max + 1 << std::endl;
}
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 851,744 | 851,745 | u675512317 | cpp |
p03037 | #include <iostream>
int main() {
int n, m;
std::cin >> n >> m;
int l_max = 0, r_min = 0;
for (int i = 0; i < m; i++) {
int l_i, r_i;
std::cin >> l_i >> r_i;
l_max = std::max(l_max, l_i);
r_min = std::min(r_min, r_i);
}
if (r_min < l_max) {
std::cout << 0 << std::endl;
} else {
std::cout << r_min - l_max + 1 << std::endl;
}
} | #include <iostream>
int main() {
int n, m;
std::cin >> n >> m;
int l_max = 0, r_min = 10000000;
for (int i = 0; i < m; i++) {
int l_i, r_i;
std::cin >> l_i >> r_i;
l_max = std::max(l_max, l_i);
r_min = std::min(r_min, r_i);
}
if (r_min < l_max) {
std::cout << 0 << std::endl;
} else {
std::cout << r_min - l_max + 1 << std::endl;
}
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 851,746 | 851,745 | u675512317 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, l, r, lmax, rmin, gen;
cin >> n >> m;
int i = 0;
cin >> lmax >> rmin;
for (int i = 1; i < m; i++) {
cin >> l >> r;
if (lmax < l)
lmax = l;
if (rmin > r)
rmin = r;
}
gen = rmin - lmax + 1;
if (l > r) {
cout << 0 << endl;
} else {
cout << gen << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, l, r, lmax, rmin, gen;
cin >> n >> m;
int i = 0;
cin >> lmax >> rmin;
for (int i = 1; i < m; i++) {
cin >> l >> r;
if (lmax < l)
lmax = l;
if (rmin > r)
rmin = r;
}
gen = rmin - lmax + 1;
if (lmax > rmin) {
cout << 0 << endl;
} else {
cout << gen << endl;
}
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 851,755 | 851,756 | u341980602 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, d = 0, mi = 1000001, ma = 0;
scanf("%d %d", &n, &m);
int l, r;
for (i = 1; i <= m; i++) {
scanf("%d %d", &l, &r);
if (l > ma) {
ma = l;
}
if (r < mi) {
mi = r;
}
}
d = abs(ma - mi) + 1;
if (d < 0) {
d = 0;
}
printf("%d", d);
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, d = 0, mi = 1000001, ma = 0;
scanf("%d %d", &n, &m);
int l, r;
for (i = 1; i <= m; i++) {
scanf("%d %d", &l, &r);
if (l > ma) {
ma = l;
}
if (r < mi) {
mi = r;
}
}
d = mi - ma + 1;
if (d < 0) {
d = 0;
}
printf("%d", d);
} | [
"call.remove",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 851,771 | 851,772 | u425970024 | cpp |
p03037 | #include <iostream>
using namespace std;
int main() {
int m, n;
cin >> m >> n;
int l, r;
int ans;
int max = n + 1;
int min = 1;
for (int j = 0; j < m; j++) {
cin >> l >> r;
if (min < l)
min = l;
if (max > r)
max = r;
}
ans = max - min + 1;
if (ans < 0)
ans = 0;
cout << ans << "\n";
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int m, n;
cin >> n >> m;
int l, r;
int ans;
int max = n;
int min = 1;
for (int j = 0; j < m; j++) {
cin >> l >> r;
if (min < l)
min = l;
if (max > r)
max = r;
}
ans = max - min + 1;
if (ans < 0)
ans = 0;
cout << ans << "\n";
return 0;
}
| [
"expression.operation.binary.remove"
] | 851,777 | 851,778 | u057617112 | cpp |
p03037 | #include <iostream>
using namespace std;
int main() {
int m, n;
cin >> m >> n;
int l, r;
int ans;
int max = n;
int min = 1;
for (int j = 0; j < m; j++) {
cin >> l >> r;
if (min < l)
min = l;
if (max > r)
max = r;
}
ans = max - min + 1;
if (ans < 0)
ans = 0;
cout << ans << "\n";
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int m, n;
cin >> n >> m;
int l, r;
int ans;
int max = n;
int min = 1;
for (int j = 0; j < m; j++) {
cin >> l >> r;
if (min < l)
min = l;
if (max > r)
max = r;
}
ans = max - min + 1;
if (ans < 0)
ans = 0;
cout << ans << "\n";
return 0;
}
| [
"expression.operation.binary.remove"
] | 851,779 | 851,778 | u057617112 | cpp |
p03037 | #include <algorithm>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define MOD (long long int)(1e9 + 7)
#define ll long long int
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define reps(i, n) for (int i = 1; i <= (int)(n); i++)
#define REP(i, n) for (int i = n - 1; i >= 0; i--)
#define REPS(i, n) for (int i = n; i > 0; i--)
#define INF (int)(1123456789)
#define LINF (long long int)(112345678901234567)
#define chmax(a, b) a = (((a) < (b)) ? (b) : (a))
#define chmin(a, b) a = (((a) > (b)) ? (b) : (a))
#define all(v) v.begin(), v.end()
int main(void) {
int n, m, l, r, ml, mr;
cin >> n >> m;
ml = 0;
mr = INF;
rep(i, m) {
cin >> l >> r;
chmax(ml, l);
chmin(mr, r);
}
cout << mr - ml + 1 << endl;
return 0;
}
| #include <algorithm>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define MOD (long long int)(1e9 + 7)
#define ll long long int
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define reps(i, n) for (int i = 1; i <= (int)(n); i++)
#define REP(i, n) for (int i = n - 1; i >= 0; i--)
#define REPS(i, n) for (int i = n; i > 0; i--)
#define INF (int)(1123456789)
#define LINF (long long int)(112345678901234567)
#define chmax(a, b) a = (((a) < (b)) ? (b) : (a))
#define chmin(a, b) a = (((a) > (b)) ? (b) : (a))
#define all(v) v.begin(), v.end()
int main(void) {
int n, m, l, r, ml, mr;
cin >> n >> m;
ml = 0;
mr = INF;
rep(i, m) {
cin >> l >> r;
chmax(ml, l);
chmin(mr, r);
}
cout << max(0, mr - ml + 1) << endl;
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 851,787 | 851,788 | u838742270 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
inline int_fast64_t read() {
int_fast64_t x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
f = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
x = x * 10 + c - '0', c = getchar();
return x * f;
}
inline string read_s() {
string s = "";
char c = getchar();
while (c < '!' || c > '~') {
c = getchar();
}
while (c >= '!' && c <= '~') {
s += c;
c = getchar();
}
return s;
}
void Main() {
int N = read(), M = read();
int L = 1, R = N;
for (int i = 0; i < M; i++) {
L = max(L, (int)read());
R = min(R, (int)read());
}
printf("%d\n", R - L + 1);
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
Main();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
inline int_fast64_t read() {
int_fast64_t x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
f = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
x = x * 10 + c - '0', c = getchar();
return x * f;
}
inline string read_s() {
string s = "";
char c = getchar();
while (c < '!' || c > '~') {
c = getchar();
}
while (c >= '!' && c <= '~') {
s += c;
c = getchar();
}
return s;
}
void Main() {
int N = read(), M = read();
int L = 1, R = N;
for (int i = 0; i < M; i++) {
L = max(L, (int)read());
R = min(R, (int)read());
}
printf("%d\n", max(R - L + 1, 0));
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
Main();
return 0;
} | [
"call.add",
"call.arguments.add"
] | 851,791 | 851,792 | u572532976 | cpp |
p03037 | #include <algorithm>
#include <iostream>
#include <numeric>
#include <stdio.h>
using namespace std;
int main(void) {
int n, m, ans = 0;
cin >> n >> m;
int l[m], r[m];
for (int i = 0; i < m; ++i)
scanf("%d %d", &l[i], &r[i]);
if (*min_element(r, r + m) - *max_element(l, l + m) + 1 >= 0)
ans = *min_element(r, r + m) - *max_element(l, l + m) + 1 >= 0;
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <numeric>
#include <stdio.h>
using namespace std;
int main(void) {
int n, m, ans = 0;
cin >> n >> m;
int l[m], r[m];
for (int i = 0; i < m; ++i)
scanf("%d %d", &l[i], &r[i]);
if (*min_element(r, r + m) - *max_element(l, l + m) + 1 >= 0)
ans = *min_element(r, r + m) - *max_element(l, l + m) + 1;
cout << ans << endl;
return 0;
} | [
"expression.operation.binary.remove"
] | 851,809 | 851,810 | u459317879 | cpp |
p03037 | #include <bits/stdc++.h>
#include <cstdio>
using namespace std;
using ll = long long;
int main() {
ll N, M;
cin >> N >> M;
ll L[100100], R[100100];
for (int i = 0; i < M; i++)
cin >> L[i] >> R[i];
ll *lmax = max_element(L, L + M);
ll *rmin = min_element(R, R + M);
ll res = 0;
if (*rmin - *lmax > 0) {
res = *rmin - *lmax + 1;
}
cout << res << "\n";
} | #include <bits/stdc++.h>
#include <cstdio>
using namespace std;
using ll = long long;
int main() {
ll N, M;
cin >> N >> M;
ll L[100100], R[100100];
for (int i = 0; i < M; i++)
cin >> L[i] >> R[i];
ll *lmax = max_element(L, L + M);
ll *rmin = min_element(R, R + M);
ll res = 0;
if (*rmin - *lmax >= 0) {
res = *rmin - *lmax + 1;
}
cout << res << "\n";
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 851,813 | 851,814 | u108648546 | cpp |
p03037 | #include <iostream>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int l_max = 0, r_min = n;
for (int j = 0; j < m; j++) {
int l, r;
cin >> l >> r;
if (l > l_max)
l_max = l;
if (r < r_min)
r_min = r;
}
if (l_max < r_min)
cout << 0 << endl;
else
cout << r_min - l_max + 1 << endl;
}
| #include <iostream>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int l_max = 0, r_min = n;
for (int j = 0; j < m; j++) {
int l, r;
cin >> l >> r;
if (l > l_max)
l_max = l;
if (r < r_min)
r_min = r;
}
if (l_max > r_min)
cout << 0 << endl;
else
cout << r_min - l_max + 1 << endl;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 851,829 | 851,830 | u927804708 | cpp |
p03037 | #include <cmath>
#include <iostream>
using namespace std;
// bool f[200000];
int main() {
int N, M;
cin >> N >> M;
int L[200000], R[200000];
int Lmax = 0, Rmin = 1e9;
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i];
Lmax = max(L[i], Lmax);
Rmin = min(R[i], Rmin);
}
cout << max(Rmin - Lmax, 0) << endl;
return 0;
} | #include <cmath>
#include <iostream>
using namespace std;
// bool f[200000];
int main() {
int N, M;
cin >> N >> M;
int L[200000], R[200000];
int Lmax = 0, Rmin = 1e9;
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i];
Lmax = max(L[i], Lmax);
Rmin = min(R[i], Rmin);
}
cout << max(Rmin - Lmax + 1, 0) << endl;
return 0;
} | [
"expression.operation.binary.add"
] | 851,839 | 851,840 | u100499821 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
#define lint long long
#define P pair<int, lint>
const lint INF = 1E15;
int main() {
int N, M;
cin >> N >> M;
int L[M], R[M];
int Min = 0, Max = 1000000;
for (int i = 0; i < M; ++i) {
cin >> L[i] >> R[i];
Min = max(Min, L[i]);
Max = min(Max, R[i]);
}
cout << Max - Min + 1 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define lint long long
#define P pair<int, lint>
const lint INF = 1E15;
int main() {
int N, M;
cin >> N >> M;
int L[M], R[M];
int Min = 0, Max = 1000000;
for (int i = 0; i < M; ++i) {
cin >> L[i] >> R[i];
Min = max(Min, L[i]);
Max = min(Max, R[i]);
}
cout << max(Max - Min + 1, 0) << endl;
}
| [
"call.add",
"call.arguments.add"
] | 851,847 | 851,848 | u432456012 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define all(V) V.begin, V.end
const int N = 100005;
int n, m;
const int inf = 1e9;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
int low = -1, high = inf;
while (m--) {
int l, r;
cin >> l >> r;
low = max(low, l);
high = min(high, r);
}
cout << high - low + 1;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define all(V) V.begin, V.end
const int N = 100005;
int n, m;
const int inf = 1e9;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
int low = -1, high = inf;
while (m--) {
int l, r;
cin >> l >> r;
low = max(low, l);
high = min(high, r);
}
cout << max(high - low + 1, 0);
} | [
"call.add",
"call.arguments.add"
] | 851,849 | 851,850 | u595786324 | cpp |
p03037 |
#if 1
#include <bits/stdc++.h>
using namespace std;
int l, r;
int n, m;
pair<int, int> a[100005];
int main() {
scanf("%d %d", &n, &m);
r = n + 1;
for (int i = 1; i <= m; i++) {
scanf("%d %d", &a[i].first, &a[i].second);
l = max(l, a[i].first);
r = min(r, a[i].second);
}
printf("%d", r - l + 1);
}
#endif // 1++
| #if 1
#include <bits/stdc++.h>
using namespace std;
int l, r;
int n, m;
pair<int, int> a[100005];
int main() {
scanf("%d %d", &n, &m);
r = n + 1;
for (int i = 1; i <= m; i++) {
scanf("%d %d", &a[i].first, &a[i].second);
l = max(l, a[i].first);
r = min(r, a[i].second);
}
printf("%d", max(r - l + 1, 0));
}
#endif // 1++ | [
"call.add",
"call.arguments.add"
] | 851,851 | 851,852 | u998677610 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M, L, R;
int Lmax = 0;
int Rmin = 1000000;
cin >> N >> M;
for (int i = 0; i < M; i++) {
cin >> L >> R;
if (L >= Lmax) {
Lmax = L;
}
if (R <= Rmin) {
Rmin = R;
}
}
if (Rmin > Lmax) {
cout << Rmin - Lmax + 1 << endl;
} else {
cout << "0" << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M, L, R;
int Lmax = 0;
int Rmin = 1000000;
cin >> N >> M;
for (int i = 0; i < M; i++) {
cin >> L >> R;
if (L >= Lmax) {
Lmax = L;
}
if (R <= Rmin) {
Rmin = R;
}
}
if (Rmin >= Lmax) {
cout << Rmin - Lmax + 1 << endl;
} else {
cout << "0" << endl;
}
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 851,866 | 851,867 | u218036413 | cpp |
p03037 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int L, R;
int left_end = 0, right_end = 10001;
for (int i = 0; i < M; i++) {
cin >> L >> R;
if (left_end < L)
left_end = L;
if (right_end > R)
right_end = R;
// cout << left_end << endl;
// cout << right_end << endl;
}
if (left_end <= right_end) {
cout << right_end - left_end + 1 << endl;
} else
cout << 0 << endl;
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int L, R;
int left_end = 0, right_end = N;
for (int i = 0; i < M; i++) {
cin >> L >> R;
if (left_end < L)
left_end = L;
if (right_end > R)
right_end = R;
// cout << left_end << endl;
// cout << right_end << endl;
}
if (left_end <= right_end) {
cout << right_end - left_end + 1 << endl;
} else
cout << 0 << endl;
return 0;
} | [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 851,868 | 851,869 | u929829215 | cpp |
p03037 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int L, R;
int left_end = 0, right_end = 10001;
for (int i = 0; i < M; i++) {
cin >> L >> R;
if (left_end > L)
left_end = L;
if (right_end < R)
right_end = R;
}
if (left_end <= right_end) {
cout << right_end - left_end + 1 << endl;
} else
cout << 0 << endl;
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int L, R;
int left_end = 0, right_end = N;
for (int i = 0; i < M; i++) {
cin >> L >> R;
if (left_end < L)
left_end = L;
if (right_end > R)
right_end = R;
// cout << left_end << endl;
// cout << right_end << endl;
}
if (left_end <= right_end) {
cout << right_end - left_end + 1 << endl;
} else
cout << 0 << endl;
return 0;
} | [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove",
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 851,870 | 851,869 | u929829215 | cpp |
p03037 |
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, M;
int min = 1000000;
int max = 1;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
int Ans = 0;
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i];
max = std::max(max, L[i]);
min = std::min(min, R[i]);
}
if (min > max) {
cout << 0 << endl;
} else {
cout << min - max + 1 << endl;
}
} |
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, M;
int min = 1000000;
int max = 1;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
int Ans = 0;
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i];
max = std::max(max, L[i]);
min = std::min(min, R[i]);
}
if (min < max) {
cout << 0 << endl;
} else {
cout << min - max + 1 << endl;
}
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 851,876 | 851,877 | u142946678 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int L, R;
int Lm = 1, Rm = N;
for (int i = 0; i < M; i++) {
cin >> L >> R;
Lm = max(Lm, L);
Rm = min(Rm, R);
}
cout << Rm - Lm + 1 << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int L, R;
int Lm = 1, Rm = N;
for (int i = 0; i < M; i++) {
cin >> L >> R;
Lm = max(Lm, L);
Rm = min(Rm, R);
}
cout << max(0, Rm - Lm + 1) << endl;
}
| [
"call.add",
"call.arguments.change"
] | 851,878 | 851,879 | u572077985 | cpp |
p03037 | #include "bits/stdc++.h"
using namespace std;
int N, M;
vector<int> L;
vector<int> R;
int main() {
cin >> N >> M;
for (int i = 1; i <= M; i++) {
int l, r;
cin >> l >> r;
L.emplace_back(l);
R.emplace_back(r);
}
int card_min = 1;
int card_max = N;
for (int i = 1; i <= M; i++) {
if (card_min < L[i - 1])
card_min = L[i - 1];
if (card_max > R[i - 1])
card_max = R[i - 1];
}
cout << card_max - card_min + 1 << endl;
return 0;
} | #include "bits/stdc++.h"
using namespace std;
int N, M;
vector<int> L;
vector<int> R;
int main() {
cin >> N >> M;
for (int i = 1; i <= M; i++) {
int l, r;
cin >> l >> r;
L.emplace_back(l);
R.emplace_back(r);
}
int card_min = 1;
int card_max = N;
for (int i = 1; i <= M; i++) {
if (card_min < L[i - 1])
card_min = L[i - 1];
if (card_max > R[i - 1])
card_max = R[i - 1];
}
cout << max(0, card_max - card_min + 1) << endl;
return 0;
} | [
"call.add",
"call.arguments.change"
] | 851,886 | 851,887 | u436976004 | cpp |
p03037 | #include <iostream>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int L, R, roop;
int maxL = 1, minR = N;
for (roop = 0; roop < M; roop++) {
cin >> L >> R;
if (maxL < L)
maxL = L;
if (minR > R)
minR = R;
}
int ans = minR - maxL + 1;
if (ans > 0)
ans = 0;
cout << ans << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int L, R, roop;
int maxL = 1, minR = N;
for (roop = 0; roop < M; roop++) {
cin >> L >> R;
if (maxL < L)
maxL = L;
if (minR > R)
minR = R;
}
int ans = minR - maxL + 1;
if (ans < 0)
ans = 0;
cout << ans << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 851,893 | 851,894 | u541263126 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;
template <class T> using VVV = V<VV<T>>;
template <class S, class T> using P = pair<S, T>;
template <class S, class T, class U> using TP = tuple<S, T, U>;
using ll = long long;
using ull = unsigned long long;
using dbl = double;
using str = string;
using vll = V<ll>;
using vvll = V<vll>;
using vvvll = V<vvll>;
using pl = P<ll, ll>;
using tl = TP<ll, ll, ll>;
using vpl = V<pl>;
using vvpl = V<vpl>;
using vtl = V<tl>;
using vvtl = V<vtl>;
using vs = V<str>;
using vvs = V<vs>;
using vd = V<dbl>;
using vvd = V<vd>;
using qll = queue<ll>;
using qpl = queue<pl>;
using stll = stack<ll>;
using stpl = stack<pl>;
using mapll = map<ll, ll>;
using setll = set<ll>;
using pqll = priority_queue<ll>;
#define int ll
#define fi first
#define se second
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define pob pop_back()
#define pf push_front
#define pof pop_front()
#define sz size()
#define bgn begin()
#define en end()
#define asn assign
#define emp empty()
#define fr front()
#define bk back()
#define clr clear()
#define ins insert
#define ers erase
#define res resize
#define tp top()
#define p_q priority_queue
#define inv inverse()
#define FOR(i, a, b) for (ll i = (a); i <= (ll)(b); i++)
#define rFOR(i, a, b) for (ll i = (b); i >= (ll)(a); i--)
#define REP(i, a) FOR((i), 0, (ll)(a)-1)
#define REP0(i, a) FOR((i), 0, (ll)(a))
#define REP1(i, a) FOR((i), 1, (ll)(a))
#define rREP(i, a) rFOR((i), 0, (ll)(a)-1)
#define rREP0(i, a) rFOR((i), 0, (ll)(a))
#define rREP1(i, a) rFOR((i), 1, (ll)(a))
#define ROR(v, i) for (auto &(i) : (v))
#define IOTA(a, n) iota((a).bgn, (a).en, (n))
#define SORT(a) sort((a).bgn, (a).en)
#define rSORT(a) sort((a).rbegin(), (a).rend())
#define UNIQUE(a) (a).erase(unique((a).bgn, (a).en), (a).en)
#define PREVP(a) prev_permutation((a).bgn, (a).en)
#define NEXTP(a) next_permutation((a).bgn, (a).en)
#define BINS(a, b) binary_search((a).bgn, (a).en, (b))
#define LOWB(a, b) (lower_bound((a).bgn, (a).en, (b)) - (a).bgn)
#define UPB(a, b) (upper_bound((a).bgn, (a).en, (b)) - (a).bgn)
#define CNT(a, b) count((a).bgn, (a).en, b)
#define SUM(a) accumulate((a).bgn, (a).en, 0)
#define REV(a) reverse((a).bgn, (a).en)
#define REGS(a, b) regex_search((a), regex(b))
#define REGM(a, b) regex_match((a), regex(b))
#define yn(a) cout << ((a) ? "yes" : "no") << "\n";
#define Yn(a) cout << ((a) ? "Yes" : "No") << "\n";
#define YN(a) cout << ((a) ? "YES" : "NO") << "\n";
#define imp(a) cout << ((a) ? "possible" : "impossible") << "\n";
#define Imp(a) cout << ((a) ? "Possible" : "Impossible") << "\n";
#define IMP(a) cout << ((a) ? "POSSIBLE" : "IMPOSSIBLE") << "\n";
#define fs(a) cout << ((a) ? "second" : "first") << "\n";
#define Fs(a) cout << ((a) ? "Second" : "First") << "\n";
#define FS(a) cout << ((a) ? "SECOND" : "FIRST") << "\n";
#define sak cout << "\n";
#define sas cout << " ";
#define sat cout << "\t";
#define dbg(a) cerr << (#a) << ": " << (a) << "\n";
#define dbgs(...) \
dal(#__VA_ARGS__); \
dal(__VA_ARGS__);
#define c2l(a) ((ll)(a - 48))
#define a2l(a) ((ll)(a - 97))
#define A2l(a) ((ll)(a - 65))
#define l2c(a) ((char)(a + 48))
#define l2a(a) ((char)(a + 97))
#define l2A(a) ((char)(a + 65))
#define DigN2(a) ((llabs(a) == 0) ? (1) : ((ll)(log2(double(llabs(a)))) + 1))
#define DigN10(a) ((llabs(a) == 0) ? (1) : ((ll)(log10(double(llabs(a)))) + 1))
#define Dig2(a, b) (((a) >> (b)) & 1)
#define Dig10(a, b) (ll)(((a) / ((ll)(pow(10.0, (double)(b))))) % 10)
#define Pow2(a) ((ll)(1) << (a))
#define Pow10(a) ((ll)(pow(10.0, double(a))))
#define LSB(a) ((a) & (-(a)))
#define vin(v) \
ROR((v), (i)) { cin >> (i); };
#define vllin(v, N) \
vll(v)((N)); \
vin(v);
#define vllin2(a, b, N) \
vll(a)(N), (b)(N); \
REP(i, N) { cin >> (a)[i] >> (b)[i]; };
#define vsin(v, N) \
vs(v)((N)); \
vin(v);
#define rdn(a, b) ((a) / (b))
#define rou(a, b) \
((((double(a) / double(b)) - ((a) / (b))) < 0.5) ? ((a) / (b)) \
: (((a) / (b)) + 1))
#define rup(a, b) ((((a) % (b)) == 0) ? ((a) / (b)) : (((a) / (b)) + 1))
#define min(...) Min(__VA_ARGS__)
#define max(...) Max(__VA_ARGS__)
#define emin(a, ...) ((a) = Min((a), __VA_ARGS__))
#define emax(a, ...) ((a) = Max((a), __VA_ARGS__))
#define egcd(a, ...) ((a) = gcd((a), __VA_ARGS__))
#define elcm(a, ...) ((a) = lcm((a), __VA_ARGS__))
#define powll(a, b) (ll)(pow((double)(a), (double)(b)))
#define Triangle(x1, y1, x2, y2, x3, y3) \
(((x1) - (x2)) * ((y1) - (y3)) - ((x1) - (x3)) * ((y1) - (y2)))
#define svll SumV<ll>
#define svvll SumV2<ll>
#define li(...) \
ll __VA_ARGS__; \
Input(__VA_ARGS__);
#define si(...) \
str __VA_ARGS__; \
Input(__VA_ARGS__);
#define vli(size, ...) \
vll __VA_ARGS__; \
vInput(size, __VA_ARGS__);
#define vsi(size, ...) \
vs __VA_ARGS__; \
vInput(size, __VA_ARGS__);
// const ll MOD = 1e9 + 7;
const ll MOD = 998244353;
// const ll MOD = 924844033;
// const ll MOD = 9007199254740881;
const ll INF = 1LL << 60; // 1.15e18
const double PI = acos(-1.0);
const vll DX = {0, -1, 0, 1, 0, -1, 1, 1, -1};
const vll DY = {0, 0, -1, 0, 1, -1, -1, 1, 1};
const str alp = "abcdefghijklmnopqrstuvwxyz";
const str ALP = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
void Input() {}
template <class Var, class... Args> void Input(Var &var, Args &...args) {
cin >> var;
Input(args...);
}
void vInit(ll size) {}
template <class T, class... Args> void vInit(ll size, V<T> &v, Args &...args) {
v.res(size);
vInit(size, args...);
}
void vInputNum(ll num) {}
template <class T, class... Args>
void vInputNum(ll num, V<T> &v, Args &...args) {
cin >> v[num];
vInputNum(num, args...);
}
void vInput(ll size) {}
template <class... Args> void vInput(ll size, Args &...args) {
vInit(size, args...);
REP(i, size) vInputNum(i, args...);
}
template <class S, class T>
ostream &operator<<(ostream &out, const P<S, T> &p) {
return out << "[" << p.fi << ", " << p.se << "]";
}
template <class T> ostream &operator<<(ostream &out, V<T> &v) {
if (v.emp)
return out << "{}";
else {
auto itr = v.bgn;
out << "{" << *itr;
itr++;
while (itr != v.en) {
out << ", " << *itr;
itr++;
}
out << "}";
return out;
}
}
template <class S, class T>
ostream &operator<<(ostream &out, const map<S, T> &m) {
if (m.emp)
return out << "<[]>";
else {
auto itr = m.bgn;
out << "< [" << (itr->fi) << ": " << (itr->se);
itr++;
while (itr != m.en) {
out << "], [" << (itr->fi) << ": " << (itr->se);
itr++;
}
out << "] >";
return out;
}
}
template <class T> ostream &operator<<(ostream &out, const set<T> &s) {
if (s.emp)
return out << "<>";
else {
auto itr = s.bgn;
out << "<" << *itr;
itr++;
while (itr != s.en) {
out << ", " << *itr;
itr++;
}
out << ">";
return out;
}
}
void say() {}
template <class T> void say(T t) { cout << t; }
template <class Head, class... Body> void say(Head head, Body... body) {
cout << head << " ";
say(body...);
}
void sal() { cout << "\n"; }
template <class... Args> void sal(Args... args) {
say(args...);
cout << "\n";
}
void day() {}
template <class T> void day(T t) { cerr << t; }
template <class Head, class... Body> void day(Head head, Body... body) {
cerr << head << " ";
day(body...);
}
void dal() { cerr << "\n"; }
template <class... Args> void dal(Args... args) {
day(args...);
cerr << "\n";
}
void salv() {}
template <class T> void salv(V<T> v) {
if (v.emp)
sal();
else {
auto itr = v.bgn;
say(*itr);
itr++;
while (itr != v.en) {
sas;
say(*itr);
itr++;
}
sak;
}
}
template <class T, class... Args> void salv(V<T> v, Args... args) {
salv(v);
salv(args...);
}
void salv2() {}
template <class T> void salv2(V<V<T>> v) {
if (v.emp)
sal();
else {
ROR(v, i) salv(i);
}
}
template <class T, class... Args> void salv2(V<V<T>> v, Args... args) {
salv2(v);
salv2(args...);
}
template <class Monoid> struct Action {
public:
Monoid I;
function<Monoid(Monoid, Monoid)> A;
Action(Monoid I, function<Monoid(Monoid, Monoid)> A) : I(I), A(A) {}
Monoid operator()() { return I; }
Monoid operator()(Monoid x) { return x; }
Monoid operator()(Monoid l, Monoid r) { return A(l, r); }
template <class... Args> Monoid operator()(Monoid x, Args... args) {
Monoid tmp = operator()(args...);
return A(x, tmp);
}
};
template <class T> Action<T> ADD = Action<T>(0, [](T l, T r) { return l + r; });
template <>
Action<str> ADD<str> = Action<str>("", [](str l, str r) { return l + r; });
template <class T1, class T2>
Action<P<T1, T2>> ADD<P<T1, T2>> =
Action<P<T1, T2>>(mp(ADD<T1>.I, ADD<T2>.I), [](P<T1, T2> l, P<T1, T2> r) {
return mp(l.fi + r.fi, l.se + r.se);
});
template <class T> Action<T> MUL = Action<T>(1, [](T l, T r) { return l * r; });
template <class T> Action<T> OR = Action<T>(0, [](T l, T r) { return l | r; });
template <class T> Action<T> XOR = Action<T>(0, [](T l, T r) { return l ^ r; });
template <class T>
Action<T> AND = Action<T>(((ll)(1) << 63) - 1, [](T l, T r) { return l & r; });
template <>
Action<bool> AND<bool> = Action<bool>(true,
[](bool l, bool r) { return l & r; });
template <>
Action<ull> AND<ull> = Action<ull>(((ull)(1) << 63) - 1,
[](ull l, ull r) { return l & r; });
template <class T>
Action<T> MIN = Action<T>(INF, [](T l, T r) { return (l < r) ? l : r; });
template <class T>
Action<T> MAX = Action<T>(-INF, [](T l, T r) { return (l > r) ? l : r; });
template <class T>
Action<T> GCD = Action<T>(0, [](T l, T r) {
if (l < r) {
l ^= r;
r ^= l;
l ^= r;
}
return (r ? GCD<T>(r, l % r) : l);
});
template <class T>
Action<T> LCM = Action<T>(1, [](T l, T r) { return (l * r) / GCD<T>(l, r); });
template <class Head> Head Min(Head head) { return head; }
template <class Head, class... Body> Head Min(Head head, Body... body) {
auto tmp = Min(body...);
return (head < tmp) ? head : tmp;
}
template <class Head> Head Max(Head head) { return head; }
template <class Head, class... Body> auto Max(Head head, Body... body) {
auto tmp = Max(body...);
return (head > tmp) ? head : tmp;
}
ll gcd(ll a, ll b) {
if (a < b) {
a ^= b;
b ^= a;
a ^= b;
}
return b ? gcd(b, a % b) : a;
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll gcd(ll head) { return head; }
template <class... Body> ll gcd(ll head, Body... body) {
return gcd(head, gcd(body...));
}
ll lcm(ll head) { return head; }
template <class... Body> ll lcm(ll head, Body... body) {
return lcm(head, lcm(body...));
}
ll Bset(ll a, ll b, ll c) {
if (c)
a |= b;
else
a &= ~b;
return a;
}
struct UFT {
public:
ll tsize;
ll mode;
vll par;
vll rank;
UFT() {}
UFT(const UFT &uft) {}
UFT(ll tsizeget, ll modeget = 0) {
tsize = tsizeget;
mode = modeget;
par.asn(tsize, -1);
if (!mode)
rank.res(tsize, 0);
}
ll root(ll x) { return par[x] < 0 ? x : par[x] = root(par[x]); }
bool isRoot(ll x) { return x == root(x); }
bool same(ll x, ll y) { return root(x) == root(y); }
void merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (mode) {
par[x] += par[y];
par[y] = x;
} else {
if (rank[x] < rank[y]) {
par[y] += par[x];
par[x] = y;
} else {
par[x] += par[y];
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
}
}
}
ll size(ll x) { return -par[root(x)]; }
};
struct pUFT {
public:
ll tsize;
ll now;
vll par;
vll rank;
vll mtime;
vvll sizepi;
vvll sizepv;
pUFT() {}
pUFT(const pUFT &puft) {}
pUFT(ll tsizeget) {
tsize = tsizeget;
now = 0;
par.asn(tsize, -1);
rank.asn(tsize, 0);
mtime.asn(tsize, INF);
sizepi.asn(tsize, {0});
sizepv.asn(tsize, {1});
}
ll root(ll x, ll t) { return (mtime[x] > t) ? x : root(par[x], t); }
bool same(ll x, ll y, ll t) { return root(x, t) == root(y, t); }
ll merge(ll x, ll y) {
now++;
x = root(x, now);
y = root(y, now);
if (x != y) {
if (rank[x] < rank[y]) {
par[y] += par[x];
sizepi[y].pb(now);
sizepv[y].pb(-par[y]);
par[x] = y;
mtime[x] = now;
} else {
par[x] += par[y];
sizepi[x].pb(now);
sizepv[x].pb(-par[x]);
par[y] = x;
mtime[y] = now;
if (rank[x] == rank[y])
rank[x]++;
}
}
return now;
}
ll size(ll x, ll t) {
x = root(x, t);
return sizepv[x][UPB(sizepi[x], t) - 1];
}
};
struct wUFT {
public:
ll tsize;
ll mode;
vll par;
vll rank;
vll dweight;
wUFT() {}
wUFT(const wUFT &wuft) {}
wUFT(ll tsizeget, ll modeget = 0) {
tsize = tsizeget;
mode = modeget;
par.asn(tsize, -1);
if (!mode)
rank.res(tsize, 0);
dweight.asn(tsize, 0);
}
ll root(ll x) {
if (par[x] < 0)
return x;
else {
ll r = root(par[x]);
dweight[x] += dweight[par[x]];
return par[x] = r;
}
}
ll weight(ll x) {
root(x);
return dweight[x];
}
ll diff(ll x, ll y) { return weight(y) - weight(x); }
bool isRoot(ll x) { return x == root(x); }
bool same(ll x, ll y) { return root(x) == root(y); }
void merge(ll x, ll y, ll w) {
w += weight(x);
w -= weight(y);
x = root(x);
y = root(y);
if (x == y)
return;
if (mode) {
par[x] += par[y];
par[y] = x;
} else {
if (rank[x] < rank[y]) {
par[y] += par[x];
par[x] = y;
dweight[x] = -w;
} else {
par[x] += par[y];
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
dweight[y] = w;
}
}
}
ll size(ll x) { return -par[root(x)]; }
};
template <typename valtype> class SegT {
public:
ll size;
vector<valtype> v;
valtype initv;
function<valtype(valtype x, valtype y)> calc;
SegT() {}
SegT(const SegT &segt) {}
SegT(ll sizeget, ll modeget = 0) {
sizeset(sizeget);
modeset(modeget);
init();
}
SegT(vector<valtype> cpyvec, ll modeget = 0) {
sizeset(cpyvec.sz);
modeset(modeget);
init();
copy(cpyvec);
}
SegT(ll sizeget, valtype initvget,
function<valtype(valtype x, valtype y)> calcget) {
sizeset(sizeget);
initv = initvget;
calc = calcget;
init();
}
SegT(vector<valtype> cpyvec, valtype initvget,
function<valtype(valtype x, valtype y)> calcget) {
sizeset(cpyvec.sz);
initv = initvget;
calc = calcget;
init();
copy(cpyvec);
}
void sizeset(ll rsize) {
size = DigN2(rsize);
if (rsize == Pow2(size - 1))
size--;
return;
}
void modeset(ll mode) {
switch (mode) {
case 0:
initv = 0;
calc = [](valtype x, valtype y) { return x + y; };
break;
case 1:
initv = INF;
calc = [](valtype x, valtype y) { return min(x, y); };
break;
case 2:
initv = -INF;
calc = [](valtype x, valtype y) { return max(x, y); };
break;
}
return;
}
void init() { v.asn(Pow2(size + 1) - 1, initv); }
void copy(vector<valtype> cpyvec) {
REP(i, min(cpyvec.sz, Pow2(size))) set(i, cpyvec[i]);
}
ll i2v(ll i) const {
if (i < 0 || i >= Pow2(size))
return -1;
return Pow2(size) + i - 1;
}
ll top(ll i) const {
if (i == 0)
return -1;
return (i - 1) / 2;
}
pl bot(ll i) const {
if (i + 1 >= Pow2(size))
return mp(-1, -1);
return mp(2 * i + 1, 2 * i + 2);
}
void set(ll i, valtype x) {
i = i2v(i);
v[i] = x;
while (i > 0) {
i = top(i);
v[i] = calc(v[bot(i).fi], v[bot(i).se]);
}
return;
}
void add(ll i, valtype x) {
set(i, v[i2v(i)] + x);
return;
}
valtype operator[](const ll &i) const { return v[i2v(i)]; }
// valtype que(ll a = 0, ll b = Pow2(size) - 1) {
valtype que(ll a, ll b) {
if (a == b)
return v[i2v(a)];
if (a > b)
return initv; // swap(a, b);
valtype ans = initv;
ll ai = i2v(a);
ll bi = i2v(b);
FOR(i, 1, size + 1) {
if (a > b)
break;
if (a % Pow2(i)) {
ans = calc(ans, v[ai]);
a += Pow2(i - 1);
ai = top(ai) + 1;
} else {
ai = top(ai);
}
if (a > b)
break;
if ((b + 1) % Pow2(i)) {
ans = calc(ans, v[bi]);
b -= Pow2(i - 1);
bi = top(bi) - 1;
} else {
bi = top(bi);
}
if (a > b)
break;
}
return ans;
}
valtype que(ll b) { return que(0, b); }
valtype que() { return que(0, Pow2(size) - 1); }
};
template <typename lentype> class Graph {
public:
ll size;
ll mode;
ll mapmode;
lentype zlen;
lentype ilen;
vector<map<ll, ll>> v2n;
vvll n2v;
vector<vector<lentype>> Edge;
vector<pair<lentype, ll>> Primresult;
Graph() {}
Graph(const Graph &graph) {}
Graph(ll sizeget = 0, ll mapmodeget = 0, ll modeget = 0, lentype zlenget = 0,
lentype ilenget = INF) {
size = sizeget;
mapmode = mapmodeget;
mode = modeget;
zlen = zlenget;
ilen = ilenget;
init();
}
void init() {
Edge.res(size);
v2n.res(size);
n2v.res(size);
Primresult.asn(size, mp(ilen, -1));
}
lentype lenplus(lentype l, lentype r) { return l + r; }
lentype lenequal(lentype l, lentype r) { return l == r; }
lentype lenlcr(lentype l, lentype r) { return l < r; }
ll addV(ll vs) {
size += vs;
init();
return size;
}
void caddE(ll x, ll y, lentype c) {
if (mapmode)
v2n[x][y] = Edge[x].sz;
Edge[x].pb(c);
n2v[x].pb(y);
}
void csetE(ll x, ll y, lentype c) {
if (mapmode)
Edge[x][v2n[x][y]] = c;
}
void cersE(ll x, ll y) {
if (mapmode) {
ll n = v2n[x][y];
Edge[x][n] = ilen;
n2v[x][n] = -1;
v2n[x].ers(y);
}
}
void addE(ll x, ll y, lentype c) {
caddE(x, y, c);
if (!mode)
caddE(y, x, c);
}
void setE(ll x, ll y, lentype c) {
csetE(x, y, c);
if (!mode)
csetE(y, x, c);
}
void ersE(ll x, ll y, lentype c) {
cersE(x, y, c);
if (!mode)
cersE(y, x, c);
}
lentype getE(ll x, ll y) {
if (mapmode) {
if (v2n[x].count(y)) {
return Edge[x][v2n[x][y]];
}
}
return ilen;
}
ll getVsz(ll x) { return Edge[x].sz; }
pair<lentype, ll> getV(ll x, ll n) {
if (n >= getVsz(x))
return mp(ilen, -1);
return mp(Edge[x][n], n2v[x][n]);
}
vector<pair<lentype, vll>> Dijk(ll x) {
vector<pair<lentype, vll>> result(size);
REP(i, size) {
result[i].fi = ilen;
result[i].se = {-1};
}
vll stat(size, 0);
pair<lentype, ll> now;
pair<lentype, ll> nowlv;
SegT<pair<lentype, ll>> Q(size, mp(ilen, -1),
[](pair<lentype, ll> l, pair<lentype, ll> r) {
if (l.se == -1)
return r;
if (r.se == -1)
return l;
return l.fi < r.fi ? l : r;
});
Q.set(x, mp(zlen, x));
result[x].fi = zlen;
result[x].se = {-1};
while (Q.que(0, size - 1).se != -1) {
now = Q.que(0, size - 1);
Q.set(now.se, mp(ilen, -1));
stat[now.se] = 1;
REP(i, getVsz(now.se)) {
nowlv = getV(now.se, i);
if (stat[nowlv.se])
continue;
if (Q[nowlv.se].se == -1) {
result[nowlv.se].fi = lenplus(result[now.se].fi, nowlv.fi);
result[nowlv.se].se = {now.se};
Q.set(nowlv.se, mp(result[nowlv.se].fi, nowlv.se));
} else {
if (lenlcr(lenplus(result[now.se].fi, nowlv.fi),
result[nowlv.se].fi)) {
result[nowlv.se].fi = lenplus(result[now.se].fi, nowlv.fi);
result[nowlv.se].se = {now.se};
Q.set(nowlv.se, mp(result[nowlv.se].fi, nowlv.se));
} else if (lenequal(lenplus(result[now.se].fi, nowlv.fi),
result[nowlv.se].fi)) {
result[nowlv.se].se.pb(now.se);
}
}
}
}
return result;
}
lentype Prim(ll x = 0) {
lentype ans = zlen;
vll stat(size, 0);
pair<lentype, ll> now;
pair<lentype, ll> nowlv;
SegT<pair<lentype, ll>> Q(size, mp(ilen, -1),
[](pair<lentype, ll> l, pair<lentype, ll> r) {
if (l.se == -1)
return r;
if (r.se == -1)
return l;
return l.fi < r.fi ? l : r;
});
Q.set(x, mp(zlen, x));
Primresult[x] = mp(zlen, -1);
while (Q.que(0, size - 1).se != -1) {
now = Q.que(0, size - 1);
Q.set(now.se, mp(ilen, -1));
stat[now.se] = 1;
ans = lenplus(ans, Primresult[now.se].fi);
REP(i, getVsz(now.se)) {
nowlv = getV(now.se, i);
if (stat[nowlv.se])
continue;
if (Q[nowlv.se].se == -1) {
Primresult[nowlv.se] = mp(nowlv.fi, now.se);
Q.set(nowlv.se, mp(Primresult[nowlv.se].fi, nowlv.se));
} else {
if (lenlcr(nowlv.fi, Primresult[nowlv.se].fi)) {
Primresult[nowlv.se] = mp(nowlv.fi, now.se);
Q.set(nowlv.se, mp(Primresult[nowlv.se].fi, nowlv.se));
}
}
}
}
return ans;
}
};
/*template <class Type> class DP {
public:
vector<Type> v;
Type initv;
vll size, block;
DP() {}
DP(const DP &dp) {}
template<class... Args> DP(Args... args) {
block.asn(1, 1);
Initialize(args...);
}
void Initialize(Type initv_) {
initv = initv_;
v.asn(block.bk, initv);
}
template<class... Args> void Initialize(ll val, Args... args) {
size.pb(val);
block.pb(block.bk*val);
Initialize(args...);
}
};*/
pl Bezout(ll a, ll b) {
if (b != 0) {
pl xy;
xy = Bezout(b, a % b);
return mp(xy.se, xy.fi - ((a / b) * xy.se));
} else {
return mp(1, 0);
}
}
pl Bez(ll a, ll b, ll c) {
pl xy;
ll x, y, z, gc;
xy = Bezout(a, b);
gc = gcd(a, b);
if (c % gc != 0)
return mp(-1, -1);
x = xy.fi * (c / gc);
y = xy.se * (c / gc);
if (x < 0)
z = rup(-x, (b / gc));
if (x >= 0)
z = -x / (b / gc);
x += z * (b / gc);
y -= z * (a / gc);
return mp(x, y);
}
ll DigS10(ll n) {
ll ans = 0;
while (1) {
ans += n % 10;
n /= 10;
if (!n)
break;
}
return ans;
}
ll isP(ll n) {
if (n <= 1)
return 0;
FOR(i, 2, (ll)sqrt(n) + 1) {
if (n % i == 0)
return 0;
}
return 1;
}
ll Tot(ll n) {
if (n <= 0)
return 0;
ll ans = n, x = 2;
while (x * x <= n) {
if (n % x == 0) {
ans -= ans / x;
while (n % x == 0)
n /= x;
}
x++;
}
if (n > 1)
ans -= ans / n;
return ans;
}
template <class T> struct Sum {
public:
V<T> v, s;
ll size;
Action<T> Add;
Sum(V<T> v, Action<T> Add = ADD<T>) : v(v), size(v.sz), Add(Add) {
Init();
Calc();
}
void Init() { s.asn(size + 1, Add.I); }
void Calc() { REP(i, size) s[i + 1] = Add(s[i], v[i]); }
T operator()(ll x) { return operator()(0, x); }
T operator()(ll l, ll r) {
if (l < 0)
l = 0;
if (r >= size)
r = size - 1;
if (l > r)
return Add.I;
return s[r + 1] - s[l]; // for ADD
}
};
using sumll = Sum<ll>;
template <class T> struct Sum2 {
public:
V<V<T>> v, s;
ll RowSize, ColumnSize;
Action<T> Add;
Sum2(V<V<T>> v, Action<T> Add = ADD<T>)
: v(v), RowSize(v.sz), ColumnSize(v.sz ? v[0].sz : 0), Add(Add) {
Init();
Calc();
}
void Init() { s.asn(RowSize + 1, V<T>(ColumnSize, Add.I)); }
void Calc() {
REP1(r, RowSize) {
REP1(c, ColumnSize) {
s[r][c] =
v[r - 1][c - 1] + operator()(r, c - 1) + operator()(r - 1, c) -
operator()(r - 1, c - 1);
}
}
}
T operator()(ll r, ll c) { return operator()(0, 0, r, c); }
T operator()(ll r1, ll c1, ll r2, ll c2) {
if (r1 < 0)
r1 = 0;
if (c1 < 0)
c1 = 0;
if (r2 >= RowSize)
r2 = RowSize - 1;
if (c2 >= ColumnSize)
c2 = ColumnSize - 1;
if (r1 > r2)
return Add.I;
if (c1 > c2)
return Add.I;
return s[r2 + 1][c2 + 1] - s[r2 + 1][c1] - s[r1][c2 + 1] + s[r1][c1];
}
};
using sum2ll = Sum2<ll>;
template <class T> struct Point2 {
public:
V<V<T>> v;
ll h, w;
Point2() : h(0), w(0) {}
Point2(ll h, ll w) : h(h), w(w) { asn(h, w); }
Point2(ll h, ll w, T val) : h(h), w(w) { asn(h, w, val); }
void assign(ll h, ll w) { v.asn(h, V<T>(w)); }
void assign(ll h, ll w, ll val) { v.asn(h, V<T>(w, val)); }
T &operator()(ll h, ll w) { return v[h][w]; }
T &operator()(pl p) { return v[p.fi][p.se]; }
};
template <class T> using P2 = Point2<T>;
template <ll Mod> struct Modll {
public:
ll v;
Modll() : v(0) {}
Modll(ll _v) { set(_v % Mod + Mod); }
Modll &set(ll _v) {
v = (_v < Mod) ? _v : (_v - Mod);
return *this;
}
Modll pow(ll n) const {
Modll x = *this, ans = 1;
while (n) {
if (n & 1)
ans *= x;
x *= x;
n >>= 1;
}
return ans;
}
Modll inverse() const { return (*this).pow(Mod - 2); }
Modll operator+(const Modll &m) const { return Modll().set(v + m.v); }
Modll operator-(const Modll &m) const { return Modll().set(Mod + v - m.v); }
Modll operator*(const Modll &m) const {
return Modll().set((ull(v) * m.v) % Mod);
}
Modll operator/(const Modll &m) const { return *this * m.inv; }
Modll &operator+=(const Modll &m) { return *this = *this + m; }
Modll &operator-=(const Modll &m) { return *this = *this - m; }
Modll &operator*=(const Modll &m) { return *this = *this * m; }
Modll &operator/=(const Modll &m) { return *this = *this / m; }
Modll operator-() const { return Modll(0) - *this; }
explicit operator bool() const { return v != 0; }
friend ostream &operator<<(ostream &out, const Modll &m) {
return out << m.v;
}
};
using mll = Modll<MOD>;
using vmll = V<mll>;
using vvmll = V<vmll>;
using vvvmll = V<vvmll>;
template <class T> T vmin(V<T> v) {
T tmp = MIN<T>.I;
ROR(v, i) emin(tmp, i);
return tmp;
}
template <class T, class... Args> T vmin(V<T> v, Args... args) {
T tmp = vmin(args...);
return min(vmin(v), tmp);
}
template <class T> T vmax(V<T> v) {
T tmp = MAX<T>.I;
ROR(v, i) emax(tmp, i);
return tmp;
}
template <class T, class... Args> T vmax(V<T> v, Args... args) {
T tmp = vmax(args...);
return max(vmax(v), tmp);
}
template <class T> T vgcd(V<T> v) {
T tmp = GCD<T>.I;
ROR(v, i) egcd(tmp, i);
return tmp;
}
template <class T, class... Args> T vgcd(V<T> v, Args... args) {
T tmp = vgcd(args...);
return gcd(vgcd(v), tmp);
}
template <class T> T vlcm(V<T> v) {
T tmp = LCM<T>.I;
ROR(v, i) elcm(tmp, i);
return tmp;
}
template <class T, class... Args> T vlcm(V<T> v, Args... args) {
T tmp = vlcm(args...);
return lcm(vlcm(v), tmp);
}
vmll MFactMemo(2, 1);
vmll MIFactMemo(2, 1);
mll mFact(ll n) {
if (MFactMemo.sz <= n) {
ll oldsize = MFactMemo.sz;
MFactMemo.res(n + 1, 1);
FOR(i, oldsize, n) MFactMemo[i] = MFactMemo[i - 1] * i;
}
return MFactMemo[n];
}
mll miFact(ll n) {
if (MIFactMemo.sz <= n) {
ll oldsize = MIFactMemo.sz;
MIFactMemo.res(n + 1, 1);
MIFactMemo.bk = mFact(n).inv;
rFOR(i, oldsize + 1, n) MIFactMemo[i - 1] = MIFactMemo[i] * i;
}
return MIFactMemo[n];
}
mll mComb(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
return mFact(n) * miFact(k) * miFact(n - k);
}
ll LIS(vll v, ll m = 0) {
if (v.sz > 0) {
ll ans = 0;
vll dp(v.sz, INF);
FOR(i, 0, v.sz - 1) { dp[m ? UPB(dp, v[i]) : LOWB(dp, v[i])] = v[i]; }
FOR(i, 0, v.sz - 1) {
if (dp[i] == INF)
break;
ans++;
}
return ans;
} else {
return 0;
}
}
void PCmprs(vll &v) {
if (v.sz == 0)
return;
vll vv(v);
IOTA(vv, 0);
sort(vv.bgn, vv.en, [&](ll v1, ll v2) { return v[v1] < v[v2]; });
IOTA(v, 0);
sort(v.bgn, v.en, [&](ll v1, ll v2) { return vv[v1] < vv[v2]; });
return;
}
ll BblCnt(vll v) {
PCmprs(v);
SegT<ll> b(v.sz, 0);
ll ans = 0;
REP(i, v.sz) {
ans += (i - b.que(0, v[i]));
b.add(v[i], 1);
}
return ans;
}
ll Bsrch(function<bool(ll x)> f, ll mi, ll ma) {
ll ng = mi - 1, ok = ma, mid;
while (ok - ng > 1) {
mid = (ng + ok) / 2;
(f(mid) ? ok : ng) = mid;
}
return ok;
}
template <class T>
V<V<T>> MultiMatrix(V<V<T>> A, V<V<T>> B, Action<T> Mul = MUL<T>,
Action<T> Add = ADD<T>) {
V<V<T>> ans;
ll ii = A.sz;
if (!ii)
return ans;
ll jj = A[0].sz;
if (!jj)
return ans;
ll jj2 = B.sz;
if (!jj2)
return ans;
if (jj != jj2)
return ans;
ll kk = B[0].sz;
if (!kk)
return ans;
ans.asn(ii, V<T>(kk, 0));
REP(i, ii) {
REP(k, kk) {
REP(j, jj) { ans[i][k] = Add(ans[i][k], Mul(A[i][j], B[j][k])); }
}
}
return ans;
}
vvll CombMemo(1000, vll(1000, -1));
ll Comb(ll n, ll k) {
if ((n < 0) || (k < 0))
return 0;
if (CombMemo[n][k] == -1) {
if (n < k)
CombMemo[n][k] = 0;
else {
if (n == 0)
CombMemo[n][k] = 1;
else if (k == 0)
CombMemo[n][k] = 1;
else if (n == k)
CombMemo[n][k] = 1;
else
CombMemo[n][k] = Comb(n - 1, k - 1) + Comb(n - 1, k);
}
}
return CombMemo[n][k];
}
template <class T> map<T, ll> Dict(V<T> v) {
map<T, ll> m;
if (!v.sz)
return m;
SORT(v);
UNIQUE(v);
REP(i, v.sz) { m[v[i]] = i; }
return m;
}
template <class T> vll Cmprs(V<T> v) {
auto m = Dict(v);
vll ans(v.sz);
REP(i, v.sz) { ans[i] = m[v[i]]; }
return ans;
}
template <class T> auto vecn(T val) { return val; }
template <class... Args> auto vecn(ll val, Args... args) {
auto tmp = vecn(args...);
return V<decltype(tmp)>(val, tmp);
}
void Solve();
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(20) << fixed;
Solve();
}
void Solve() {
li(n, m);
vli(m, l, r);
ll lll = 1, rrr = n;
REP(i, m) {
lll = max(l[i], lll);
rrr = min(r[i], rrr);
}
cout << rrr - lll + 1;
}
| #include <bits/stdc++.h>
using namespace std;
template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;
template <class T> using VVV = V<VV<T>>;
template <class S, class T> using P = pair<S, T>;
template <class S, class T, class U> using TP = tuple<S, T, U>;
using ll = long long;
using ull = unsigned long long;
using dbl = double;
using str = string;
using vll = V<ll>;
using vvll = V<vll>;
using vvvll = V<vvll>;
using pl = P<ll, ll>;
using tl = TP<ll, ll, ll>;
using vpl = V<pl>;
using vvpl = V<vpl>;
using vtl = V<tl>;
using vvtl = V<vtl>;
using vs = V<str>;
using vvs = V<vs>;
using vd = V<dbl>;
using vvd = V<vd>;
using qll = queue<ll>;
using qpl = queue<pl>;
using stll = stack<ll>;
using stpl = stack<pl>;
using mapll = map<ll, ll>;
using setll = set<ll>;
using pqll = priority_queue<ll>;
#define int ll
#define fi first
#define se second
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define pob pop_back()
#define pf push_front
#define pof pop_front()
#define sz size()
#define bgn begin()
#define en end()
#define asn assign
#define emp empty()
#define fr front()
#define bk back()
#define clr clear()
#define ins insert
#define ers erase
#define res resize
#define tp top()
#define p_q priority_queue
#define inv inverse()
#define FOR(i, a, b) for (ll i = (a); i <= (ll)(b); i++)
#define rFOR(i, a, b) for (ll i = (b); i >= (ll)(a); i--)
#define REP(i, a) FOR((i), 0, (ll)(a)-1)
#define REP0(i, a) FOR((i), 0, (ll)(a))
#define REP1(i, a) FOR((i), 1, (ll)(a))
#define rREP(i, a) rFOR((i), 0, (ll)(a)-1)
#define rREP0(i, a) rFOR((i), 0, (ll)(a))
#define rREP1(i, a) rFOR((i), 1, (ll)(a))
#define ROR(v, i) for (auto &(i) : (v))
#define IOTA(a, n) iota((a).bgn, (a).en, (n))
#define SORT(a) sort((a).bgn, (a).en)
#define rSORT(a) sort((a).rbegin(), (a).rend())
#define UNIQUE(a) (a).erase(unique((a).bgn, (a).en), (a).en)
#define PREVP(a) prev_permutation((a).bgn, (a).en)
#define NEXTP(a) next_permutation((a).bgn, (a).en)
#define BINS(a, b) binary_search((a).bgn, (a).en, (b))
#define LOWB(a, b) (lower_bound((a).bgn, (a).en, (b)) - (a).bgn)
#define UPB(a, b) (upper_bound((a).bgn, (a).en, (b)) - (a).bgn)
#define CNT(a, b) count((a).bgn, (a).en, b)
#define SUM(a) accumulate((a).bgn, (a).en, 0)
#define REV(a) reverse((a).bgn, (a).en)
#define REGS(a, b) regex_search((a), regex(b))
#define REGM(a, b) regex_match((a), regex(b))
#define yn(a) cout << ((a) ? "yes" : "no") << "\n";
#define Yn(a) cout << ((a) ? "Yes" : "No") << "\n";
#define YN(a) cout << ((a) ? "YES" : "NO") << "\n";
#define imp(a) cout << ((a) ? "possible" : "impossible") << "\n";
#define Imp(a) cout << ((a) ? "Possible" : "Impossible") << "\n";
#define IMP(a) cout << ((a) ? "POSSIBLE" : "IMPOSSIBLE") << "\n";
#define fs(a) cout << ((a) ? "second" : "first") << "\n";
#define Fs(a) cout << ((a) ? "Second" : "First") << "\n";
#define FS(a) cout << ((a) ? "SECOND" : "FIRST") << "\n";
#define sak cout << "\n";
#define sas cout << " ";
#define sat cout << "\t";
#define dbg(a) cerr << (#a) << ": " << (a) << "\n";
#define dbgs(...) \
dal(#__VA_ARGS__); \
dal(__VA_ARGS__);
#define c2l(a) ((ll)(a - 48))
#define a2l(a) ((ll)(a - 97))
#define A2l(a) ((ll)(a - 65))
#define l2c(a) ((char)(a + 48))
#define l2a(a) ((char)(a + 97))
#define l2A(a) ((char)(a + 65))
#define DigN2(a) ((llabs(a) == 0) ? (1) : ((ll)(log2(double(llabs(a)))) + 1))
#define DigN10(a) ((llabs(a) == 0) ? (1) : ((ll)(log10(double(llabs(a)))) + 1))
#define Dig2(a, b) (((a) >> (b)) & 1)
#define Dig10(a, b) (ll)(((a) / ((ll)(pow(10.0, (double)(b))))) % 10)
#define Pow2(a) ((ll)(1) << (a))
#define Pow10(a) ((ll)(pow(10.0, double(a))))
#define LSB(a) ((a) & (-(a)))
#define vin(v) \
ROR((v), (i)) { cin >> (i); };
#define vllin(v, N) \
vll(v)((N)); \
vin(v);
#define vllin2(a, b, N) \
vll(a)(N), (b)(N); \
REP(i, N) { cin >> (a)[i] >> (b)[i]; };
#define vsin(v, N) \
vs(v)((N)); \
vin(v);
#define rdn(a, b) ((a) / (b))
#define rou(a, b) \
((((double(a) / double(b)) - ((a) / (b))) < 0.5) ? ((a) / (b)) \
: (((a) / (b)) + 1))
#define rup(a, b) ((((a) % (b)) == 0) ? ((a) / (b)) : (((a) / (b)) + 1))
#define min(...) Min(__VA_ARGS__)
#define max(...) Max(__VA_ARGS__)
#define emin(a, ...) ((a) = Min((a), __VA_ARGS__))
#define emax(a, ...) ((a) = Max((a), __VA_ARGS__))
#define egcd(a, ...) ((a) = gcd((a), __VA_ARGS__))
#define elcm(a, ...) ((a) = lcm((a), __VA_ARGS__))
#define powll(a, b) (ll)(pow((double)(a), (double)(b)))
#define Triangle(x1, y1, x2, y2, x3, y3) \
(((x1) - (x2)) * ((y1) - (y3)) - ((x1) - (x3)) * ((y1) - (y2)))
#define svll SumV<ll>
#define svvll SumV2<ll>
#define li(...) \
ll __VA_ARGS__; \
Input(__VA_ARGS__);
#define si(...) \
str __VA_ARGS__; \
Input(__VA_ARGS__);
#define vli(size, ...) \
vll __VA_ARGS__; \
vInput(size, __VA_ARGS__);
#define vsi(size, ...) \
vs __VA_ARGS__; \
vInput(size, __VA_ARGS__);
// const ll MOD = 1e9 + 7;
const ll MOD = 998244353;
// const ll MOD = 924844033;
// const ll MOD = 9007199254740881;
const ll INF = 1LL << 60; // 1.15e18
const double PI = acos(-1.0);
const vll DX = {0, -1, 0, 1, 0, -1, 1, 1, -1};
const vll DY = {0, 0, -1, 0, 1, -1, -1, 1, 1};
const str alp = "abcdefghijklmnopqrstuvwxyz";
const str ALP = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
void Input() {}
template <class Var, class... Args> void Input(Var &var, Args &...args) {
cin >> var;
Input(args...);
}
void vInit(ll size) {}
template <class T, class... Args> void vInit(ll size, V<T> &v, Args &...args) {
v.res(size);
vInit(size, args...);
}
void vInputNum(ll num) {}
template <class T, class... Args>
void vInputNum(ll num, V<T> &v, Args &...args) {
cin >> v[num];
vInputNum(num, args...);
}
void vInput(ll size) {}
template <class... Args> void vInput(ll size, Args &...args) {
vInit(size, args...);
REP(i, size) vInputNum(i, args...);
}
template <class S, class T>
ostream &operator<<(ostream &out, const P<S, T> &p) {
return out << "[" << p.fi << ", " << p.se << "]";
}
template <class T> ostream &operator<<(ostream &out, V<T> &v) {
if (v.emp)
return out << "{}";
else {
auto itr = v.bgn;
out << "{" << *itr;
itr++;
while (itr != v.en) {
out << ", " << *itr;
itr++;
}
out << "}";
return out;
}
}
template <class S, class T>
ostream &operator<<(ostream &out, const map<S, T> &m) {
if (m.emp)
return out << "<[]>";
else {
auto itr = m.bgn;
out << "< [" << (itr->fi) << ": " << (itr->se);
itr++;
while (itr != m.en) {
out << "], [" << (itr->fi) << ": " << (itr->se);
itr++;
}
out << "] >";
return out;
}
}
template <class T> ostream &operator<<(ostream &out, const set<T> &s) {
if (s.emp)
return out << "<>";
else {
auto itr = s.bgn;
out << "<" << *itr;
itr++;
while (itr != s.en) {
out << ", " << *itr;
itr++;
}
out << ">";
return out;
}
}
void say() {}
template <class T> void say(T t) { cout << t; }
template <class Head, class... Body> void say(Head head, Body... body) {
cout << head << " ";
say(body...);
}
void sal() { cout << "\n"; }
template <class... Args> void sal(Args... args) {
say(args...);
cout << "\n";
}
void day() {}
template <class T> void day(T t) { cerr << t; }
template <class Head, class... Body> void day(Head head, Body... body) {
cerr << head << " ";
day(body...);
}
void dal() { cerr << "\n"; }
template <class... Args> void dal(Args... args) {
day(args...);
cerr << "\n";
}
void salv() {}
template <class T> void salv(V<T> v) {
if (v.emp)
sal();
else {
auto itr = v.bgn;
say(*itr);
itr++;
while (itr != v.en) {
sas;
say(*itr);
itr++;
}
sak;
}
}
template <class T, class... Args> void salv(V<T> v, Args... args) {
salv(v);
salv(args...);
}
void salv2() {}
template <class T> void salv2(V<V<T>> v) {
if (v.emp)
sal();
else {
ROR(v, i) salv(i);
}
}
template <class T, class... Args> void salv2(V<V<T>> v, Args... args) {
salv2(v);
salv2(args...);
}
template <class Monoid> struct Action {
public:
Monoid I;
function<Monoid(Monoid, Monoid)> A;
Action(Monoid I, function<Monoid(Monoid, Monoid)> A) : I(I), A(A) {}
Monoid operator()() { return I; }
Monoid operator()(Monoid x) { return x; }
Monoid operator()(Monoid l, Monoid r) { return A(l, r); }
template <class... Args> Monoid operator()(Monoid x, Args... args) {
Monoid tmp = operator()(args...);
return A(x, tmp);
}
};
template <class T> Action<T> ADD = Action<T>(0, [](T l, T r) { return l + r; });
template <>
Action<str> ADD<str> = Action<str>("", [](str l, str r) { return l + r; });
template <class T1, class T2>
Action<P<T1, T2>> ADD<P<T1, T2>> =
Action<P<T1, T2>>(mp(ADD<T1>.I, ADD<T2>.I), [](P<T1, T2> l, P<T1, T2> r) {
return mp(l.fi + r.fi, l.se + r.se);
});
template <class T> Action<T> MUL = Action<T>(1, [](T l, T r) { return l * r; });
template <class T> Action<T> OR = Action<T>(0, [](T l, T r) { return l | r; });
template <class T> Action<T> XOR = Action<T>(0, [](T l, T r) { return l ^ r; });
template <class T>
Action<T> AND = Action<T>(((ll)(1) << 63) - 1, [](T l, T r) { return l & r; });
template <>
Action<bool> AND<bool> = Action<bool>(true,
[](bool l, bool r) { return l & r; });
template <>
Action<ull> AND<ull> = Action<ull>(((ull)(1) << 63) - 1,
[](ull l, ull r) { return l & r; });
template <class T>
Action<T> MIN = Action<T>(INF, [](T l, T r) { return (l < r) ? l : r; });
template <class T>
Action<T> MAX = Action<T>(-INF, [](T l, T r) { return (l > r) ? l : r; });
template <class T>
Action<T> GCD = Action<T>(0, [](T l, T r) {
if (l < r) {
l ^= r;
r ^= l;
l ^= r;
}
return (r ? GCD<T>(r, l % r) : l);
});
template <class T>
Action<T> LCM = Action<T>(1, [](T l, T r) { return (l * r) / GCD<T>(l, r); });
template <class Head> Head Min(Head head) { return head; }
template <class Head, class... Body> Head Min(Head head, Body... body) {
auto tmp = Min(body...);
return (head < tmp) ? head : tmp;
}
template <class Head> Head Max(Head head) { return head; }
template <class Head, class... Body> auto Max(Head head, Body... body) {
auto tmp = Max(body...);
return (head > tmp) ? head : tmp;
}
ll gcd(ll a, ll b) {
if (a < b) {
a ^= b;
b ^= a;
a ^= b;
}
return b ? gcd(b, a % b) : a;
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll gcd(ll head) { return head; }
template <class... Body> ll gcd(ll head, Body... body) {
return gcd(head, gcd(body...));
}
ll lcm(ll head) { return head; }
template <class... Body> ll lcm(ll head, Body... body) {
return lcm(head, lcm(body...));
}
ll Bset(ll a, ll b, ll c) {
if (c)
a |= b;
else
a &= ~b;
return a;
}
struct UFT {
public:
ll tsize;
ll mode;
vll par;
vll rank;
UFT() {}
UFT(const UFT &uft) {}
UFT(ll tsizeget, ll modeget = 0) {
tsize = tsizeget;
mode = modeget;
par.asn(tsize, -1);
if (!mode)
rank.res(tsize, 0);
}
ll root(ll x) { return par[x] < 0 ? x : par[x] = root(par[x]); }
bool isRoot(ll x) { return x == root(x); }
bool same(ll x, ll y) { return root(x) == root(y); }
void merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (mode) {
par[x] += par[y];
par[y] = x;
} else {
if (rank[x] < rank[y]) {
par[y] += par[x];
par[x] = y;
} else {
par[x] += par[y];
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
}
}
}
ll size(ll x) { return -par[root(x)]; }
};
struct pUFT {
public:
ll tsize;
ll now;
vll par;
vll rank;
vll mtime;
vvll sizepi;
vvll sizepv;
pUFT() {}
pUFT(const pUFT &puft) {}
pUFT(ll tsizeget) {
tsize = tsizeget;
now = 0;
par.asn(tsize, -1);
rank.asn(tsize, 0);
mtime.asn(tsize, INF);
sizepi.asn(tsize, {0});
sizepv.asn(tsize, {1});
}
ll root(ll x, ll t) { return (mtime[x] > t) ? x : root(par[x], t); }
bool same(ll x, ll y, ll t) { return root(x, t) == root(y, t); }
ll merge(ll x, ll y) {
now++;
x = root(x, now);
y = root(y, now);
if (x != y) {
if (rank[x] < rank[y]) {
par[y] += par[x];
sizepi[y].pb(now);
sizepv[y].pb(-par[y]);
par[x] = y;
mtime[x] = now;
} else {
par[x] += par[y];
sizepi[x].pb(now);
sizepv[x].pb(-par[x]);
par[y] = x;
mtime[y] = now;
if (rank[x] == rank[y])
rank[x]++;
}
}
return now;
}
ll size(ll x, ll t) {
x = root(x, t);
return sizepv[x][UPB(sizepi[x], t) - 1];
}
};
struct wUFT {
public:
ll tsize;
ll mode;
vll par;
vll rank;
vll dweight;
wUFT() {}
wUFT(const wUFT &wuft) {}
wUFT(ll tsizeget, ll modeget = 0) {
tsize = tsizeget;
mode = modeget;
par.asn(tsize, -1);
if (!mode)
rank.res(tsize, 0);
dweight.asn(tsize, 0);
}
ll root(ll x) {
if (par[x] < 0)
return x;
else {
ll r = root(par[x]);
dweight[x] += dweight[par[x]];
return par[x] = r;
}
}
ll weight(ll x) {
root(x);
return dweight[x];
}
ll diff(ll x, ll y) { return weight(y) - weight(x); }
bool isRoot(ll x) { return x == root(x); }
bool same(ll x, ll y) { return root(x) == root(y); }
void merge(ll x, ll y, ll w) {
w += weight(x);
w -= weight(y);
x = root(x);
y = root(y);
if (x == y)
return;
if (mode) {
par[x] += par[y];
par[y] = x;
} else {
if (rank[x] < rank[y]) {
par[y] += par[x];
par[x] = y;
dweight[x] = -w;
} else {
par[x] += par[y];
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
dweight[y] = w;
}
}
}
ll size(ll x) { return -par[root(x)]; }
};
template <typename valtype> class SegT {
public:
ll size;
vector<valtype> v;
valtype initv;
function<valtype(valtype x, valtype y)> calc;
SegT() {}
SegT(const SegT &segt) {}
SegT(ll sizeget, ll modeget = 0) {
sizeset(sizeget);
modeset(modeget);
init();
}
SegT(vector<valtype> cpyvec, ll modeget = 0) {
sizeset(cpyvec.sz);
modeset(modeget);
init();
copy(cpyvec);
}
SegT(ll sizeget, valtype initvget,
function<valtype(valtype x, valtype y)> calcget) {
sizeset(sizeget);
initv = initvget;
calc = calcget;
init();
}
SegT(vector<valtype> cpyvec, valtype initvget,
function<valtype(valtype x, valtype y)> calcget) {
sizeset(cpyvec.sz);
initv = initvget;
calc = calcget;
init();
copy(cpyvec);
}
void sizeset(ll rsize) {
size = DigN2(rsize);
if (rsize == Pow2(size - 1))
size--;
return;
}
void modeset(ll mode) {
switch (mode) {
case 0:
initv = 0;
calc = [](valtype x, valtype y) { return x + y; };
break;
case 1:
initv = INF;
calc = [](valtype x, valtype y) { return min(x, y); };
break;
case 2:
initv = -INF;
calc = [](valtype x, valtype y) { return max(x, y); };
break;
}
return;
}
void init() { v.asn(Pow2(size + 1) - 1, initv); }
void copy(vector<valtype> cpyvec) {
REP(i, min(cpyvec.sz, Pow2(size))) set(i, cpyvec[i]);
}
ll i2v(ll i) const {
if (i < 0 || i >= Pow2(size))
return -1;
return Pow2(size) + i - 1;
}
ll top(ll i) const {
if (i == 0)
return -1;
return (i - 1) / 2;
}
pl bot(ll i) const {
if (i + 1 >= Pow2(size))
return mp(-1, -1);
return mp(2 * i + 1, 2 * i + 2);
}
void set(ll i, valtype x) {
i = i2v(i);
v[i] = x;
while (i > 0) {
i = top(i);
v[i] = calc(v[bot(i).fi], v[bot(i).se]);
}
return;
}
void add(ll i, valtype x) {
set(i, v[i2v(i)] + x);
return;
}
valtype operator[](const ll &i) const { return v[i2v(i)]; }
// valtype que(ll a = 0, ll b = Pow2(size) - 1) {
valtype que(ll a, ll b) {
if (a == b)
return v[i2v(a)];
if (a > b)
return initv; // swap(a, b);
valtype ans = initv;
ll ai = i2v(a);
ll bi = i2v(b);
FOR(i, 1, size + 1) {
if (a > b)
break;
if (a % Pow2(i)) {
ans = calc(ans, v[ai]);
a += Pow2(i - 1);
ai = top(ai) + 1;
} else {
ai = top(ai);
}
if (a > b)
break;
if ((b + 1) % Pow2(i)) {
ans = calc(ans, v[bi]);
b -= Pow2(i - 1);
bi = top(bi) - 1;
} else {
bi = top(bi);
}
if (a > b)
break;
}
return ans;
}
valtype que(ll b) { return que(0, b); }
valtype que() { return que(0, Pow2(size) - 1); }
};
template <typename lentype> class Graph {
public:
ll size;
ll mode;
ll mapmode;
lentype zlen;
lentype ilen;
vector<map<ll, ll>> v2n;
vvll n2v;
vector<vector<lentype>> Edge;
vector<pair<lentype, ll>> Primresult;
Graph() {}
Graph(const Graph &graph) {}
Graph(ll sizeget = 0, ll mapmodeget = 0, ll modeget = 0, lentype zlenget = 0,
lentype ilenget = INF) {
size = sizeget;
mapmode = mapmodeget;
mode = modeget;
zlen = zlenget;
ilen = ilenget;
init();
}
void init() {
Edge.res(size);
v2n.res(size);
n2v.res(size);
Primresult.asn(size, mp(ilen, -1));
}
lentype lenplus(lentype l, lentype r) { return l + r; }
lentype lenequal(lentype l, lentype r) { return l == r; }
lentype lenlcr(lentype l, lentype r) { return l < r; }
ll addV(ll vs) {
size += vs;
init();
return size;
}
void caddE(ll x, ll y, lentype c) {
if (mapmode)
v2n[x][y] = Edge[x].sz;
Edge[x].pb(c);
n2v[x].pb(y);
}
void csetE(ll x, ll y, lentype c) {
if (mapmode)
Edge[x][v2n[x][y]] = c;
}
void cersE(ll x, ll y) {
if (mapmode) {
ll n = v2n[x][y];
Edge[x][n] = ilen;
n2v[x][n] = -1;
v2n[x].ers(y);
}
}
void addE(ll x, ll y, lentype c) {
caddE(x, y, c);
if (!mode)
caddE(y, x, c);
}
void setE(ll x, ll y, lentype c) {
csetE(x, y, c);
if (!mode)
csetE(y, x, c);
}
void ersE(ll x, ll y, lentype c) {
cersE(x, y, c);
if (!mode)
cersE(y, x, c);
}
lentype getE(ll x, ll y) {
if (mapmode) {
if (v2n[x].count(y)) {
return Edge[x][v2n[x][y]];
}
}
return ilen;
}
ll getVsz(ll x) { return Edge[x].sz; }
pair<lentype, ll> getV(ll x, ll n) {
if (n >= getVsz(x))
return mp(ilen, -1);
return mp(Edge[x][n], n2v[x][n]);
}
vector<pair<lentype, vll>> Dijk(ll x) {
vector<pair<lentype, vll>> result(size);
REP(i, size) {
result[i].fi = ilen;
result[i].se = {-1};
}
vll stat(size, 0);
pair<lentype, ll> now;
pair<lentype, ll> nowlv;
SegT<pair<lentype, ll>> Q(size, mp(ilen, -1),
[](pair<lentype, ll> l, pair<lentype, ll> r) {
if (l.se == -1)
return r;
if (r.se == -1)
return l;
return l.fi < r.fi ? l : r;
});
Q.set(x, mp(zlen, x));
result[x].fi = zlen;
result[x].se = {-1};
while (Q.que(0, size - 1).se != -1) {
now = Q.que(0, size - 1);
Q.set(now.se, mp(ilen, -1));
stat[now.se] = 1;
REP(i, getVsz(now.se)) {
nowlv = getV(now.se, i);
if (stat[nowlv.se])
continue;
if (Q[nowlv.se].se == -1) {
result[nowlv.se].fi = lenplus(result[now.se].fi, nowlv.fi);
result[nowlv.se].se = {now.se};
Q.set(nowlv.se, mp(result[nowlv.se].fi, nowlv.se));
} else {
if (lenlcr(lenplus(result[now.se].fi, nowlv.fi),
result[nowlv.se].fi)) {
result[nowlv.se].fi = lenplus(result[now.se].fi, nowlv.fi);
result[nowlv.se].se = {now.se};
Q.set(nowlv.se, mp(result[nowlv.se].fi, nowlv.se));
} else if (lenequal(lenplus(result[now.se].fi, nowlv.fi),
result[nowlv.se].fi)) {
result[nowlv.se].se.pb(now.se);
}
}
}
}
return result;
}
lentype Prim(ll x = 0) {
lentype ans = zlen;
vll stat(size, 0);
pair<lentype, ll> now;
pair<lentype, ll> nowlv;
SegT<pair<lentype, ll>> Q(size, mp(ilen, -1),
[](pair<lentype, ll> l, pair<lentype, ll> r) {
if (l.se == -1)
return r;
if (r.se == -1)
return l;
return l.fi < r.fi ? l : r;
});
Q.set(x, mp(zlen, x));
Primresult[x] = mp(zlen, -1);
while (Q.que(0, size - 1).se != -1) {
now = Q.que(0, size - 1);
Q.set(now.se, mp(ilen, -1));
stat[now.se] = 1;
ans = lenplus(ans, Primresult[now.se].fi);
REP(i, getVsz(now.se)) {
nowlv = getV(now.se, i);
if (stat[nowlv.se])
continue;
if (Q[nowlv.se].se == -1) {
Primresult[nowlv.se] = mp(nowlv.fi, now.se);
Q.set(nowlv.se, mp(Primresult[nowlv.se].fi, nowlv.se));
} else {
if (lenlcr(nowlv.fi, Primresult[nowlv.se].fi)) {
Primresult[nowlv.se] = mp(nowlv.fi, now.se);
Q.set(nowlv.se, mp(Primresult[nowlv.se].fi, nowlv.se));
}
}
}
}
return ans;
}
};
/*template <class Type> class DP {
public:
vector<Type> v;
Type initv;
vll size, block;
DP() {}
DP(const DP &dp) {}
template<class... Args> DP(Args... args) {
block.asn(1, 1);
Initialize(args...);
}
void Initialize(Type initv_) {
initv = initv_;
v.asn(block.bk, initv);
}
template<class... Args> void Initialize(ll val, Args... args) {
size.pb(val);
block.pb(block.bk*val);
Initialize(args...);
}
};*/
pl Bezout(ll a, ll b) {
if (b != 0) {
pl xy;
xy = Bezout(b, a % b);
return mp(xy.se, xy.fi - ((a / b) * xy.se));
} else {
return mp(1, 0);
}
}
pl Bez(ll a, ll b, ll c) {
pl xy;
ll x, y, z, gc;
xy = Bezout(a, b);
gc = gcd(a, b);
if (c % gc != 0)
return mp(-1, -1);
x = xy.fi * (c / gc);
y = xy.se * (c / gc);
if (x < 0)
z = rup(-x, (b / gc));
if (x >= 0)
z = -x / (b / gc);
x += z * (b / gc);
y -= z * (a / gc);
return mp(x, y);
}
ll DigS10(ll n) {
ll ans = 0;
while (1) {
ans += n % 10;
n /= 10;
if (!n)
break;
}
return ans;
}
ll isP(ll n) {
if (n <= 1)
return 0;
FOR(i, 2, (ll)sqrt(n) + 1) {
if (n % i == 0)
return 0;
}
return 1;
}
ll Tot(ll n) {
if (n <= 0)
return 0;
ll ans = n, x = 2;
while (x * x <= n) {
if (n % x == 0) {
ans -= ans / x;
while (n % x == 0)
n /= x;
}
x++;
}
if (n > 1)
ans -= ans / n;
return ans;
}
template <class T> struct Sum {
public:
V<T> v, s;
ll size;
Action<T> Add;
Sum(V<T> v, Action<T> Add = ADD<T>) : v(v), size(v.sz), Add(Add) {
Init();
Calc();
}
void Init() { s.asn(size + 1, Add.I); }
void Calc() { REP(i, size) s[i + 1] = Add(s[i], v[i]); }
T operator()(ll x) { return operator()(0, x); }
T operator()(ll l, ll r) {
if (l < 0)
l = 0;
if (r >= size)
r = size - 1;
if (l > r)
return Add.I;
return s[r + 1] - s[l]; // for ADD
}
};
using sumll = Sum<ll>;
template <class T> struct Sum2 {
public:
V<V<T>> v, s;
ll RowSize, ColumnSize;
Action<T> Add;
Sum2(V<V<T>> v, Action<T> Add = ADD<T>)
: v(v), RowSize(v.sz), ColumnSize(v.sz ? v[0].sz : 0), Add(Add) {
Init();
Calc();
}
void Init() { s.asn(RowSize + 1, V<T>(ColumnSize, Add.I)); }
void Calc() {
REP1(r, RowSize) {
REP1(c, ColumnSize) {
s[r][c] =
v[r - 1][c - 1] + operator()(r, c - 1) + operator()(r - 1, c) -
operator()(r - 1, c - 1);
}
}
}
T operator()(ll r, ll c) { return operator()(0, 0, r, c); }
T operator()(ll r1, ll c1, ll r2, ll c2) {
if (r1 < 0)
r1 = 0;
if (c1 < 0)
c1 = 0;
if (r2 >= RowSize)
r2 = RowSize - 1;
if (c2 >= ColumnSize)
c2 = ColumnSize - 1;
if (r1 > r2)
return Add.I;
if (c1 > c2)
return Add.I;
return s[r2 + 1][c2 + 1] - s[r2 + 1][c1] - s[r1][c2 + 1] + s[r1][c1];
}
};
using sum2ll = Sum2<ll>;
template <class T> struct Point2 {
public:
V<V<T>> v;
ll h, w;
Point2() : h(0), w(0) {}
Point2(ll h, ll w) : h(h), w(w) { asn(h, w); }
Point2(ll h, ll w, T val) : h(h), w(w) { asn(h, w, val); }
void assign(ll h, ll w) { v.asn(h, V<T>(w)); }
void assign(ll h, ll w, ll val) { v.asn(h, V<T>(w, val)); }
T &operator()(ll h, ll w) { return v[h][w]; }
T &operator()(pl p) { return v[p.fi][p.se]; }
};
template <class T> using P2 = Point2<T>;
template <ll Mod> struct Modll {
public:
ll v;
Modll() : v(0) {}
Modll(ll _v) { set(_v % Mod + Mod); }
Modll &set(ll _v) {
v = (_v < Mod) ? _v : (_v - Mod);
return *this;
}
Modll pow(ll n) const {
Modll x = *this, ans = 1;
while (n) {
if (n & 1)
ans *= x;
x *= x;
n >>= 1;
}
return ans;
}
Modll inverse() const { return (*this).pow(Mod - 2); }
Modll operator+(const Modll &m) const { return Modll().set(v + m.v); }
Modll operator-(const Modll &m) const { return Modll().set(Mod + v - m.v); }
Modll operator*(const Modll &m) const {
return Modll().set((ull(v) * m.v) % Mod);
}
Modll operator/(const Modll &m) const { return *this * m.inv; }
Modll &operator+=(const Modll &m) { return *this = *this + m; }
Modll &operator-=(const Modll &m) { return *this = *this - m; }
Modll &operator*=(const Modll &m) { return *this = *this * m; }
Modll &operator/=(const Modll &m) { return *this = *this / m; }
Modll operator-() const { return Modll(0) - *this; }
explicit operator bool() const { return v != 0; }
friend ostream &operator<<(ostream &out, const Modll &m) {
return out << m.v;
}
};
using mll = Modll<MOD>;
using vmll = V<mll>;
using vvmll = V<vmll>;
using vvvmll = V<vvmll>;
template <class T> T vmin(V<T> v) {
T tmp = MIN<T>.I;
ROR(v, i) emin(tmp, i);
return tmp;
}
template <class T, class... Args> T vmin(V<T> v, Args... args) {
T tmp = vmin(args...);
return min(vmin(v), tmp);
}
template <class T> T vmax(V<T> v) {
T tmp = MAX<T>.I;
ROR(v, i) emax(tmp, i);
return tmp;
}
template <class T, class... Args> T vmax(V<T> v, Args... args) {
T tmp = vmax(args...);
return max(vmax(v), tmp);
}
template <class T> T vgcd(V<T> v) {
T tmp = GCD<T>.I;
ROR(v, i) egcd(tmp, i);
return tmp;
}
template <class T, class... Args> T vgcd(V<T> v, Args... args) {
T tmp = vgcd(args...);
return gcd(vgcd(v), tmp);
}
template <class T> T vlcm(V<T> v) {
T tmp = LCM<T>.I;
ROR(v, i) elcm(tmp, i);
return tmp;
}
template <class T, class... Args> T vlcm(V<T> v, Args... args) {
T tmp = vlcm(args...);
return lcm(vlcm(v), tmp);
}
vmll MFactMemo(2, 1);
vmll MIFactMemo(2, 1);
mll mFact(ll n) {
if (MFactMemo.sz <= n) {
ll oldsize = MFactMemo.sz;
MFactMemo.res(n + 1, 1);
FOR(i, oldsize, n) MFactMemo[i] = MFactMemo[i - 1] * i;
}
return MFactMemo[n];
}
mll miFact(ll n) {
if (MIFactMemo.sz <= n) {
ll oldsize = MIFactMemo.sz;
MIFactMemo.res(n + 1, 1);
MIFactMemo.bk = mFact(n).inv;
rFOR(i, oldsize + 1, n) MIFactMemo[i - 1] = MIFactMemo[i] * i;
}
return MIFactMemo[n];
}
mll mComb(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
return mFact(n) * miFact(k) * miFact(n - k);
}
ll LIS(vll v, ll m = 0) {
if (v.sz > 0) {
ll ans = 0;
vll dp(v.sz, INF);
FOR(i, 0, v.sz - 1) { dp[m ? UPB(dp, v[i]) : LOWB(dp, v[i])] = v[i]; }
FOR(i, 0, v.sz - 1) {
if (dp[i] == INF)
break;
ans++;
}
return ans;
} else {
return 0;
}
}
void PCmprs(vll &v) {
if (v.sz == 0)
return;
vll vv(v);
IOTA(vv, 0);
sort(vv.bgn, vv.en, [&](ll v1, ll v2) { return v[v1] < v[v2]; });
IOTA(v, 0);
sort(v.bgn, v.en, [&](ll v1, ll v2) { return vv[v1] < vv[v2]; });
return;
}
ll BblCnt(vll v) {
PCmprs(v);
SegT<ll> b(v.sz, 0);
ll ans = 0;
REP(i, v.sz) {
ans += (i - b.que(0, v[i]));
b.add(v[i], 1);
}
return ans;
}
ll Bsrch(function<bool(ll x)> f, ll mi, ll ma) {
ll ng = mi - 1, ok = ma, mid;
while (ok - ng > 1) {
mid = (ng + ok) / 2;
(f(mid) ? ok : ng) = mid;
}
return ok;
}
template <class T>
V<V<T>> MultiMatrix(V<V<T>> A, V<V<T>> B, Action<T> Mul = MUL<T>,
Action<T> Add = ADD<T>) {
V<V<T>> ans;
ll ii = A.sz;
if (!ii)
return ans;
ll jj = A[0].sz;
if (!jj)
return ans;
ll jj2 = B.sz;
if (!jj2)
return ans;
if (jj != jj2)
return ans;
ll kk = B[0].sz;
if (!kk)
return ans;
ans.asn(ii, V<T>(kk, 0));
REP(i, ii) {
REP(k, kk) {
REP(j, jj) { ans[i][k] = Add(ans[i][k], Mul(A[i][j], B[j][k])); }
}
}
return ans;
}
vvll CombMemo(1000, vll(1000, -1));
ll Comb(ll n, ll k) {
if ((n < 0) || (k < 0))
return 0;
if (CombMemo[n][k] == -1) {
if (n < k)
CombMemo[n][k] = 0;
else {
if (n == 0)
CombMemo[n][k] = 1;
else if (k == 0)
CombMemo[n][k] = 1;
else if (n == k)
CombMemo[n][k] = 1;
else
CombMemo[n][k] = Comb(n - 1, k - 1) + Comb(n - 1, k);
}
}
return CombMemo[n][k];
}
template <class T> map<T, ll> Dict(V<T> v) {
map<T, ll> m;
if (!v.sz)
return m;
SORT(v);
UNIQUE(v);
REP(i, v.sz) { m[v[i]] = i; }
return m;
}
template <class T> vll Cmprs(V<T> v) {
auto m = Dict(v);
vll ans(v.sz);
REP(i, v.sz) { ans[i] = m[v[i]]; }
return ans;
}
template <class T> auto vecn(T val) { return val; }
template <class... Args> auto vecn(ll val, Args... args) {
auto tmp = vecn(args...);
return V<decltype(tmp)>(val, tmp);
}
void Solve();
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(20) << fixed;
Solve();
}
void Solve() {
li(n, m);
vli(m, l, r);
ll lll = 1, rrr = n;
REP(i, m) {
lll = max(l[i], lll);
rrr = min(r[i], rrr);
}
cout << max(0, rrr - lll + 1);
} | [
"call.add",
"call.arguments.change"
] | 851,906 | 851,907 | u172929647 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int i, n, m, minv = 0, maxv = INT_MAX, l, r;
scanf("%d %d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d %d", &l, &r);
maxv = min(maxv, r);
minv = max(minv, l);
}
printf("%d", maxv - minv + 1);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int i, n, m, minv = 0, maxv = INT_MAX, l, r;
scanf("%d %d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d %d", &l, &r);
maxv = min(maxv, r);
minv = max(minv, l);
}
printf("%d", max(maxv - minv + 1, 0));
return 0;
} | [
"call.add",
"call.arguments.add"
] | 851,916 | 851,917 | u379393519 | cpp |
p03037 |
#include "bits/stdc++.h"
// #define int long long
using namespace std;
int main(void) {
int n, m;
cin >> n >> m;
int l = 1, r = n;
for (int i = 0; i < m; ++i) {
int _l, _r;
cin >> _l >> _r;
l = max(l, _l);
r = min(r, _r);
}
cout << r - l + 1 << endl;
return 0;
}
|
#include "bits/stdc++.h"
// #define int long long
using namespace std;
int main(void) {
int n, m;
cin >> n >> m;
int l = 1, r = n;
for (int i = 0; i < m; ++i) {
int _l, _r;
cin >> _l >> _r;
l = max(l, _l);
r = min(r, _r);
}
cout << max(0, r - l + 1) << endl;
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 851,920 | 851,921 | u076865901 | cpp |
p03037 | //
// main.c
// Prison
//
// Created by yuta on 2019/05/25.
// Copyright © 2019 501Software. All rights reserved.
//
#include <stdio.h>
int main(int argc, const char *argv[]) {
int N, M;
int L, R;
int l = 1, r;
int t = 0;
// スペース区切りの整数の入力
scanf("%d %d", &N, &M);
r = N;
// ゲート
for (int i = 0; i < M; i++) {
scanf("%d %d", &L, &R);
if (l < L)
l = L;
if (r > R)
r = R;
}
for (int i = 0; i < N; i++) {
if (l <= i && r >= i)
t++;
}
printf("%d\n", t);
return 0;
}
| //
// main.c
// Prison
//
// Created by yuta on 2019/05/25.
// Copyright © 2019 501Software. All rights reserved.
//
#include <stdio.h>
int main(int argc, const char *argv[]) {
int N, M;
int L, R;
int l = 1, r;
int t = 0;
// スペース区切りの整数の入力
scanf("%d %d", &N, &M);
r = N;
// ゲート
for (int i = 0; i < M; i++) {
scanf("%d %d", &L, &R);
if (l < L)
l = L;
if (r > R)
r = R;
}
for (int i = 0; i <= N; i++) {
if (l <= i && r >= i)
t++;
}
printf("%d\n", t);
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 851,934 | 851,935 | u156723325 | cpp |
p03037 | #include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
using namespace std;
typedef unsigned long long int ulli;
typedef long long int lli;
#define MAX(x, y) ((x) < (y) ? (y) : (x))
#define MIN(x, y) ((x) > (y) ? (y) : (x))
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, M;
cin >> N >> M;
int maxL;
int minR;
int tempL, tempR;
cin >> maxL >> minR;
for (int i = 1; i < M; ++i) {
cin >> tempL >> tempR;
maxL = MAX(maxL, tempL);
minR = MIN(minR, tempR);
}
cout << minR - maxL + 1 << "\n";
return 0;
}
| #include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
using namespace std;
typedef unsigned long long int ulli;
typedef long long int lli;
#define MAX(x, y) ((x) < (y) ? (y) : (x))
#define MIN(x, y) ((x) > (y) ? (y) : (x))
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, M;
cin >> N >> M;
int maxL;
int minR;
int tempL, tempR;
cin >> maxL >> minR;
for (int i = 1; i < M; ++i) {
cin >> tempL >> tempR;
maxL = MAX(maxL, tempL);
minR = MIN(minR, tempR);
}
cout << MAX(minR - maxL + 1, 0) << "\n";
return 0;
}
| [
"call.add",
"call.arguments.add"
] | 851,946 | 851,947 | u806999568 | cpp |
p03037 | //#pragma warning(disable:4996)
#include <stdio.h>
int main() {
/*int n, m;
int L[100000];
int R[100000];
bool a[100000];//false：ダメ,true：いける
for (int i = 0; i < 100000; i++) {
a[i] = true;
}
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &L[i], &R[i]);
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (a[j] && (j < L[i]-1 || R[i]-1 < j)) {
a[j]=false;
}
}
}
int answer = 0;
for (int i = 0; i < n; i++) {
if (a[i]) {
answer++;
}
}
printf("%d\n", answer);
//while (1);
*/
int n, m;
int L[100500];
int R[100500];
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &L[i], &R[i]);
}
int min = 0;
int max = 100500;
for (int i = 0; i < m; i++) {
if (max < L[i] || R[i] < min) { //かぶってない
min = max + 1; // 0の出力
break;
}
if (L[i] < max && min < R[i]) {
if (min < L[i]) {
min = L[i];
}
if (R[i] < max) {
max = R[i];
}
}
}
printf("%d\n", max - min + 1);
// while (1);
} | //#pragma warning(disable:4996)
#include <stdio.h>
int main() {
/*int n, m;
int L[100000];
int R[100000];
bool a[100000];//false：ダメ,true：いける
for (int i = 0; i < 100000; i++) {
a[i] = true;
}
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &L[i], &R[i]);
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (a[j] && (j < L[i]-1 || R[i]-1 < j)) {
a[j]=false;
}
}
}
int answer = 0;
for (int i = 0; i < n; i++) {
if (a[i]) {
answer++;
}
}
printf("%d\n", answer);
//while (1);
*/
int n, m;
int L[100500];
int R[100500];
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &L[i], &R[i]);
}
int min = 0;
int max = 100500;
for (int i = 0; i < m; i++) {
if (max < L[i] || R[i] < min) { //かぶってない
min = max + 1; // 0の出力
break;
}
if (L[i] <= max && min <= R[i]) {
if (min < L[i]) {
min = L[i];
}
if (R[i] < max) {
max = R[i];
}
}
}
printf("%d\n", max - min + 1);
// while (1);
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 851,950 | 851,951 | u691912637 | cpp |
p03037 | #include <iostream>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int r, l;
l = 0;
r = N;
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
if (l < a)
l = a;
if (r > b)
r = b;
}
cout << min(r - l + 1, 0) << endl;
} | #include <iostream>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int r, l;
l = 0;
r = N;
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
if (l < a)
l = a;
if (r > b)
r = b;
}
cout << max(r - l + 1, 0) << endl;
}
| [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 851,956 | 851,957 | u058186113 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M), R(M);
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i];
}
int minR = *min_element(R.begin(), R.end());
int maxL = *max_element(L.begin(), L.end());
int count = 0;
for (int i = 0; i < N; i++) {
if (maxL <= i && i <= minR) {
count++;
}
}
cout << count;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M), R(M);
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i];
}
int minR = *min_element(R.begin(), R.end());
int maxL = *max_element(L.begin(), L.end());
int count = 0;
for (int i = 1; i <= N; i++) {
if (maxL <= i && i <= minR) {
count++;
}
}
cout << count;
}
| [
"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"
] | 851,962 | 851,963 | u692650171 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
#define ROUNDUP(divisor, dividend) (divisor + (dividend - 1)) / dividend
int n, m;
int a, b, am, bm;
int temp1 = 0, temp2 = 999999;
int main() {
cin >> n >> m;
bool wa = false;
for (int i = 0; i < m; i++) {
cin >> a >> b;
temp1 = max(temp1, a);
temp2 = min(temp2, b);
}
cout << (temp1 <= temp2 ? 0 : (temp2 - temp1) + 1) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define ROUNDUP(divisor, dividend) (divisor + (dividend - 1)) / dividend
int n, m;
int a, b, am, bm;
int temp1 = 0, temp2 = 999999;
int main() {
cin >> n >> m;
bool wa = false;
for (int i = 0; i < m; i++) {
cin >> a >> b;
temp1 = max(temp1, a);
temp2 = min(temp2, b);
}
cout << (temp1 > temp2 ? 0 : (temp2 - temp1) + 1) << endl;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"io.output.change"
] | 851,964 | 851,965 | u890807039 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
const ll N = 1e5 + 5, MOD = 1e9 + 7;
ll n, m;
ll l, r;
vector<pair<ll, ll>> v1, v2;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
for (ll i = 1; i <= m; i++) {
cin >> l >> r;
v1.pb({l, r});
v2.pb({r, l});
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
cout << max(0LL, v2[0].first - v1[0].first + 1) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
const ll N = 1e5 + 5, MOD = 1e9 + 7;
ll n, m;
ll l, r;
vector<pair<ll, ll>> v1, v2;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
for (ll i = 1; i <= m; i++) {
cin >> l >> r;
v1.pb({l, r});
v2.pb({r, l});
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
cout << max(0LL, v2[0].first - v1[m - 1].first + 1) << endl;
return 0;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"io.output.change"
] | 851,968 | 851,969 | u769602639 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int mxLi = -1, mnRi = (int)1e8;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
mxLi = max(mxLi, x);
mnRi = min(mnRi, y);
}
cout << -mxLi + 1 + mnRi << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int mxLi = -1, mnRi = (int)1e8;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
mxLi = max(mxLi, x);
mnRi = min(mnRi, y);
}
cout << max(0, -mxLi + 1 + mnRi) << endl;
return 0;
} | [
"call.add",
"call.arguments.change"
] | 851,980 | 851,981 | u095814925 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
#define X first
#define Y second
#define pb push_back
#define pp pop_back
#define mk make_pair
#define EPS 1e-9
#define INF 1 << 25
#define ln '\n'
#define sp ' '
#define all(x) x.begin(), x.end()
#define Sort(x) sort(all(x))
#define mem(a, b) memset(a, b, sizeof(a))
#define lpa(p, v) for (auto p : (v))
#define lp(a, b, c) for (int a = (b); a < (c); a++)
#define lp0(a, n) lp(a, 0, n)
#define lpr(a, b, c) for (int a = (b); a >= (c); a--)
#define faster \
ios_base::sync_with_stdio(0); \
cin.tie(0);
#define debug(a) cout << a << ln;
#define debug2(a, b) cout << a << sp << b << ln;
#define debug3(a, b, c) cout << a << sp << b << sp << c << ln;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef pair<int, string> psi;
typedef map<int, int> mii;
inline bool sc(int &_x) { return scanf("%d", &_x) == 1; }
inline bool sc(int &_x, int &_y) { return sc(_x) && sc(_y); }
inline bool sc(int &_x, int &_y, int &_z) { return sc(_x) && sc(_y) && sc(_z); }
inline bool sc(int &_x, int &_y, int &_z, int &_zz) {
return sc(_x) && sc(_y) && sc(_z) && sc(_zz);
}
/*int x4[]= {1,-1,0,0};
int y4[]= {0,0,1,-1};
int x8[]= {0,0,+1,-1,-1,+1,-1,+1};
int y8[]= {-1,+1,0,0,+1,+1,-1,-1};
int kx[]= {2,2,-2,-2,1,-1,1,-1};
int ky[]= {1,-1,1,-1,2,2,-2,-2};*/
const double PI = acos(-1.0);
const int N = 1000005;
const int MOD = 1e9 + 7;
pii a[N];
int main() {
int n, m;
cin >> n >> m;
int l = 0, r = INF;
lp0(i, m) cin >> a[i].X >> a[i].Y;
sort(a, a + m);
lp0(i, m) {
l = max(l, a[i].X);
r = min(r, a[i].Y);
}
cout << r - l + 1 << ln;
}
| #include <bits/stdc++.h>
using namespace std;
#define X first
#define Y second
#define pb push_back
#define pp pop_back
#define mk make_pair
#define EPS 1e-9
#define INF 1 << 25
#define ln '\n'
#define sp ' '
#define all(x) x.begin(), x.end()
#define Sort(x) sort(all(x))
#define mem(a, b) memset(a, b, sizeof(a))
#define lpa(p, v) for (auto p : (v))
#define lp(a, b, c) for (int a = (b); a < (c); a++)
#define lp0(a, n) lp(a, 0, n)
#define lpr(a, b, c) for (int a = (b); a >= (c); a--)
#define faster \
ios_base::sync_with_stdio(0); \
cin.tie(0);
#define debug(a) cout << a << ln;
#define debug2(a, b) cout << a << sp << b << ln;
#define debug3(a, b, c) cout << a << sp << b << sp << c << ln;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef pair<int, string> psi;
typedef map<int, int> mii;
inline bool sc(int &_x) { return scanf("%d", &_x) == 1; }
inline bool sc(int &_x, int &_y) { return sc(_x) && sc(_y); }
inline bool sc(int &_x, int &_y, int &_z) { return sc(_x) && sc(_y) && sc(_z); }
inline bool sc(int &_x, int &_y, int &_z, int &_zz) {
return sc(_x) && sc(_y) && sc(_z) && sc(_zz);
}
/*int x4[]= {1,-1,0,0};
int y4[]= {0,0,1,-1};
int x8[]= {0,0,+1,-1,-1,+1,-1,+1};
int y8[]= {-1,+1,0,0,+1,+1,-1,-1};
int kx[]= {2,2,-2,-2,1,-1,1,-1};
int ky[]= {1,-1,1,-1,2,2,-2,-2};*/
const double PI = acos(-1.0);
const int N = 1000005;
const int MOD = 1e9 + 7;
pii a[N];
int main() {
int n, m;
cin >> n >> m;
int l = 0, r = INF;
lp0(i, m) cin >> a[i].X >> a[i].Y;
sort(a, a + m);
lp0(i, m) {
l = max(l, a[i].X);
r = min(r, a[i].Y);
}
cout << max(0, r - l + 1) << ln;
}
| [
"call.add",
"call.arguments.change"
] | 851,989 | 851,990 | u613686673 | cpp |
p03037 | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
#define mod (1e9 + 7)
#define pb push_back
using namespace std;
typedef pair<int, int> pii;
int main() {
int n, m;
cin >> n >> m;
int l, r, ll, rr;
ll = 0;
rr = n;
for (int i = 0; i < m; i++) {
cin >> l >> r;
ll = max(l, ll);
rr = min(r, rr);
}
cout << rr - ll + 1 << endl;
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
#define mod (1e9 + 7)
#define pb push_back
using namespace std;
typedef pair<int, int> pii;
int main() {
int n, m;
cin >> n >> m;
int l, r, ll, rr;
ll = 0;
rr = n;
for (int i = 0; i < m; i++) {
cin >> l >> r;
ll = max(l, ll);
rr = min(r, rr);
}
cout << max(rr - ll + 1, 0) << endl;
return 0;
}
| [
"call.add",
"call.arguments.add"
] | 851,991 | 851,992 | u733823138 | cpp |
p03037 | #include <iostream>
#include <vector>
using namespace std;
int main(int argc, char *argv[]) {
int N, M, i, j;
cin >> N >> M;
vector<int> Pass(N + 1, 0);
int L, R;
int ans = 0;
int MaxL = 0;
int MinR = N;
for (i = 0; i < M; i++) {
cin >> L >> R;
if (MaxL < L) {
MaxL = L;
}
if (MinR > R) {
MinR = R;
}
}
if (MinR > MaxL) {
cout << MinR - MaxL + 1 << endl;
} else {
cout << 0 << endl;
}
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
int main(int argc, char *argv[]) {
int N, M, i, j;
cin >> N >> M;
vector<int> Pass(N + 1, 0);
int L, R;
int ans = 0;
int MaxL = 0;
int MinR = N;
for (i = 0; i < M; i++) {
cin >> L >> R;
if (MaxL < L) {
MaxL = L;
}
if (MinR > R) {
MinR = R;
}
}
if (MinR >= MaxL) {
cout << MinR - MaxL + 1 << endl;
} else {
cout << 0 << endl;
}
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 851,993 | 851,994 | u875570028 | cpp |
p03037 | #include <algorithm>
#include <iostream>
#include <iterator>
#include <sstream>
#include <vector>
using namespace std;
int main(void) {
int N, M;
cin >> N >> M;
vector<int> imos(N + 5, 0);
for (int i = 0; i < M; i++) {
int L, R;
cin >> L >> R;
imos[L]++;
imos[R + 1]--;
}
for (int i = 0; i < N + 4; i++)
imos[i + 1] += imos[i];
int cnt = 0;
for (int i = 0; i < N + 5; i++)
if (imos[i] == N)
cnt++;
cout << cnt << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <iterator>
#include <sstream>
#include <vector>
using namespace std;
int main(void) {
int N, M;
cin >> N >> M;
vector<int> imos(N + 5, 0);
for (int i = 0; i < M; i++) {
int L, R;
cin >> L >> R;
imos[L]++;
imos[R + 1]--;
}
for (int i = 0; i < N + 4; i++)
imos[i + 1] += imos[i];
int cnt = 0;
for (int i = 0; i < N + 5; i++)
if (imos[i] == M)
cnt++;
cout << cnt << endl;
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 852,004 | 852,005 | u013936801 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, n, a, b;
cin >> n >> m;
vector<int> L(m);
vector<int> R(m);
for (int i = 0; i < m; i++) {
cin >> L.at(i) >> R.at(i);
}
a = L.at(0), b = R.at(0);
for (int i = 1; i < m; i++) {
if (a < L.at(i)) {
a = L.at(i);
}
if (b > R.at(i)) {
b = R.at(i);
}
}
if (b - a + 1 < 1) {
cout << 0 << endl;
}
cout << b - a + 1 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int m, n, a, b;
cin >> n >> m;
vector<int> L(m);
vector<int> R(m);
for (int i = 0; i < m; i++) {
cin >> L.at(i) >> R.at(i);
}
a = L.at(0), b = R.at(0);
for (int i = 1; i < m; i++) {
if (a < L.at(i)) {
a = L.at(i);
}
if (b > R.at(i)) {
b = R.at(i);
}
}
if (b - a + 1 < 1) {
cout << 0 << endl;
} else {
cout << b - a + 1 << endl;
}
}
| [
"control_flow.branch.else.add"
] | 852,010 | 852,011 | u201743726 | cpp |
p03037 | #include <iostream>
using namespace std;
main() {
int N, M, L, R, min_x, max_x;
cin >> N >> M;
min_x = 1;
max_x = N;
for (int j = 1; j < M + 1; j++) {
cin >> L >> R;
if (R <= min_x || L >= max_x) {
cout << 0 << endl;
exit(0);
}
if (L >= min_x)
min_x = L;
if (R <= max_x)
max_x = R;
}
cout << max_x - min_x + 1 << endl;
} | #include <iostream>
using namespace std;
main() {
int N, M, L, R, min_x, max_x;
cin >> N >> M;
min_x = 1;
max_x = N;
for (int j = 1; j < M + 1; j++) {
cin >> L >> R;
if (R < min_x || L > max_x) {
cout << 0 << endl;
exit(0);
}
if (L >= min_x)
min_x = L;
if (R <= max_x)
max_x = R;
}
cout << max_x - min_x + 1 << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 852,012 | 852,013 | u139112688 | cpp |
p03037 | #include <iostream>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int l[m], r[m];
int left, right;
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
}
int count = 0;
for (int j = 0; j < m; j++) {
if (j == 0) {
left = l[0];
right = r[0];
}
if (j > 0) { // 2nd iteration
if (l[j] > left) {
left = l[j];
}
if (r[j] < right) {
right = r[j];
}
}
}
if (right == left) {
printf("%d", right - left + 1);
} else {
printf("0");
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int l[m], r[m];
int left, right;
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
}
int count = 0;
for (int j = 0; j < m; j++) {
if (j == 0) {
left = l[0];
right = r[0];
}
if (j > 0) { // 2nd iteration
if (l[j] > left) {
left = l[j];
}
if (r[j] < right) {
right = r[j];
}
}
}
if (right == left || right > left) {
printf("%d", right - left + 1);
} else {
printf("0");
}
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 852,014 | 852,015 | u793225530 | cpp |
p03037 | #include <iostream>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int l[m], r[m];
int left, right;
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
}
int count = 0;
for (int j = 0; j < m; j++) {
if (j == 0) {
left = l[0];
right = r[0];
}
if (j > 0) { // 2nd iteration
if (l[j] > left) {
left = l[j];
}
if (r[j] < right) {
right = r[j];
}
}
}
if ((right - left) > 0) {
printf("%d", right - left + 1);
} else {
printf("0");
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int l[m], r[m];
int left, right;
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
}
int count = 0;
for (int j = 0; j < m; j++) {
if (j == 0) {
left = l[0];
right = r[0];
}
if (j > 0) { // 2nd iteration
if (l[j] > left) {
left = l[j];
}
if (r[j] < right) {
right = r[j];
}
}
}
if (right == left || right > left) {
printf("%d", right - left + 1);
} else {
printf("0");
}
return 0;
} | [
"control_flow.branch.if.condition.change",
"identifier.replace.add",
"literal.replace.remove"
] | 852,016 | 852,015 | u793225530 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define MOD 1000000007
#define INF (1e9)
#define PI (acos(-1))
#define print(x) cout << x << endl
#define yes cout << "Yes" << endl
#define YES cout << "YES" << endl
#define no cout << "No" << endl
#define NO cout << "NO" << endl
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
rep(i, M) cin >> L[i] >> R[i];
sort(all(L));
sort(all(R));
int ans = R[0] - L[L.size() - 1] + 1;
if (ans >= 0)
print(ans);
else
(0);
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define MOD 1000000007
#define INF (1e9)
#define PI (acos(-1))
#define print(x) cout << x << endl
#define yes cout << "Yes" << endl
#define YES cout << "YES" << endl
#define no cout << "No" << endl
#define NO cout << "NO" << endl
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
rep(i, M) cin >> L[i] >> R[i];
sort(all(L));
sort(all(R));
int ans = R[0] - L[L.size() - 1] + 1;
if (ans >= 0)
print(ans);
else
print(0);
}
| [
"call.add"
] | 852,017 | 852,018 | u319234342 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define MOD 1000000007
#define INF (1e9)
#define PI (acos(-1))
#define print(x) cout << x << endl
#define yes cout << "Yes" << endl
#define YES cout << "YES" << endl
#define no cout << "No" << endl
#define NO cout << "NO" << endl
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
rep(i, M) cin >> L[i] >> R[i];
sort(all(L));
sort(all(R));
ll ans = R[0] - L[L.size() - 1] + 1;
if (ans > 0)
print(ans);
else
(0);
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define MOD 1000000007
#define INF (1e9)
#define PI (acos(-1))
#define print(x) cout << x << endl
#define yes cout << "Yes" << endl
#define YES cout << "YES" << endl
#define no cout << "No" << endl
#define NO cout << "NO" << endl
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
rep(i, M) cin >> L[i] >> R[i];
sort(all(L));
sort(all(R));
int ans = R[0] - L[L.size() - 1] + 1;
if (ans >= 0)
print(ans);
else
print(0);
}
| [
"variable_declaration.type.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"call.add"
] | 852,019 | 852,018 | u319234342 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define MOD 1000000007
#define INF (1e9)
#define PI (acos(-1))
#define print(x) cout << x << endl
#define yes cout << "Yes" << endl
#define YES cout << "YES" << endl
#define no cout << "No" << endl
#define NO cout << "NO" << endl
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
rep(i, M) cin >> L[i] >> R[i];
sort(all(L));
sort(all(R));
int ans = R[0] - L[L.size() - 1] + 1;
if (ans > 0)
print(ans);
else
(0);
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define MOD 1000000007
#define INF (1e9)
#define PI (acos(-1))
#define print(x) cout << x << endl
#define yes cout << "Yes" << endl
#define YES cout << "YES" << endl
#define no cout << "No" << endl
#define NO cout << "NO" << endl
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
rep(i, M) cin >> L[i] >> R[i];
sort(all(L));
sort(all(R));
int ans = R[0] - L[L.size() - 1] + 1;
if (ans >= 0)
print(ans);
else
print(0);
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"call.add"
] | 852,020 | 852,018 | u319234342 | cpp |
p03037 | #include <stdio.h>
int main(void) {
int n, m, i, j, k = 0, o = 0, p = 9999999, s, t;
scanf("%d %d", &n, &m);
int l[m];
int r[m];
for (i = 0; i < m; i++) {
scanf("%d %d", &l[i], &r[i]);
}
for (s = 0; s < m; s++) {
if (o < l[s]) {
o = l[s];
}
}
for (t = 0; t < m; t++) {
if (p > l[t]) {
p = l[t];
}
}
for (j = 0; j < n; j++) {
if (o <= j + 1 && j + 1 <= p) {
k = k + 1;
} else {
k = k;
}
}
printf("%d\n", k);
return 0;
}
| #include <stdio.h>
int main(void) {
int n, m, i, j, k = 0, o = 0, p = 9999999, s, t;
scanf("%d %d", &n, &m);
int l[m];
int r[m];
for (i = 0; i < m; i++) {
scanf("%d %d", &l[i], &r[i]);
}
for (s = 0; s < m; s++) {
if (o < l[s]) {
o = l[s];
}
}
for (t = 0; t < m; t++) {
if (p > r[t]) {
p = r[t];
}
}
for (j = 0; j < n; j++) {
if (o <= j + 1 && j + 1 <= p) {
k = k + 1;
} else {
k = k;
}
}
printf("%d\n", k);
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change",
"assignment.value.change"
] | 852,022 | 852,023 | u222643545 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.