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 |
|---|---|---|---|---|---|---|---|
p03061 | #include <bits/stdc++.h>
using namespace std;
int Gcd(int a, int b) {
if (b == 0)
return a;
return Gcd(b, a % b);
}
int main() {
int N;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++)
cin >> A[i];
vector<int> L(N), R(N);
L[1] = A[0], R[N - 2] = A[N - 1];
for (int i = 2; i < N; i++)
L[i] = Gcd(L[i - 1], A[i - 1]);
for (int i = N - 3; i >= 0; i--)
R[i] = Gcd(R[i + 1], A[i + 1]);
L[0] = R[0], R[N - 1] = A[N - 1];
int ans = 0;
for (int i = 0; i < N; i++)
ans = max(Gcd(L[i], R[i]), ans);
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int Gcd(int a, int b) {
if (b == 0)
return a;
return Gcd(b, a % b);
}
int main() {
int N;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++)
cin >> A[i];
vector<int> L(N), R(N);
L[1] = A[0], R[N - 2] = A[N - 1];
for (int i = 2; i < N; i++)
L[i] = Gcd(L[i - 1], A[i - 1]);
for (int i = N - 3; i >= 0; i--)
R[i] = Gcd(R[i + 1], A[i + 1]);
L[0] = R[0], R[N - 1] = L[N - 1];
int ans = 0;
for (int i = 0; i < N; i++)
ans = max(Gcd(L[i], R[i]), ans);
cout << ans << endl;
} | [
"assignment.value.change",
"identifier.change"
] | 877,557 | 877,558 | u879581330 | cpp |
p03061 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define forx(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) for (int i = 0; i < (n); i++)
int main(void) {
int n;
cin >> n;
vector<int> s(n);
for (auto &tmp : s) {
cin >> tmp;
}
int L[n], R[n];
L[0] = s[0];
R[n - 1] = s[n - 1];
for (int i = 1; i < n; i++) {
L[i] = __gcd(L[i - 1], s[i]);
}
for (int i = n - 2; i >= 0; i--) {
R[i] = __gcd(R[i + 1], s[i]);
}
int m = max(R[0], L[n - 1]);
for (int i = 1; i < n - 1; i++) {
m = max(m, __gcd(L[i - 1], R[i + 1]));
}
cout << m << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define forx(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) for (int i = 0; i < (n); i++)
int main(void) {
int n;
cin >> n;
vector<int> s(n);
for (auto &tmp : s) {
cin >> tmp;
}
int L[n], R[n];
L[0] = s[0];
R[n - 1] = s[n - 1];
for (int i = 1; i < n; i++) {
L[i] = __gcd(L[i - 1], s[i]);
}
for (int i = n - 2; i >= 0; i--) {
R[i] = __gcd(R[i + 1], s[i]);
}
int m = max(R[1], L[n - 2]);
for (int i = 1; i < n - 1; i++) {
m = max(m, __gcd(L[i - 1], R[i + 1]));
}
cout << m << endl;
return 0;
} | [
"literal.number.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 877,559 | 877,560 | u850779832 | cpp |
p03061 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define INF 1e9
#define LINF 1e18
#define FOR(i, j, k) for (int i = j; i < k; ++i)
#define rep(i, j) FOR(i, 0, j)
#define FORr(i, j, k) for (int i = j; i >= k; --i)
#define repr(i, j) FOR(i, j, 0)
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef pair<int, P> Pi;
typedef pair<P, P> PP;
const int MOD = 1e9 + 7;
const int dy[] = {0, 0, 1, -1};
const int dx[] = {1, -1, 0, 0};
template <class T> void chmin(T &a, const T &b) { a = min(a, b); }
template <class T> void chmax(T &a, const T &b) { a = max(a, b); }
int N, A[100000];
int lgcd[100000], rgcd[100000];
int gcd(int x, int y) { return y == 0 ? x : gcd(y, x % y); }
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N;
rep(i, N) cin >> A[i];
lgcd[0] = A[0];
rgcd[N - 1] = A[N - 1];
FOR(i, 1, N) lgcd[i] = gcd(lgcd[i - 1], A[i]);
FORr(i, N - 2, 0) rgcd[i] = gcd(rgcd[i + 1], A[i]);
int res = rgcd[1];
FOR(i, 1, N - 1) chmax(res, gcd(lgcd[i - 1], rgcd[i + 1]));
chmax(res, lgcd[N - 1]);
cout << res << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define INF 1e9
#define LINF 1e18
#define FOR(i, j, k) for (int i = j; i < k; ++i)
#define rep(i, j) FOR(i, 0, j)
#define FORr(i, j, k) for (int i = j; i >= k; --i)
#define repr(i, j) FOR(i, j, 0)
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef pair<int, P> Pi;
typedef pair<P, P> PP;
const int MOD = 1e9 + 7;
const int dy[] = {0, 0, 1, -1};
const int dx[] = {1, -1, 0, 0};
template <class T> void chmin(T &a, const T &b) { a = min(a, b); }
template <class T> void chmax(T &a, const T &b) { a = max(a, b); }
int N, A[100000];
int lgcd[100000], rgcd[100000];
int gcd(int x, int y) { return y == 0 ? x : gcd(y, x % y); }
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N;
rep(i, N) cin >> A[i];
lgcd[0] = A[0];
rgcd[N - 1] = A[N - 1];
FOR(i, 1, N) lgcd[i] = gcd(lgcd[i - 1], A[i]);
FORr(i, N - 2, 0) rgcd[i] = gcd(rgcd[i + 1], A[i]);
int res = rgcd[1];
FOR(i, 1, N - 1) chmax(res, gcd(lgcd[i - 1], rgcd[i + 1]));
chmax(res, lgcd[N - 2]);
cout << res << endl;
return 0;
}
| [
"literal.number.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 877,561 | 877,562 | u292929213 | cpp |
p03061 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define forx(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) for (int i = 0; i < (n); i++)
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> a(n), c(n), d(n), x(n);
rep(i, n) cin >> a[i];
c[0] = a[0];
d[n - 1] = a[n - 1];
forx(i, 1, n) {
c[i] = __gcd(c[i - 1], a[i]);
d[n - 1 - i] = __gcd(d[n - i], a[n - i - 1]);
}
forx(i, 1, n - 1) { x[i] = __gcd(c[i - 1], d[i + 1]); }
x[0] = d[1];
x[n - 1] = c[n - 1];
sort(x.begin(), x.end());
cout << x[n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define forx(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) for (int i = 0; i < (n); i++)
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> a(n), c(n), d(n), x(n);
rep(i, n) cin >> a[i];
c[0] = a[0];
d[n - 1] = a[n - 1];
forx(i, 1, n) {
c[i] = __gcd(c[i - 1], a[i]);
d[n - 1 - i] = __gcd(d[n - i], a[n - i - 1]);
}
forx(i, 1, n - 1) { x[i] = __gcd(c[i - 1], d[i + 1]); }
x[0] = d[1];
x[n - 1] = c[n - 2];
sort(x.begin(), x.end());
cout << x[n - 1] << endl;
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 877,566 | 877,567 | u604231488 | cpp |
p03061 | #include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<int> l(n);
vector<int> r(n);
for (int i = 0; i < n; i++) {
l[i + 1] = gcd(l[i], a[i]);
}
for (int i = 0; i < n; i++) {
r[i + 1] = gcd(r[i], a[n - i - 1]);
}
int ans = 0;
for (int i = 0; i < n; i++) {
int g = gcd(l[i], r[n - 1 - i]);
ans = max(ans, g);
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<int> l(n + 1);
vector<int> r(n + 1);
for (int i = 0; i < n; i++) {
l[i + 1] = gcd(l[i], a[i]);
}
for (int i = 0; i < n; i++) {
r[i + 1] = gcd(r[i], a[n - i - 1]);
}
int ans = 0;
for (int i = 0; i < n; i++) {
int g = gcd(l[i], r[n - 1 - i]);
ans = max(ans, g);
}
cout << ans << endl;
}
| [
"assignment.change"
] | 877,573 | 877,574 | u410878763 | cpp |
p03061 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define ALL(v) (v).begin(), (v).end()
#define ios() \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
using ll = long long;
using ull = unsigned long long;
using vi = vector<int>;
using vvi = vector<vi>;
using pii = pair<int, int>;
constexpr ll MOD = 1e9 + 7;
constexpr ll INF = 1LL << 60;
constexpr int Inf = 1e9;
inline int in() {
int x;
cin >> x;
return x;
}
template <typename T> inline void out(const T &x) { cout << x << endl; }
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
// UP = 0;RIGHT = 1; DOWN = 2; LEFT =3;
const int dx[] = {0, 1, 0, -1, 1, -1, 1, -1},
dy[] = {1, 0, -1, 0, 1, -1, -1, 1};
int gcd(int a, int b) {
if (a < b)
gcd(b, a);
if (b == 0)
return a;
int r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
void eratos(bool *isPrime, int max) {
fill(isPrime, isPrime + max, true);
isPrime[0] = false;
isPrime[1] = false;
for (int i = 2; i <= max / i; ++i)
if (isPrime[i])
for (int j = 2; j <= max / i; ++j)
isPrime[i * j] = false;
}
//
signed main() {
ios();
int N;
cin >> N;
vi A(N);
rep(i, N) { cin >> A[i]; }
vi L(N + 1), R(N + 1);
L[0] = 0;
R[N] = 0;
rep(i, N) { L[i + 1] = gcd(L[i], A[i]); }
for (int i = N; i > 0; i--) {
R[i - 1] = gcd(R[i], A[i - 1]);
}
int ans = 0;
rep(i, N - 1) { chmax(ans, gcd(L[i], R[i + 1])); }
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define ALL(v) (v).begin(), (v).end()
#define ios() \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
using ll = long long;
using ull = unsigned long long;
using vi = vector<int>;
using vvi = vector<vi>;
using pii = pair<int, int>;
constexpr ll MOD = 1e9 + 7;
constexpr ll INF = 1LL << 60;
constexpr int Inf = 1e9;
inline int in() {
int x;
cin >> x;
return x;
}
template <typename T> inline void out(const T &x) { cout << x << endl; }
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
// UP = 0;RIGHT = 1; DOWN = 2; LEFT =3;
const int dx[] = {0, 1, 0, -1, 1, -1, 1, -1},
dy[] = {1, 0, -1, 0, 1, -1, -1, 1};
int gcd(int a, int b) {
if (a < b)
gcd(b, a);
if (b == 0)
return a;
int r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
void eratos(bool *isPrime, int max) {
fill(isPrime, isPrime + max, true);
isPrime[0] = false;
isPrime[1] = false;
for (int i = 2; i <= max / i; ++i)
if (isPrime[i])
for (int j = 2; j <= max / i; ++j)
isPrime[i * j] = false;
}
//
signed main() {
ios();
int N;
cin >> N;
vi A(N);
rep(i, N) { cin >> A[i]; }
vi L(N + 1), R(N + 1);
L[0] = 0;
R[N] = 0;
rep(i, N) { L[i + 1] = gcd(L[i], A[i]); }
for (int i = N; i > 0; i--) {
R[i - 1] = gcd(R[i], A[i - 1]);
}
int ans = 0;
rep(i, N) { chmax(ans, gcd(L[i], R[i + 1])); }
cout << ans << endl;
}
| [
"expression.operation.binary.remove"
] | 877,588 | 877,589 | u904833081 | cpp |
p03061 | #include <bits/stdc++.h>
using namespace std;
#define int long long int
#define endl "\n"
const int MOD = 1e9 + 7;
#ifndef HOME
#define cerr \
if (0) \
cerr
#endif
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int a[n];
int pre[n + 5];
int suf[n + 5];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
pre[0] = a[0];
for (int i = 1; i < n; i++) {
pre[i] = __gcd(pre[i - 1], a[i]);
}
suf[n - 1] = a[n - 1];
for (int i = n - 2; i >= 0; i--) {
suf[i] = __gcd(suf[i + 1], a[i]);
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (i == 0) {
ans = max(ans, suf[i + 1]);
} else if (i == n - 1) {
ans = max(ans, pre[n - 1]);
} else {
ans = max(ans, __gcd(pre[i - 1], suf[i + 1]));
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long int
#define endl "\n"
const int MOD = 1e9 + 7;
#ifndef HOME
#define cerr \
if (0) \
cerr
#endif
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int a[n];
int pre[n + 5];
int suf[n + 5];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
pre[0] = a[0];
for (int i = 1; i < n; i++) {
pre[i] = __gcd(pre[i - 1], a[i]);
}
suf[n - 1] = a[n - 1];
for (int i = n - 2; i >= 0; i--) {
suf[i] = __gcd(suf[i + 1], a[i]);
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (i == 0) {
ans = max(ans, suf[i + 1]);
} else if (i == n - 1) {
ans = max(ans, pre[n - 2]);
} else {
ans = max(ans, __gcd(pre[i - 1], suf[i + 1]));
}
}
cout << ans << endl;
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 877,590 | 877,591 | u124992729 | cpp |
p03061 | #define __USE_MINGW_ANSI_STDIO 0
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <limits.h>
#include <map>
#include <numeric>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
typedef unsigned long ul;
typedef pair<ul, ul> P;
const int INF = 1e9;
long long gcd(long long x, long long y) {
if (x == 0)
return y;
if (y == 0)
return x;
if (x < y) {
long long temp = x;
x = y;
y = temp;
}
long long r = x % y;
while (r != 0) {
x = y;
y = r;
r = x % y;
}
return y;
}
int main() {
int N;
cin >> N;
vector<int> A(N);
vector<int> left(N + 1, 0);
vector<int> right(N + 1, 0);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
for (int i = 0; i < N; i++)
left[i + 1] = gcd(left[i], A[i]);
for (int i = N - 1; i >= 0; i--)
right[i] = gcd(right[i + 1], A[i]);
long long ans = 1;
for (int i = 0; i <= N + 1; i++) {
long long r = right[i + 1];
long long l = left[i];
ans = max(ans, gcd(l, r));
}
cout << ans << endl;
} | #define __USE_MINGW_ANSI_STDIO 0
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <limits.h>
#include <map>
#include <numeric>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
typedef unsigned long ul;
typedef pair<ul, ul> P;
const int INF = 1e9;
long long gcd(long long x, long long y) {
if (x == 0)
return y;
if (y == 0)
return x;
if (x < y) {
long long temp = x;
x = y;
y = temp;
}
long long r = x % y;
while (r != 0) {
x = y;
y = r;
r = x % y;
}
return y;
}
int main() {
int N;
cin >> N;
vector<int> A(N);
vector<int> left(N + 1, 0);
vector<int> right(N + 1, 0);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
for (int i = 0; i < N; i++)
left[i + 1] = gcd(left[i], A[i]);
for (int i = N - 1; i >= 0; i--)
right[i] = gcd(right[i + 1], A[i]);
long long ans = 1;
for (int i = 0; i <= N; i++) {
long long r = right[i + 1];
long long l = left[i];
ans = max(ans, gcd(l, r));
}
cout << ans << endl;
} | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 877,598 | 877,599 | u403848488 | cpp |
p03061 | #define __USE_MINGW_ANSI_STDIO 0
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <limits.h>
#include <map>
#include <numeric>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
typedef unsigned long ul;
typedef pair<ul, ul> P;
const int INF = 1e9;
long long gcd(long long x, long long y) {
if (x == 0)
return y;
if (y == 0)
return x;
if (x < y) {
long long temp = x;
x = y;
y = temp;
}
long long r = x % y;
while (r != 0) {
x = y;
y = r;
r = x % y;
}
return y;
}
int main() {
int N;
cin >> N;
vector<int> A(N);
vector<int> left(N + 1, 0);
vector<int> right(N + 1, 0);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
for (int i = 0; i < N; i++)
left[i + 1] = gcd(left[i], A[i]);
for (int i = N - 1; i >= 0; i--)
right[i] = gcd(right[i + 1], A[i]);
long long ans = 0;
for (int i = 0; i <= N + 1; i++) {
long long r = right[i + 1];
long long l = left[i];
ans = max(ans, gcd(l, r));
}
cout << ans << endl;
} | #define __USE_MINGW_ANSI_STDIO 0
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <limits.h>
#include <map>
#include <numeric>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
typedef unsigned long ul;
typedef pair<ul, ul> P;
const int INF = 1e9;
long long gcd(long long x, long long y) {
if (x == 0)
return y;
if (y == 0)
return x;
if (x < y) {
long long temp = x;
x = y;
y = temp;
}
long long r = x % y;
while (r != 0) {
x = y;
y = r;
r = x % y;
}
return y;
}
int main() {
int N;
cin >> N;
vector<int> A(N);
vector<int> left(N + 1, 0);
vector<int> right(N + 1, 0);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
for (int i = 0; i < N; i++)
left[i + 1] = gcd(left[i], A[i]);
for (int i = N - 1; i >= 0; i--)
right[i] = gcd(right[i + 1], A[i]);
long long ans = 1;
for (int i = 0; i <= N; i++) {
long long r = right[i + 1];
long long l = left[i];
ans = max(ans, gcd(l, r));
}
cout << ans << endl;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 877,600 | 877,599 | u403848488 | cpp |
p03067 |
#include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <deque> // deque
#include <iomanip>
#include <iostream>
#include <map> // map
#include <numeric>
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <stdio.h>
#include <string> // string, to_string, stoi
#include <tuple> // tuple, make_tuple
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <utility> // pair, make_pair
#include <vector> // vector
using namespace std;
using ll = long long;
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
int Max(int(a), int(b), int(c)) { return max(max(a, b), c); }
int Min(int(a), int(b), int(c)) { return min(min(a, b), c); }
int main() {
ll N, K, M;
cin >> N >> K >> M;
string s = "No";
if ((N - M) * (K - M) < 0) {
s = "Yes";
}
cout << N - K + 1 << endl;
} |
#include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <deque> // deque
#include <iomanip>
#include <iostream>
#include <map> // map
#include <numeric>
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <stdio.h>
#include <string> // string, to_string, stoi
#include <tuple> // tuple, make_tuple
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <utility> // pair, make_pair
#include <vector> // vector
using namespace std;
using ll = long long;
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
int Max(int(a), int(b), int(c)) { return max(max(a, b), c); }
int Min(int(a), int(b), int(c)) { return min(min(a, b), c); }
int main() {
ll N, K, M;
cin >> N >> K >> M;
string s = "No";
if ((N - M) * (K - M) < 0) {
s = "Yes";
}
cout << s << endl;
} | [
"identifier.change",
"io.output.change",
"expression.operation.binary.remove"
] | 877,619 | 877,620 | u927801748 | cpp |
p03067 | /**
* purpose :
* author : kyomukyomupurin
* created :
**/
// input/output
#include <fstream>
#include <iostream>
#include <sstream>
// container class
#include <array>
#include <deque>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
// math, algorithm
#include <algorithm>
#include <cmath>
#include <complex>
#include <numeric>
// etc
#include <bitset>
#include <cctype>
#include <chrono>
#include <cstring>
#include <iomanip>
#include <random>
#include <utility>
// using-directive
using namespace std;
// alias template
using int64 = int64_t;
using pii = pair<int, int>;
using pll = pair<int64_t, int64_t>;
// text macro replacement
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define print(x) cout << (x) << '\n'
#define debug(x) cout << #x << ": " << (x) << '\n'
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int a, b, c;
cin >> a >> b >> c;
if (a > b && b < c)
print("Yes");
else if (a < b && b > c)
print("Yes");
else
print("No");
return 0;
} | #pragma region kyomukyomupurin
/**
* author : 𝒌𝒚𝒐𝒎𝒖𝒌𝒚𝒐𝒎𝒖𝒑𝒖𝒓𝒊𝒏
* created : 2020-04-24 18:55:13
**/
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <chrono>
#include <cmath>
#include <complex>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using int64 = long long;
template <class T>
using binary_heap = std::priority_queue<T, std::vector<T>, std::greater<T>>;
template <class T, class U>
std::ostream &operator<<(std::ostream &os, const std::pair<T, U> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
template <class T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &vec) {
int flag = 0;
for (auto e : vec)
os << (flag++ ? ", " : "{") << e;
return os << '}';
}
template <class T>
std::ostream &operator<<(std::ostream &os, const std::set<T> &st) {
int flag = 0;
for (auto e : st)
os << (flag++ ? ", " : "{") << e;
return os << '}';
}
template <class T, class U>
std::ostream &operator<<(std::ostream &os, const std::map<T, U> &mp) {
int flag = 0;
for (auto e : mp)
os << (flag++ ? ", " : "{") << e;
return os << '}';
}
template <class T>
std::istream &operator>>(std::istream &is, std::vector<T> &vec) {
for (T &e : vec)
is >> e;
return is;
}
#define all(_) begin(_), end(_)
#define rall(_) rbegin(_), rend(_)
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]: ", debug_out(__VA_ARGS__)
#else
#define debug(...)
#endif
void debug_out() { std::cerr << '\n'; }
template <class Head, class... Tail>
void debug_out(Head &&head, Tail &&...tail) {
std::cerr << head;
if (sizeof...(Tail) != 0)
std::cerr << ", ";
debug_out(std::forward<Tail>(tail)...);
}
#pragma endregion kyomukyomupurin
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int a, b, c;
cin >> a >> b >> c;
// a < c < b
// a > c > b
if ((a < c && c < b) || (a > c && c > b)) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | [] | 877,623 | 877,624 | u095266283 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << (((A < C && C < A) || (A > C && C > B)) ? "Yes" : "No") << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << (((A < C && C < B) || (A > C && C > B)) ? "Yes" : "No") << endl;
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"io.output.change"
] | 877,625 | 877,626 | u379168673 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
#define repr(i, a, b) for (int i = a; i < b; i++)
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
#define mod 1000000007
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
int main() {
int a, b, c;
cin >> a >> b >> c;
if ((a < c && c << b) || (b < c && c << a))
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define repr(i, a, b) for (int i = a; i < b; i++)
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
#define mod 1000000007
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
int main() {
int a, b, c;
cin >> a >> b >> c;
if ((a < c && c < b) || (b < c && c < a))
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| [
"misc.typo",
"control_flow.branch.if.condition.change"
] | 877,635 | 877,636 | u426143712 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) \
; \
for (int i = 0; i < n; ++i)
using ll = long long;
using P = pair<int, int>;
int main() {
int a, b, c;
cin >> a >> b >> c;
int x = max(a, b);
int y = min(a, b);
if (y <= c && y <= x)
puts("Yes");
else
puts("No");
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) \
; \
for (int i = 0; i < n; ++i)
using ll = long long;
using P = pair<int, int>;
int main() {
int a, b, c;
cin >> a >> b >> c;
int x = max(a, b);
int y = min(a, b);
if (y <= c && c <= x)
puts("Yes");
else
puts("No");
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 877,639 | 877,640 | u375398641 | cpp |
p03067 | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define REP(i, a, b) for (int i = a; i < (b); ++i)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define YY cout << "Yes" << endl
#define NN cout << "No" << endl
#define pint pair<int, int>
#define vi(v) rep(i, v.size()) cin >> v[i]
#define vc(v) rep(i, v.size()) cout << v[i] << endl
#define ni(n) cin >> n
#define nc(n) cout << n << endl
const int INF = 1000000007;
const long double EPS = 1e-15;
const long double PI = acos(-1);
typedef long long ll;
using namespace std;
using Graph = vector<vector<int>>;
using Graph_weighted = vector<vector<pair<int, int>>>;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return (a * b) / gcd(a, b); }
int solve() {
int a, b, c;
cin >> a >> b >> c;
int A = max(a, b), B = min(a, b);
if (b <= c && c <= a)
YY;
else
NN;
return 0;
}
int main() {
// ios::sync_with_stdio(false);cin.tie(nullptr);
// cout << fixed;cout << setprecision(16);
solve();
return 0;
}
| #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define REP(i, a, b) for (int i = a; i < (b); ++i)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define YY cout << "Yes" << endl
#define NN cout << "No" << endl
#define pint pair<int, int>
#define vi(v) rep(i, v.size()) cin >> v[i]
#define vc(v) rep(i, v.size()) cout << v[i] << endl
#define ni(n) cin >> n
#define nc(n) cout << n << endl
const int INF = 1000000007;
const long double EPS = 1e-15;
const long double PI = acos(-1);
typedef long long ll;
using namespace std;
using Graph = vector<vector<int>>;
using Graph_weighted = vector<vector<pair<int, int>>>;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return (a * b) / gcd(a, b); }
int solve() {
int a, b, c;
cin >> a >> b >> c;
int A = max(a, b), B = min(a, b);
if (B <= c && c <= A)
YY;
else
NN;
return 0;
}
int main() {
// ios::sync_with_stdio(false);cin.tie(nullptr);
// cout << fixed;cout << setprecision(16);
solve();
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 877,641 | 877,642 | u820341516 | cpp |
p03067 | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define REP(i, a, b) for (int i = a; i < (b); ++i)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define YY cout << "Yes" << endl
#define NN cout << "No" << endl
#define pint pair<int, int>
#define vi(v) rep(i, v.size()) cin >> v[i]
#define vc(v) rep(i, v.size()) cout << v[i] << endl
#define ni(n) cin >> n
#define nc(n) cout << n << endl
const int INF = 1000000007;
const long double EPS = 1e-15;
const long double PI = acos(-1);
typedef long long ll;
using namespace std;
using Graph = vector<vector<int>>;
using Graph_weighted = vector<vector<pair<int, int>>>;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return (a * b) / gcd(a, b); }
int solve() {
int a, b, c;
cin >> a >> b >> c;
int A = max(a, b), B = min(a, b);
if (a <= c && c <= b)
YY;
else
NN;
return 0;
}
int main() {
// ios::sync_with_stdio(false);cin.tie(nullptr);
// cout << fixed;cout << setprecision(16);
solve();
return 0;
}
| #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define REP(i, a, b) for (int i = a; i < (b); ++i)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define YY cout << "Yes" << endl
#define NN cout << "No" << endl
#define pint pair<int, int>
#define vi(v) rep(i, v.size()) cin >> v[i]
#define vc(v) rep(i, v.size()) cout << v[i] << endl
#define ni(n) cin >> n
#define nc(n) cout << n << endl
const int INF = 1000000007;
const long double EPS = 1e-15;
const long double PI = acos(-1);
typedef long long ll;
using namespace std;
using Graph = vector<vector<int>>;
using Graph_weighted = vector<vector<pair<int, int>>>;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return (a * b) / gcd(a, b); }
int solve() {
int a, b, c;
cin >> a >> b >> c;
int A = max(a, b), B = min(a, b);
if (B <= c && c <= A)
YY;
else
NN;
return 0;
}
int main() {
// ios::sync_with_stdio(false);cin.tie(nullptr);
// cout << fixed;cout << setprecision(16);
solve();
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 877,643 | 877,642 | u820341516 | cpp |
p03067 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <string>
#include <vector>
#pragma region Macros
#define int long long
#define double long double
constexpr int MOD = 1000000007;
constexpr double PI = 3.14159265358979323846;
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n) for (int i = 1; i <= n; i++)
#define LAST(x) x[x.size() - 1]
#define ALL(x) (x).begin(), (x).end()
#define swap(a, b) (a += b, b = a - b, a -= b)
#define CEIL(a, b) ((a + b - 1) / b)
int FACT(int a) {
if (a == 0)
return 1;
else
return a * FACT(a - 1);
}
int nPr(int n, int r) {
int s = n - r + 1;
int sum = 1;
for (int i = s; i <= n; i++)
sum *= i;
return sum;
}
// int nCr1(int n, int r)
// int nCr2(int n, int r)
int GCD(int a, int b) // assuming a,b >= 1
{
if (a < b)
swap(a, b);
if (b == 0)
return a;
if (a % b == 0)
return b;
return GCD(b, a % b);
}
int LCM(int a, int b) // assuming a,b >= 1
{
return a * b / GCD(a, b);
}
double LOG(int a, int b) { return log(b) / log(a); }
inline bool BETWEEN(int x, int min, int max) {
if (min <= x && x <= max)
return true;
else
return false;
}
inline bool PRIMEOR(int x) {
if (x == 1)
return false;
if (x == 2)
return true;
if (x % 2 == 0)
return false;
double sqrtx = sqrt(x);
for (int i = 3; i <= sqrtx; i += 2) {
if (x % i == 0)
return false;
}
return true;
}
using namespace std;
#pragma endregion
signed main() {
int A, B, C;
cin >> A >> B >> C;
if (BETWEEN(B, min(A, C), max(A, C)))
cout << "Yes" << endl;
else
cout << "No";
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <string>
#include <vector>
#pragma region Macros
#define int long long
#define double long double
constexpr int MOD = 1000000007;
constexpr double PI = 3.14159265358979323846;
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n) for (int i = 1; i <= n; i++)
#define LAST(x) x[x.size() - 1]
#define ALL(x) (x).begin(), (x).end()
#define swap(a, b) (a += b, b = a - b, a -= b)
#define CEIL(a, b) ((a + b - 1) / b)
int FACT(int a) {
if (a == 0)
return 1;
else
return a * FACT(a - 1);
}
int nPr(int n, int r) {
int s = n - r + 1;
int sum = 1;
for (int i = s; i <= n; i++)
sum *= i;
return sum;
}
// int nCr1(int n, int r)
// int nCr2(int n, int r)
int GCD(int a, int b) // assuming a,b >= 1
{
if (a < b)
swap(a, b);
if (b == 0)
return a;
if (a % b == 0)
return b;
return GCD(b, a % b);
}
int LCM(int a, int b) // assuming a,b >= 1
{
return a * b / GCD(a, b);
}
double LOG(int a, int b) { return log(b) / log(a); }
inline bool BETWEEN(int x, int min, int max) {
if (min <= x && x <= max)
return true;
else
return false;
}
inline bool PRIMEOR(int x) {
if (x == 1)
return false;
if (x == 2)
return true;
if (x % 2 == 0)
return false;
double sqrtx = sqrt(x);
for (int i = 3; i <= sqrtx; i += 2) {
if (x % i == 0)
return false;
}
return true;
}
using namespace std;
#pragma endregion
signed main() {
int A, B, C;
cin >> A >> B >> C;
if (BETWEEN(C, min(A, B), max(A, B)))
cout << "Yes" << endl;
else
cout << "No";
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 877,650 | 877,651 | u545364250 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
int a, b, c;
int main() {
scanf("%d%d%d", &a, &b, &c);
if (a > b)
swap(a, b);
if (a < c && c < b)
puts("YES");
else
puts("NO");
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int a, b, c;
int main() {
scanf("%d%d%d", &a, &b, &c);
if (a > b)
swap(a, b);
if (a < c && c < b)
puts("Yes");
else
puts("No");
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"call.arguments.change",
"io.output.change"
] | 877,654 | 877,655 | u887700001 | cpp |
p03067 | #include "bits/stdc++.h"
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
int a = max(max(A, B), C);
int b = min(min(A, B), C);
if (B != a && B != b) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
| #include "bits/stdc++.h"
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
int a = max(max(A, B), C);
int b = min(min(A, B), C);
if (C != a && C != b) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 877,656 | 877,657 | u101808526 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
#define modulo 1000000007
#define mod(mod_x) ((((long long)mod_x + modulo)) % modulo)
#define Inf 1000000000
int main() {
int A, B, C;
cin >> A >> B >> C;
if ((A - B) * (C - B) < 0) {
cout << "No" << endl;
} else {
cout << "Yes" << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define modulo 1000000007
#define mod(mod_x) ((((long long)mod_x + modulo)) % modulo)
#define Inf 1000000000
int main() {
int A, B, C;
cin >> A >> B >> C;
if ((A - C) * (C - B) < 0) {
cout << "No" << endl;
} else {
cout << "Yes" << endl;
}
return 0;
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 877,668 | 877,669 | u118797367 | cpp |
p03067 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string>
#define rep(i, n) for (int i = 0; i < n; i++)
#define llint long long int
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a > c) {
swap(a, c);
}
if (c > a && c < b) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string>
#define rep(i, n) for (int i = 0; i < n; i++)
#define llint long long int
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a > b) {
swap(a, b);
}
if (c > a && c < b) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | [
"identifier.change",
"control_flow.branch.if.condition.change",
"call.arguments.change"
] | 877,689 | 877,690 | u274962354 | cpp |
p03067 | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a < c && b > c) {
cout << "YES" << endl;
} else if (a > c && b < c) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a < c && b > c) {
cout << "Yes" << endl;
} else if (a > c && b < c) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 877,693 | 877,694 | u844201387 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
#define SZ(x) (int)(x.size())
using ll = long long;
using ld = long double;
using P = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
const double eps = 1e-10;
const int MOD = 1000000007;
const int INF = 1000000000;
const ll LINF = 1ll << 50;
template <typename T> void printv(const vector<T> &s) {
for (int i = 0; i < (int)(s.size()); ++i) {
cout << s[i];
if (i == (int)(s.size()) - 1)
cout << endl;
else
cout << " ";
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
int a, b, c;
cin >> a >> b >> c;
if (a > c)
swap(a, c);
cout << (a < b && b < c ? "Yes" : "No") << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define SZ(x) (int)(x.size())
using ll = long long;
using ld = long double;
using P = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
const double eps = 1e-10;
const int MOD = 1000000007;
const int INF = 1000000000;
const ll LINF = 1ll << 50;
template <typename T> void printv(const vector<T> &s) {
for (int i = 0; i < (int)(s.size()); ++i) {
cout << s[i];
if (i == (int)(s.size()) - 1)
cout << endl;
else
cout << " ";
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
int a, b, c;
cin >> a >> c >> b;
if (a > c)
swap(a, c);
cout << (a < b && b < c ? "Yes" : "No") << endl;
}
| [
"expression.operation.binary.remove"
] | 877,697 | 877,698 | u334351654 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, j, n) for (int i = j; i < n; i++)
#define all(x) (x).begin(), (x).end()
#define pii pair<int, int>
#define pll pair<ll, ll>
#define vc vector
#define a first
#define b second
#define pb pusu_back
#define INF (1000000000)
#define MOD (1000000007)
#define MAX (5000000)
/////////////////////////////////////////////////////////
class XY {
public:
ll x, y;
XY() { x = y = 0; }
XY(ll u, ll v) {
x = u;
y = v;
}
};
template <typename T1, typename T2> void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
template <typename T1, typename T2> ll mypow(T1 a, T2 n) {
if (n == 0)
return 1;
if (n == 1)
return a;
if (n % 2)
return a * mypow(a, n - 1);
ll tmp = mypow(a, n / 2);
return tmp * tmp;
}
template <typename T> int BS(vector<T> &V, int left, int right, T key) {
int mid = (left + right) / 2;
if (V[mid] <= key)
left = mid;
else
right = mid;
if (right - mid == 1)
return left;
else
return BS(V, left, right, key);
}
ll comb(ll n, ll r) {
ll res = 1;
rep(i, 0, r) {
res *= n - i;
res /= i + 1;
}
return res;
}
template <typename T> T euclid(T a, T b) {
if (b == 0)
return a;
else
return euclid(b, a % b);
}
/////////////////////////////////////////////////////////
// MOD of Combination
/*
vector<ll> fact(MAX, 0), fact_inv(MAX, 0);
ll pow_mod(ll a, ll b){
ll res = 1;
while(b > 0){
if(b & 1) res = res * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return res;
}
void prepare_comb_mod(ll n){
fact[0] = 1LL;
for(ll i = 0; i < n; i++) fact[i+1] = fact[i] * (i + 1) % MOD;
fact_inv[n] = pow_mod(fact[n], MOD - 2);
for(ll i = n - 1; i >= 0; i--) fact_inv[i] = fact_inv[i + 1] * (i + 1) %
MOD;
}
ll comb_mod(ll n, ll r){
return (fact[n] * fact_inv[r]) % MOD * fact_inv[n - r] % MOD;
}
*/
/////////////////////////////////////////////////////////
// Union-Find Tree
template <class T> struct UFT {
vector<int> par;
vector<int> rank;
vector<T> diff_weight;
UFT(int n = 1, T w = 0) { init(n, w); }
void init(int n = 1, T w = 0) {
par.resize(n);
rank.resize(n);
diff_weight.resize(n);
rep(i, 0, n) {
par[i] = i;
rank[i] = 0;
diff_weight[i] = w;
}
}
int root(int x) {
if (par[x] == x) {
return x;
} else {
int r = root(par[x]);
diff_weight[x] += diff_weight[par[x]];
return par[x] = r;
}
}
bool unite(int x, int y, int w = 0) {
w += weight(x);
w -= weight(y);
x = root(x);
y = root(y);
if (x == y)
return false;
if (rank[x] < rank[y]) {
par[x] = y;
diff_weight[x] = -w;
} else {
par[y] = x;
diff_weight[y] = w;
if (rank[x] == rank[y])
rank[x]++;
}
return true;
}
bool same(int x, int y) { return root(x) == root(y); }
T weight(int x) {
root(x);
return diff_weight[x];
}
T diff(int x, int y) { return weight(y) - weight(x); }
};
/////////////////////////////////////////////////////////
void ans(bool b) {
if (b)
cout << "yes" << endl;
else
cout << "no" << endl;
}
void Ans(bool b) {
if (b)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
void ANS(bool b) {
if (b)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
/////////////////////////////////////////////////////////
void Main() {
int A, B, C;
cin >> A >> B >> C;
Ans(min(A, C) <= B && B <= max(A, C));
}
/////////////////////////////////////////////////////////
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << std::fixed << std::setprecision(15);
Main();
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, j, n) for (int i = j; i < n; i++)
#define all(x) (x).begin(), (x).end()
#define pii pair<int, int>
#define pll pair<ll, ll>
#define vc vector
#define a first
#define b second
#define pb pusu_back
#define INF (1000000000)
#define MOD (1000000007)
#define MAX (5000000)
/////////////////////////////////////////////////////////
class XY {
public:
ll x, y;
XY() { x = y = 0; }
XY(ll u, ll v) {
x = u;
y = v;
}
};
template <typename T1, typename T2> void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
template <typename T1, typename T2> ll mypow(T1 a, T2 n) {
if (n == 0)
return 1;
if (n == 1)
return a;
if (n % 2)
return a * mypow(a, n - 1);
ll tmp = mypow(a, n / 2);
return tmp * tmp;
}
template <typename T> int BS(vector<T> &V, int left, int right, T key) {
int mid = (left + right) / 2;
if (V[mid] <= key)
left = mid;
else
right = mid;
if (right - mid == 1)
return left;
else
return BS(V, left, right, key);
}
ll comb(ll n, ll r) {
ll res = 1;
rep(i, 0, r) {
res *= n - i;
res /= i + 1;
}
return res;
}
template <typename T> T euclid(T a, T b) {
if (b == 0)
return a;
else
return euclid(b, a % b);
}
/////////////////////////////////////////////////////////
// MOD of Combination
/*
vector<ll> fact(MAX, 0), fact_inv(MAX, 0);
ll pow_mod(ll a, ll b){
ll res = 1;
while(b > 0){
if(b & 1) res = res * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return res;
}
void prepare_comb_mod(ll n){
fact[0] = 1LL;
for(ll i = 0; i < n; i++) fact[i+1] = fact[i] * (i + 1) % MOD;
fact_inv[n] = pow_mod(fact[n], MOD - 2);
for(ll i = n - 1; i >= 0; i--) fact_inv[i] = fact_inv[i + 1] * (i + 1) %
MOD;
}
ll comb_mod(ll n, ll r){
return (fact[n] * fact_inv[r]) % MOD * fact_inv[n - r] % MOD;
}
*/
/////////////////////////////////////////////////////////
// Union-Find Tree
template <class T> struct UFT {
vector<int> par;
vector<int> rank;
vector<T> diff_weight;
UFT(int n = 1, T w = 0) { init(n, w); }
void init(int n = 1, T w = 0) {
par.resize(n);
rank.resize(n);
diff_weight.resize(n);
rep(i, 0, n) {
par[i] = i;
rank[i] = 0;
diff_weight[i] = w;
}
}
int root(int x) {
if (par[x] == x) {
return x;
} else {
int r = root(par[x]);
diff_weight[x] += diff_weight[par[x]];
return par[x] = r;
}
}
bool unite(int x, int y, int w = 0) {
w += weight(x);
w -= weight(y);
x = root(x);
y = root(y);
if (x == y)
return false;
if (rank[x] < rank[y]) {
par[x] = y;
diff_weight[x] = -w;
} else {
par[y] = x;
diff_weight[y] = w;
if (rank[x] == rank[y])
rank[x]++;
}
return true;
}
bool same(int x, int y) { return root(x) == root(y); }
T weight(int x) {
root(x);
return diff_weight[x];
}
T diff(int x, int y) { return weight(y) - weight(x); }
};
/////////////////////////////////////////////////////////
void ans(bool b) {
if (b)
cout << "yes" << endl;
else
cout << "no" << endl;
}
void Ans(bool b) {
if (b)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
void ANS(bool b) {
if (b)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
/////////////////////////////////////////////////////////
void Main() {
int A, B, C;
cin >> A >> B >> C;
Ans(min(A, B) <= C && C <= max(A, B));
}
/////////////////////////////////////////////////////////
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << std::fixed << std::setprecision(15);
Main();
}
| [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 877,706 | 877,707 | u855985627 | cpp |
p03067 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
typedef long long ll;
#define mop 1000000007
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if ((a - b) * (b - c) <= 0) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
typedef long long ll;
#define mop 1000000007
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if ((a - c) * (c - b) >= 0) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} | [
"identifier.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove",
"misc.opposites",
"expression.operator.compare.change"
] | 877,711 | 877,712 | u099918199 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> ii;
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
int a, b, c;
cin >> a >> b >> c;
cout << ((b - a) * (b - c) > 0 ? "Yes" : "No") << "\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> ii;
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
int a, b, c;
cin >> a >> b >> c;
cout << ((c - a) * (b - c) > 0 ? "Yes" : "No") << "\n";
return 0;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"io.output.change"
] | 877,717 | 877,718 | u586598623 | cpp |
p03067 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using vll = vector<long long>;
using pll = pair<long long, long long>;
#define rep(i, n) for (long long i(0); (i) < (n); (i)++)
const string YES = "Yes";
const string NO = "No";
void solve(long long A, long long B, long long C) {
if (A > C)
swap(A, C);
if (B < A || B > C)
cout << YES << endl;
else
cout << NO << endl;
}
int main() {
long long A;
scanf("%lld", &A);
long long B;
scanf("%lld", &B);
long long C;
scanf("%lld", &C);
solve(A, B, C);
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using vll = vector<long long>;
using pll = pair<long long, long long>;
#define rep(i, n) for (long long i(0); (i) < (n); (i)++)
const string YES = "Yes";
const string NO = "No";
void solve(long long A, long long B, long long C) {
if (A > B)
swap(A, B);
if (C > A && B > C)
cout << YES << endl;
else
cout << NO << endl;
}
int main() {
long long A;
scanf("%lld", &A);
long long B;
scanf("%lld", &B);
long long C;
scanf("%lld", &C);
solve(A, B, C);
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change",
"call.arguments.change",
"misc.opposites"
] | 877,719 | 877,720 | u960267905 | cpp |
p03067 | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a < b) {
if (c < b) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} else {
if (b < c) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
return 0;
} | #include <iostream>
#include <string>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a < c) {
if (c < b) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} else {
if (b < c) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
return 0;
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 877,731 | 877,732 | u441823651 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
#define INF ((1 << 30) - 1) // int32_t
#define MOD 1000000007
#define MOD2
#define all(a) (a).begin(), (a).end()
#define mkp make_pair
#define pb push_back
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
int main() {
bool flag = true;
ll ans = 0, sum = 0;
int a, b, c;
cin >> a >> b >> c;
if (a < c && c < b)
flag = true;
if (b < c && c < a)
flag = true;
// cout <<fixed<<setprecision(16)<< << endl;
// cout << ans << endl;
if (flag)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define INF ((1 << 30) - 1) // int32_t
#define MOD 1000000007
#define MOD2
#define all(a) (a).begin(), (a).end()
#define mkp make_pair
#define pb push_back
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
int main() {
bool flag = false;
ll ans = 0, sum = 0;
int a, b, c;
cin >> a >> b >> c;
if (a < c && c < b)
flag = true;
if (b < c && c < a)
flag = true;
// cout <<fixed<<setprecision(16)<< << endl;
// cout << ans << endl;
if (flag)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| [
"misc.opposites",
"variable_declaration.value.change"
] | 877,734 | 877,735 | u355424600 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define rrep(i, n) for (int(i) = (n)-1; (i) >= 0; --(i)) // Reversi rep
#define nfor(i, a, b) for (int(i) = (a); (i) < (b); ++(i)) // Natural for
#define rfor(i, a, b) for (int(i) = (b); (i) >= (a); --(i)) // Reversi for
#define ll long long
#define mod (1000000007)
#define YES cout << "YES" << endl;
#define Yes cout << "Yes" << endl;
#define NO cout << "NO" << endl;
#define No cout << "No" << endl;
int asc(const void *a, const void *b) { return *(int *)a - *(int *)b; }
int desc(const void *a, const void *b) { return *(int *)b - *(int *)a; }
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a > b && c > b) {
Yes;
} else if (a < b && c < b) {
Yes;
} else {
No;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define rrep(i, n) for (int(i) = (n)-1; (i) >= 0; --(i)) // Reversi rep
#define nfor(i, a, b) for (int(i) = (a); (i) < (b); ++(i)) // Natural for
#define rfor(i, a, b) for (int(i) = (b); (i) >= (a); --(i)) // Reversi for
#define ll long long
#define mod (1000000007)
#define YES cout << "YES" << endl;
#define Yes cout << "Yes" << endl;
#define NO cout << "NO" << endl;
#define No cout << "No" << endl;
int asc(const void *a, const void *b) { return *(int *)a - *(int *)b; }
int desc(const void *a, const void *b) { return *(int *)b - *(int *)a; }
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a > c && c > b) {
Yes;
} else if (a < c && c < b) {
Yes;
} else {
No;
}
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 877,738 | 877,739 | u801513186 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define rrep(i, n) for (int(i) = (n)-1; (i) >= 0; --(i)) // Reversi rep
#define nfor(i, a, b) for (int(i) = (a); (i) < (b); ++(i)) // Natural for
#define rfor(i, a, b) for (int(i) = (b); (i) >= (a); --(i)) // Reversi for
#define ll long long
#define mod (1000000007)
#define YES cout << "YES" << endl;
#define Yes cout << "Yes" << endl;
#define NO cout << "NO" << endl;
#define No cout << "No" << endl;
int asc(const void *a, const void *b) { return *(int *)a - *(int *)b; }
int desc(const void *a, const void *b) { return *(int *)b - *(int *)a; }
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a > b && c >= b) {
Yes;
} else if (a < b && c <= b) {
Yes;
} else {
No;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define rrep(i, n) for (int(i) = (n)-1; (i) >= 0; --(i)) // Reversi rep
#define nfor(i, a, b) for (int(i) = (a); (i) < (b); ++(i)) // Natural for
#define rfor(i, a, b) for (int(i) = (b); (i) >= (a); --(i)) // Reversi for
#define ll long long
#define mod (1000000007)
#define YES cout << "YES" << endl;
#define Yes cout << "Yes" << endl;
#define NO cout << "NO" << endl;
#define No cout << "No" << endl;
int asc(const void *a, const void *b) { return *(int *)a - *(int *)b; }
int desc(const void *a, const void *b) { return *(int *)b - *(int *)a; }
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a > c && c > b) {
Yes;
} else if (a < c && c < b) {
Yes;
} else {
No;
}
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change",
"expression.operator.compare.change"
] | 877,740 | 877,739 | u801513186 | cpp |
p03067 | #include <iostream>
using namespace std;
int main(void) {
int a, b, c;
cin >> a >> b >> c;
if (a < c && c < b || b < c && c < a) {
cout << "Yes" << endl;
} else {
cout << "NO" << endl;
}
} | #include <iostream>
using namespace std;
int main(void) {
int a, b, c;
cin >> a >> b >> c;
if (a < c && c < b || b < c && c < a) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 877,745 | 877,746 | u845000384 | cpp |
p03067 | #include <iostream>
#include <math.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
string ans;
if ((c - b) * (b - a) > 0) {
ans = "Yes";
} else {
ans = "No";
}
cout << ans << endl;
} | #include <iostream>
#include <math.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
string ans;
if ((b - c) * (c - a) > 0) {
ans = "Yes";
} else {
ans = "No";
}
cout << ans << endl;
} | [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change",
"identifier.change"
] | 877,751 | 877,752 | u889344512 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
#define pb push_back
#define mp make_pair
#define eps 1e-9
#define INF 2000000000
#define LLINF 1000000000000000ll
#define sz(x) ((int)(x).size())
#define fi first
#define sec second
#define all(x) (x).begin(), (x).end()
#define sq(x) ((x) * (x))
#define rep(i, n) for (int(i) = 0; (i) < (int)(n); (i)++)
#define repn(i, a, n) for (int(i) = (a); (i) < (int)(n); (i)++)
#define EQ(a, b) (abs((a) - (b)) < eps)
#define dmp(x) cerr << __LINE__ << " " << #x << " " << x << endl;
template <class T> void chmin(T &a, const T &b) {
if (a > b)
a = b;
}
template <class T> void chmax(T &a, const T &b) {
if (a < b)
a = b;
}
template <class t, class u> ostream &operator<<(ostream &os, pair<t, u> p) {
return os << p.fi << ',' << p.sec;
}
template <class T> void dump(vector<T> &vec) {
for (int i = 0; i < vec.size(); i++) {
cout << vec[i];
if (i + 1 < vec.size())
cout << ' ';
else
cout << endl;
}
return;
}
template <class T> void input(vector<T> &vec, int n) {
vec.resize(n);
for (int i = 0; i < n; i++) {
cin >> vec[i];
}
}
void fastio() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
}
int a, b, c;
int main() {
cin >> a >> b >> c;
if ((a - b) * (c - b) <= 0)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
#define pb push_back
#define mp make_pair
#define eps 1e-9
#define INF 2000000000
#define LLINF 1000000000000000ll
#define sz(x) ((int)(x).size())
#define fi first
#define sec second
#define all(x) (x).begin(), (x).end()
#define sq(x) ((x) * (x))
#define rep(i, n) for (int(i) = 0; (i) < (int)(n); (i)++)
#define repn(i, a, n) for (int(i) = (a); (i) < (int)(n); (i)++)
#define EQ(a, b) (abs((a) - (b)) < eps)
#define dmp(x) cerr << __LINE__ << " " << #x << " " << x << endl;
template <class T> void chmin(T &a, const T &b) {
if (a > b)
a = b;
}
template <class T> void chmax(T &a, const T &b) {
if (a < b)
a = b;
}
template <class t, class u> ostream &operator<<(ostream &os, pair<t, u> p) {
return os << p.fi << ',' << p.sec;
}
template <class T> void dump(vector<T> &vec) {
for (int i = 0; i < vec.size(); i++) {
cout << vec[i];
if (i + 1 < vec.size())
cout << ' ';
else
cout << endl;
}
return;
}
template <class T> void input(vector<T> &vec, int n) {
vec.resize(n);
for (int i = 0; i < n; i++) {
cin >> vec[i];
}
}
void fastio() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
}
int a, b, c;
int main() {
cin >> a >> b >> c;
if ((a - c) * (b - c) <= 0)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 877,753 | 877,754 | u379947938 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
#define pb push_back
#define mp make_pair
#define eps 1e-9
#define INF 2000000000
#define LLINF 1000000000000000ll
#define sz(x) ((int)(x).size())
#define fi first
#define sec second
#define all(x) (x).begin(), (x).end()
#define sq(x) ((x) * (x))
#define rep(i, n) for (int(i) = 0; (i) < (int)(n); (i)++)
#define repn(i, a, n) for (int(i) = (a); (i) < (int)(n); (i)++)
#define EQ(a, b) (abs((a) - (b)) < eps)
#define dmp(x) cerr << __LINE__ << " " << #x << " " << x << endl;
template <class T> void chmin(T &a, const T &b) {
if (a > b)
a = b;
}
template <class T> void chmax(T &a, const T &b) {
if (a < b)
a = b;
}
template <class t, class u> ostream &operator<<(ostream &os, pair<t, u> p) {
return os << p.fi << ',' << p.sec;
}
template <class T> void dump(vector<T> &vec) {
for (int i = 0; i < vec.size(); i++) {
cout << vec[i];
if (i + 1 < vec.size())
cout << ' ';
else
cout << endl;
}
return;
}
template <class T> void input(vector<T> &vec, int n) {
vec.resize(n);
for (int i = 0; i < n; i++) {
cin >> vec[i];
}
}
void fastio() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
}
int a, b, c;
int main() {
cin >> a >> b >> c;
if ((a - b) * (b - c) <= 0)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
#define pb push_back
#define mp make_pair
#define eps 1e-9
#define INF 2000000000
#define LLINF 1000000000000000ll
#define sz(x) ((int)(x).size())
#define fi first
#define sec second
#define all(x) (x).begin(), (x).end()
#define sq(x) ((x) * (x))
#define rep(i, n) for (int(i) = 0; (i) < (int)(n); (i)++)
#define repn(i, a, n) for (int(i) = (a); (i) < (int)(n); (i)++)
#define EQ(a, b) (abs((a) - (b)) < eps)
#define dmp(x) cerr << __LINE__ << " " << #x << " " << x << endl;
template <class T> void chmin(T &a, const T &b) {
if (a > b)
a = b;
}
template <class T> void chmax(T &a, const T &b) {
if (a < b)
a = b;
}
template <class t, class u> ostream &operator<<(ostream &os, pair<t, u> p) {
return os << p.fi << ',' << p.sec;
}
template <class T> void dump(vector<T> &vec) {
for (int i = 0; i < vec.size(); i++) {
cout << vec[i];
if (i + 1 < vec.size())
cout << ' ';
else
cout << endl;
}
return;
}
template <class T> void input(vector<T> &vec, int n) {
vec.resize(n);
for (int i = 0; i < n; i++) {
cin >> vec[i];
}
}
void fastio() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
}
int a, b, c;
int main() {
cin >> a >> b >> c;
if ((a - c) * (b - c) <= 0)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 877,755 | 877,754 | u379947938 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (min(a, c) < b && b < max(a, c)) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (min(a, b) < c && c < max(a, b)) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 877,758 | 877,759 | u596200441 | cpp |
p03067 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define MOD 1000000007
#define rep(i, m, n) for (int(i) = (int)(m); i < (int)(n); i++)
#define REP(i, n) rep(i, 0, n)
#define FOR(i, c) \
for (decltype((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ll long long
#define ull unsigned long long
#define all(hoge) (hoge).begin(), (hoge).end()
typedef pair<ll, ll> P;
const long long INF = 1LL << 60;
typedef vector<ll> Array;
typedef vector<Array> Matrix;
// priority_queue<ll> max;//大きい順
// priority_queue<ll, Array, greater<ll>> min;//小さい順
/*firstについては昇順 secondについては降順
sort(all(wh), [&](P x, P y) {
if (x.first == y.first)return x.second > y.second;
return x.first < y.first;
});
*/
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// substr 文字列取り出し
// upper_bound
// ある値より大きい一番左のイテレータを返す、lowerは以上(setに対して使うとO(N)なので、setのメンバ関数を使う
// stoi
struct Edge { //グラフ
ll to, cap, rev;
Edge(ll _to, ll _cap, ll _rev) {
to = _to;
cap = _cap;
rev = _rev;
}
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
void add_edge(Graph &G, ll from, ll to, ll cap, bool revFlag,
ll revCap) { //最大フロー求める Ford-fulkerson
G[from].push_back(Edge(to, cap, (ll)G[to].size()));
if (revFlag)
G[to].push_back(Edge(
from, revCap, (ll)G[from].size() - 1)); //最小カットの場合逆辺は0にする
}
ll max_flow_dfs(Graph &G, ll v, ll t, ll f, vector<bool> &used) {
if (v == t)
return f;
used[v] = true;
for (int i = 0; i < G[v].size(); ++i) {
Edge &e = G[v][i];
if (!used[e.to] && e.cap > 0) {
ll d = max_flow_dfs(G, e.to, t, min(f, e.cap), used);
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
//二分グラフの最大マッチングを求めたりも出来る また二部グラフの最大独立集合は頂点数-最大マッチングのサイズ
ll max_flow(Graph &G, ll s, ll t) // O(V(V+E))
{
ll flow = 0;
for (;;) {
vector<bool> used(G.size());
REP(i, used.size()) used[i] = false;
ll f = max_flow_dfs(G, s, t, INF, used);
if (f == 0) {
return flow;
}
flow += f;
}
}
void BellmanFord(Graph &G, ll s, Array &d, Array &negative) { // O(|E||V|)
d.resize(G.size());
negative.resize(G.size());
REP(i, d.size()) d[i] = INF;
REP(i, d.size()) negative[i] = false;
d[s] = 0;
REP(k, G.size() - 2) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
}
}
}
}
REP(k, G.size() - 2) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
negative[G[i][j].to] = true;
}
if (negative[i] == true)
negative[G[i][j].to] = true;
}
}
}
}
void Dijkstra(Graph &G, ll s, Array &d) { // O(|E|log|V|)
d.resize(G.size());
REP(i, d.size()) d[i] = INF;
d[s] = 0;
priority_queue<P, vector<P>, greater<P>> q;
q.push(make_pair(0, s));
while (!q.empty()) {
P a = q.top();
q.pop();
if (d[a.second] < a.first)
continue;
REP(i, G[a.second].size()) {
Edge e = G[a.second][i];
if (d[e.to] > d[a.second] + e.cap) {
d[e.to] = d[a.second] + e.cap;
q.push(make_pair(d[e.to], e.to));
}
}
}
}
void WarshallFloyd(Graph &G, Matrix &d) { // O(V^3)
d.resize(G.size());
REP(i, d.size()) d[i].resize(G.size());
REP(i, d.size()) {
REP(j, d[i].size()) { d[i][j] = INF; }
}
REP(i, G.size()) {
REP(j, G[i].size()) { d[i][G[i][j].to] = G[i][j].cap; }
}
REP(i, G.size()) {
REP(j, G.size()) {
REP(k, G.size()) { chmin(d[j][k], d[j][i] + d[i][k]); }
}
}
}
bool tsort(Graph &graph, vector<int> &order) { //トポロジカルソートO(E+V)
int n = graph.size(), k = 0;
Array in(n);
for (auto &es : graph)
for (auto &e : es)
in[e.to]++;
priority_queue<ll, Array, greater<ll>> que;
REP(i, n)
if (in[i] == 0)
que.push(i);
while (que.size()) {
int v = que.top();
que.pop();
order.push_back(v);
for (auto &e : graph[v])
if (--in[e.to] == 0)
que.push(e.to);
}
if (order.size() != n)
return false;
else
return true;
}
class lca {
public:
const int n = 0;
const int log2_n = 0;
std::vector<std::vector<int>> parent;
std::vector<int> depth;
lca() {}
lca(const Graph &g, int root)
: n(g.size()), log2_n(log2(n) + 1), parent(log2_n, std::vector<int>(n)),
depth(n) {
dfs(g, root, -1, 0);
for (int k = 0; k + 1 < log2_n; k++) {
for (int v = 0; v < (int)g.size(); v++) {
if (parent[k][v] < 0)
parent[k + 1][v] = -1;
else
parent[k + 1][v] = parent[k][parent[k][v]];
}
}
}
void dfs(const Graph &g, int v, int p, int d) {
parent[0][v] = p;
depth[v] = d;
for (auto &e : g[v]) {
if (e.to != p)
dfs(g, e.to, v, d + 1);
}
}
int get(int u, int v) {
if (depth[u] > depth[v])
std::swap(u, v);
for (int k = 0; k < log2_n; k++) {
if ((depth[v] - depth[u]) >> k & 1) {
v = parent[k][v];
}
}
if (u == v)
return u;
for (int k = log2_n - 1; k >= 0; k--) {
if (parent[k][u] != parent[k][v]) {
u = parent[k][u];
v = parent[k][v];
}
}
return parent[0][u];
}
};
class UnionFind {
vector<int> data;
ll num;
public:
UnionFind(int size) : data(size, -1), num(size) {}
bool unionSet(int x, int y) { // xとyの集合を統合する
x = root(x);
y = root(y);
if (x != y) {
if (data[y] < data[x])
swap(x, y);
data[x] += data[y];
data[y] = x;
}
num -= (x != y);
return x != y;
}
bool findSet(int x, int y) { // xとyが同じ集合か返す
return root(x) == root(y);
}
int root(int x) { // xのルートを返す
return data[x] < 0 ? x : data[x] = root(data[x]);
}
int size(int x) { // xの集合のサイズを返す
return -data[root(x)];
}
int numSet() { //集合の数を返す
return num;
}
};
class SumSegTree {
private:
int _sum(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return 0; // 交差しない
if (a <= l && r <= b)
return dat[k]; // a,l,r,bの順で完全に含まれる
else {
int s1 = _sum(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
int s2 = _sum(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return s1 + s2;
}
}
public:
int n, height;
vector<int> dat;
// 初期化（_nは最大要素数）
SumSegTree(int _n) {
n = 1;
height = 1;
while (n < _n) {
n *= 2;
height++;
}
dat = vector<int>(2 * n - 1, 0);
}
// 場所i(0-indexed)にxを足す
void add(int i, int x) {
i += n - 1; // i番目の葉ノードへ
dat[i] += x;
while (i > 0) { // 下から上がっていく
i = (i - 1) / 2;
dat[i] += x;
}
}
// 区間[a,b)の総和。ノードk=[l,r)に着目している。
int sum(int a, int b) { return _sum(a, b, 0, 0, n); }
};
class RmqTree {
private:
P _find(ll a, ll b, ll k, ll l, ll r) {
if (r <= a || b <= l)
return make_pair(INF, INF); // 交差しない
if (a <= l && r <= b)
return dat[k]; // a,l,r,bの順で完全に含まれる
else {
P s1 = _find(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
P s2 = _find(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return min(s1, s2);
}
}
public:
ll n, height;
vector<P> dat;
// 初期化（_nは最大要素数）
RmqTree(ll _n) {
n = 1;
height = 1;
while (n < _n) {
n *= 2;
height++;
}
dat = vector<P>(2 * n - 1, make_pair(INF, INF));
}
// 場所i(0-indexed)をxにする
void update(ll i, ll x) {
ll num = i;
i += n - 1; // i番目の葉ノードへ
dat[i] = make_pair(x, num);
while (i > 0) { // 下から上がっていく
i = (i - 1) / 2;
dat[i] = min(dat[i * 2 + 1], dat[i * 2 + 2]);
}
}
// 区間[a,b)の最小値。ノードk=[l,r)に着目している。
P find(ll a, ll b) { return _find(a, b, 0, 0, n); }
};
//約数求める //約数
void divisor(ll n, vector<ll> &ret) {
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(ret.begin(), ret.end());
}
vector<ll> lis_fast(const vector<ll> &a) { //最長部分増加列
const ll n = a.size();
vector<ll> A(n, INT_MAX);
vector<ll> id(n);
for (int i = 0; i < n; ++i) {
id[i] = distance(A.begin(), lower_bound(A.begin(), A.end(), a[i]));
A[id[i]] = a[i];
}
ll m = *max_element(id.begin(), id.end());
vector<ll> b(m + 1);
for (int i = n - 1; i >= 0; --i)
if (id[i] == m)
b[m--] = a[i];
return b;
}
ll ModPow(ll x, ll n) {
ll res = 1LL;
while (n > 0) {
if (n & 1)
res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
// nCrとか
class Combination {
public:
Array fact;
Array inv;
ll mod;
ll mod_inv(ll x) {
ll n = mod - 2LL;
ll res = 1LL;
while (n > 0) {
if (n & 1)
res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
ll nCr(ll n, ll r) { return ((fact[n] * inv[r] % mod) * inv[n - r]) % mod; }
ll nPr(ll n, ll r) { return (fact[n] * inv[n - r]) % mod; }
ll nHr(ll n, ll r) { return nCr(r + n - 1, r); }
Combination(ll n, ll _mod) {
mod = _mod;
fact.resize(n + 1);
fact[0] = 1;
REP(i, n) { fact[i + 1] = (fact[i] * (i + 1LL)) % mod; }
inv.resize(n + 1);
REP(i, n + 1) { inv[i] = mod_inv(fact[i]); }
}
};
ll gcd(ll m, ll n) {
if (n == 0)
return m;
return gcd(n, m % n);
} // gcd
ll lcm(ll m, ll n) { return m / gcd(m, n) * n; }
Matrix mIdentity(ll n) {
Matrix A(n, Array(n));
for (int i = 0; i < n; ++i)
A[i][i] = 1;
return A;
}
Matrix mMul(const Matrix &A, const Matrix &B) {
Matrix C(A.size(), Array(B[0].size()));
for (int i = 0; i < C.size(); ++i)
for (int j = 0; j < C[i].size(); ++j)
for (int k = 0; k < A[i].size(); ++k)
(C[i][j] += (A[i][k] % MOD) * (B[k][j] % MOD)) %= MOD;
return C;
}
// O( n^3 log e )
Matrix mPow(const Matrix &A, ll e) {
return e == 0 ? mIdentity(A.size())
: e % 2 == 0 ? mPow(mMul(A, A), e / 2)
: mMul(A, mPow(A, e - 1));
}
template <class T> class RectangleSum {
public:
vector<vector<T>> sum;
T GetSum(int left, int right, int top,
int bottom) { //[left, right], [top, bottom]
T res = sum[bottom][right];
if (left > 0)
res -= sum[bottom][left - 1];
if (top > 0)
res -= sum[top - 1][right];
if (left > 0 && top > 0)
res += sum[top - 1][left - 1];
return res;
}
RectangleSum(const vector<vector<T>> &s, int h, int w) {
sum.resize(h);
for (int i = 0; i < h; i++)
sum[i].resize(w, 0);
for (int y = 0; y < h; y++) {
for (int x = 0; x < w; x++) {
sum[y][x] = s[y][x];
if (y > 0)
sum[y][x] += sum[y - 1][x];
if (x > 0)
sum[y][x] += sum[y][x - 1];
if (y > 0 && x > 0)
sum[y][x] -= sum[y - 1][x - 1];
}
}
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n, h, w;
cin >> n >> h >> w;
if (min({n, h, w}) == w || max({n, h, w}) == w)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| #define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define MOD 1000000007
#define rep(i, m, n) for (int(i) = (int)(m); i < (int)(n); i++)
#define REP(i, n) rep(i, 0, n)
#define FOR(i, c) \
for (decltype((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ll long long
#define ull unsigned long long
#define all(hoge) (hoge).begin(), (hoge).end()
typedef pair<ll, ll> P;
const long long INF = 1LL << 60;
typedef vector<ll> Array;
typedef vector<Array> Matrix;
// priority_queue<ll> max;//大きい順
// priority_queue<ll, Array, greater<ll>> min;//小さい順
/*firstについては昇順 secondについては降順
sort(all(wh), [&](P x, P y) {
if (x.first == y.first)return x.second > y.second;
return x.first < y.first;
});
*/
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// substr 文字列取り出し
// upper_bound
// ある値より大きい一番左のイテレータを返す、lowerは以上(setに対して使うとO(N)なので、setのメンバ関数を使う
// stoi
struct Edge { //グラフ
ll to, cap, rev;
Edge(ll _to, ll _cap, ll _rev) {
to = _to;
cap = _cap;
rev = _rev;
}
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
void add_edge(Graph &G, ll from, ll to, ll cap, bool revFlag,
ll revCap) { //最大フロー求める Ford-fulkerson
G[from].push_back(Edge(to, cap, (ll)G[to].size()));
if (revFlag)
G[to].push_back(Edge(
from, revCap, (ll)G[from].size() - 1)); //最小カットの場合逆辺は0にする
}
ll max_flow_dfs(Graph &G, ll v, ll t, ll f, vector<bool> &used) {
if (v == t)
return f;
used[v] = true;
for (int i = 0; i < G[v].size(); ++i) {
Edge &e = G[v][i];
if (!used[e.to] && e.cap > 0) {
ll d = max_flow_dfs(G, e.to, t, min(f, e.cap), used);
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
//二分グラフの最大マッチングを求めたりも出来る また二部グラフの最大独立集合は頂点数-最大マッチングのサイズ
ll max_flow(Graph &G, ll s, ll t) // O(V(V+E))
{
ll flow = 0;
for (;;) {
vector<bool> used(G.size());
REP(i, used.size()) used[i] = false;
ll f = max_flow_dfs(G, s, t, INF, used);
if (f == 0) {
return flow;
}
flow += f;
}
}
void BellmanFord(Graph &G, ll s, Array &d, Array &negative) { // O(|E||V|)
d.resize(G.size());
negative.resize(G.size());
REP(i, d.size()) d[i] = INF;
REP(i, d.size()) negative[i] = false;
d[s] = 0;
REP(k, G.size() - 2) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
}
}
}
}
REP(k, G.size() - 2) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
negative[G[i][j].to] = true;
}
if (negative[i] == true)
negative[G[i][j].to] = true;
}
}
}
}
void Dijkstra(Graph &G, ll s, Array &d) { // O(|E|log|V|)
d.resize(G.size());
REP(i, d.size()) d[i] = INF;
d[s] = 0;
priority_queue<P, vector<P>, greater<P>> q;
q.push(make_pair(0, s));
while (!q.empty()) {
P a = q.top();
q.pop();
if (d[a.second] < a.first)
continue;
REP(i, G[a.second].size()) {
Edge e = G[a.second][i];
if (d[e.to] > d[a.second] + e.cap) {
d[e.to] = d[a.second] + e.cap;
q.push(make_pair(d[e.to], e.to));
}
}
}
}
void WarshallFloyd(Graph &G, Matrix &d) { // O(V^3)
d.resize(G.size());
REP(i, d.size()) d[i].resize(G.size());
REP(i, d.size()) {
REP(j, d[i].size()) { d[i][j] = INF; }
}
REP(i, G.size()) {
REP(j, G[i].size()) { d[i][G[i][j].to] = G[i][j].cap; }
}
REP(i, G.size()) {
REP(j, G.size()) {
REP(k, G.size()) { chmin(d[j][k], d[j][i] + d[i][k]); }
}
}
}
bool tsort(Graph &graph, vector<int> &order) { //トポロジカルソートO(E+V)
int n = graph.size(), k = 0;
Array in(n);
for (auto &es : graph)
for (auto &e : es)
in[e.to]++;
priority_queue<ll, Array, greater<ll>> que;
REP(i, n)
if (in[i] == 0)
que.push(i);
while (que.size()) {
int v = que.top();
que.pop();
order.push_back(v);
for (auto &e : graph[v])
if (--in[e.to] == 0)
que.push(e.to);
}
if (order.size() != n)
return false;
else
return true;
}
class lca {
public:
const int n = 0;
const int log2_n = 0;
std::vector<std::vector<int>> parent;
std::vector<int> depth;
lca() {}
lca(const Graph &g, int root)
: n(g.size()), log2_n(log2(n) + 1), parent(log2_n, std::vector<int>(n)),
depth(n) {
dfs(g, root, -1, 0);
for (int k = 0; k + 1 < log2_n; k++) {
for (int v = 0; v < (int)g.size(); v++) {
if (parent[k][v] < 0)
parent[k + 1][v] = -1;
else
parent[k + 1][v] = parent[k][parent[k][v]];
}
}
}
void dfs(const Graph &g, int v, int p, int d) {
parent[0][v] = p;
depth[v] = d;
for (auto &e : g[v]) {
if (e.to != p)
dfs(g, e.to, v, d + 1);
}
}
int get(int u, int v) {
if (depth[u] > depth[v])
std::swap(u, v);
for (int k = 0; k < log2_n; k++) {
if ((depth[v] - depth[u]) >> k & 1) {
v = parent[k][v];
}
}
if (u == v)
return u;
for (int k = log2_n - 1; k >= 0; k--) {
if (parent[k][u] != parent[k][v]) {
u = parent[k][u];
v = parent[k][v];
}
}
return parent[0][u];
}
};
class UnionFind {
vector<int> data;
ll num;
public:
UnionFind(int size) : data(size, -1), num(size) {}
bool unionSet(int x, int y) { // xとyの集合を統合する
x = root(x);
y = root(y);
if (x != y) {
if (data[y] < data[x])
swap(x, y);
data[x] += data[y];
data[y] = x;
}
num -= (x != y);
return x != y;
}
bool findSet(int x, int y) { // xとyが同じ集合か返す
return root(x) == root(y);
}
int root(int x) { // xのルートを返す
return data[x] < 0 ? x : data[x] = root(data[x]);
}
int size(int x) { // xの集合のサイズを返す
return -data[root(x)];
}
int numSet() { //集合の数を返す
return num;
}
};
class SumSegTree {
private:
int _sum(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return 0; // 交差しない
if (a <= l && r <= b)
return dat[k]; // a,l,r,bの順で完全に含まれる
else {
int s1 = _sum(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
int s2 = _sum(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return s1 + s2;
}
}
public:
int n, height;
vector<int> dat;
// 初期化（_nは最大要素数）
SumSegTree(int _n) {
n = 1;
height = 1;
while (n < _n) {
n *= 2;
height++;
}
dat = vector<int>(2 * n - 1, 0);
}
// 場所i(0-indexed)にxを足す
void add(int i, int x) {
i += n - 1; // i番目の葉ノードへ
dat[i] += x;
while (i > 0) { // 下から上がっていく
i = (i - 1) / 2;
dat[i] += x;
}
}
// 区間[a,b)の総和。ノードk=[l,r)に着目している。
int sum(int a, int b) { return _sum(a, b, 0, 0, n); }
};
class RmqTree {
private:
P _find(ll a, ll b, ll k, ll l, ll r) {
if (r <= a || b <= l)
return make_pair(INF, INF); // 交差しない
if (a <= l && r <= b)
return dat[k]; // a,l,r,bの順で完全に含まれる
else {
P s1 = _find(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
P s2 = _find(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return min(s1, s2);
}
}
public:
ll n, height;
vector<P> dat;
// 初期化（_nは最大要素数）
RmqTree(ll _n) {
n = 1;
height = 1;
while (n < _n) {
n *= 2;
height++;
}
dat = vector<P>(2 * n - 1, make_pair(INF, INF));
}
// 場所i(0-indexed)をxにする
void update(ll i, ll x) {
ll num = i;
i += n - 1; // i番目の葉ノードへ
dat[i] = make_pair(x, num);
while (i > 0) { // 下から上がっていく
i = (i - 1) / 2;
dat[i] = min(dat[i * 2 + 1], dat[i * 2 + 2]);
}
}
// 区間[a,b)の最小値。ノードk=[l,r)に着目している。
P find(ll a, ll b) { return _find(a, b, 0, 0, n); }
};
//約数求める //約数
void divisor(ll n, vector<ll> &ret) {
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(ret.begin(), ret.end());
}
vector<ll> lis_fast(const vector<ll> &a) { //最長部分増加列
const ll n = a.size();
vector<ll> A(n, INT_MAX);
vector<ll> id(n);
for (int i = 0; i < n; ++i) {
id[i] = distance(A.begin(), lower_bound(A.begin(), A.end(), a[i]));
A[id[i]] = a[i];
}
ll m = *max_element(id.begin(), id.end());
vector<ll> b(m + 1);
for (int i = n - 1; i >= 0; --i)
if (id[i] == m)
b[m--] = a[i];
return b;
}
ll ModPow(ll x, ll n) {
ll res = 1LL;
while (n > 0) {
if (n & 1)
res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
// nCrとか
class Combination {
public:
Array fact;
Array inv;
ll mod;
ll mod_inv(ll x) {
ll n = mod - 2LL;
ll res = 1LL;
while (n > 0) {
if (n & 1)
res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
ll nCr(ll n, ll r) { return ((fact[n] * inv[r] % mod) * inv[n - r]) % mod; }
ll nPr(ll n, ll r) { return (fact[n] * inv[n - r]) % mod; }
ll nHr(ll n, ll r) { return nCr(r + n - 1, r); }
Combination(ll n, ll _mod) {
mod = _mod;
fact.resize(n + 1);
fact[0] = 1;
REP(i, n) { fact[i + 1] = (fact[i] * (i + 1LL)) % mod; }
inv.resize(n + 1);
REP(i, n + 1) { inv[i] = mod_inv(fact[i]); }
}
};
ll gcd(ll m, ll n) {
if (n == 0)
return m;
return gcd(n, m % n);
} // gcd
ll lcm(ll m, ll n) { return m / gcd(m, n) * n; }
Matrix mIdentity(ll n) {
Matrix A(n, Array(n));
for (int i = 0; i < n; ++i)
A[i][i] = 1;
return A;
}
Matrix mMul(const Matrix &A, const Matrix &B) {
Matrix C(A.size(), Array(B[0].size()));
for (int i = 0; i < C.size(); ++i)
for (int j = 0; j < C[i].size(); ++j)
for (int k = 0; k < A[i].size(); ++k)
(C[i][j] += (A[i][k] % MOD) * (B[k][j] % MOD)) %= MOD;
return C;
}
// O( n^3 log e )
Matrix mPow(const Matrix &A, ll e) {
return e == 0 ? mIdentity(A.size())
: e % 2 == 0 ? mPow(mMul(A, A), e / 2)
: mMul(A, mPow(A, e - 1));
}
template <class T> class RectangleSum {
public:
vector<vector<T>> sum;
T GetSum(int left, int right, int top,
int bottom) { //[left, right], [top, bottom]
T res = sum[bottom][right];
if (left > 0)
res -= sum[bottom][left - 1];
if (top > 0)
res -= sum[top - 1][right];
if (left > 0 && top > 0)
res += sum[top - 1][left - 1];
return res;
}
RectangleSum(const vector<vector<T>> &s, int h, int w) {
sum.resize(h);
for (int i = 0; i < h; i++)
sum[i].resize(w, 0);
for (int y = 0; y < h; y++) {
for (int x = 0; x < w; x++) {
sum[y][x] = s[y][x];
if (y > 0)
sum[y][x] += sum[y - 1][x];
if (x > 0)
sum[y][x] += sum[y][x - 1];
if (y > 0 && x > 0)
sum[y][x] -= sum[y - 1][x - 1];
}
}
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n, h, w;
cin >> n >> h >> w;
if (min({n, h, w}) == w || max({n, h, w}) == w)
cout << "No" << endl;
else
cout << "Yes" << endl;
return 0;
}
| [
"control_flow.branch.else.remove",
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add"
] | 877,760 | 877,761 | u051493691 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a < b && c < b)
cout << "Yes" << endl;
else if (a > b && c > b)
cout << "Yes" << endl;
else {
cout << "No" << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a < c && c < b)
cout << "Yes" << endl;
else if (a > c && c > b)
cout << "Yes" << endl;
// else if(a<b&&b<<c)cout<<"Yes"<<endl;
else {
cout << "No" << endl;
}
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 877,773 | 877,774 | u122496126 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a < b && c < b)
cout << "Yes" << endl;
if (a > b && c > b)
cout << "Yes" << endl;
else {
cout << "No" << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a < c && c < b)
cout << "Yes" << endl;
else if (a > c && c > b)
cout << "Yes" << endl;
// else if(a<b&&b<<c)cout<<"Yes"<<endl;
else {
cout << "No" << endl;
}
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change",
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove"
] | 877,775 | 877,774 | u122496126 | cpp |
p03067 | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = int(a); i < int(b); ++i)
using namespace std;
typedef long long ll;
int INF = (1LL << 30) - 1;
int MOD = 1e9 + 7;
main() {
int A, B, C;
cin >> A >> B >> C;
if (B > A)
swap(A, B);
if (C >= A && C <= B)
cout << "Yes" << endl;
else
cout << "No" << endl;
} | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = int(a); i < int(b); ++i)
using namespace std;
typedef long long ll;
int INF = (1LL << 30) - 1;
int MOD = 1e9 + 7;
main() {
int A, B, C;
cin >> A >> B >> C;
if (B < A)
swap(A, B);
if (C >= A && C <= B)
cout << "Yes" << endl;
else
cout << "No" << endl;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 877,776 | 877,777 | u157322125 | cpp |
p03067 | #include <algorithm>
#include <cctype>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (n); i++)
locale l = locale::classic();
int main() {
int a, b, c;
cin >> a >> b >> c;
if ((c - b) * (b - a) > 0)
cout << "Yes" << endl;
else
cout << "No" << endl;
} | #include <algorithm>
#include <cctype>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (n); i++)
locale l = locale::classic();
int main() {
int a, b, c;
cin >> a >> b >> c;
if ((b - c) * (c - a) > 0)
cout << "Yes" << endl;
else
cout << "No" << endl;
} | [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change",
"identifier.change"
] | 877,778 | 877,779 | u372550522 | cpp |
p03067 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_set>
#include <vector>
using namespace std;
#define FOR(i, N) for (int i = 0; i < (int)N; i++)
#define FORIN(i, a, b) for (int i = a; i < (int)b; i++)
#define ALL(x) (x).begin(), (x).end()
#define MOD 1000000007
#define DEBUG(...) debug(__LINE__, ":" __VA_ARGS__)
using Pi = pair<int, int>;
using ll = long long;
const int INF = 1 << 28;
string to_string(string s) { return s; }
template <class T> string to_string(vector<T> v) {
string ret = "{";
for (int i = 0; i < v.size() - 1; ++i) {
ret += to_string(v[i]) + ",";
}
if (v.size() > 0) {
ret += to_string(v.back());
}
ret += "}";
return ret;
}
void debug() { cerr << endl; }
template <class Head, class... Tail> void debug(Head head, Tail... tail) {
cerr << to_string(head) << " ";
debug(tail...);
}
void print() { cout << endl; }
template <class Head, class... Tail> void print(Head head, Tail... tail) {
cout << to_string(head);
print(tail...);
}
void get() {}
template <class Head, class... Tail> void get(Head &head, Tail &...tail) {
cin >> head;
get(tail...);
}
template <class T> void getv(vector<T> &vec) {
for (int i = 0; i < vec.size(); ++i)
cin >> vec[i];
}
int main() {
int A, B, C;
get(A, B, C);
print(C < B & A < C ? "Yes" : "No");
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_set>
#include <vector>
using namespace std;
#define FOR(i, N) for (int i = 0; i < (int)N; i++)
#define FORIN(i, a, b) for (int i = a; i < (int)b; i++)
#define ALL(x) (x).begin(), (x).end()
#define MOD 1000000007
#define DEBUG(...) debug(__LINE__, ":" __VA_ARGS__)
using Pi = pair<int, int>;
using ll = long long;
const int INF = 1 << 28;
string to_string(string s) { return s; }
template <class T> string to_string(vector<T> v) {
string ret = "{";
for (int i = 0; i < v.size() - 1; ++i) {
ret += to_string(v[i]) + ",";
}
if (v.size() > 0) {
ret += to_string(v.back());
}
ret += "}";
return ret;
}
void debug() { cerr << endl; }
template <class Head, class... Tail> void debug(Head head, Tail... tail) {
cerr << to_string(head) << " ";
debug(tail...);
}
void print() { cout << endl; }
template <class Head, class... Tail> void print(Head head, Tail... tail) {
cout << to_string(head);
print(tail...);
}
void get() {}
template <class Head, class... Tail> void get(Head &head, Tail &...tail) {
cin >> head;
get(tail...);
}
template <class T> void getv(vector<T> &vec) {
for (int i = 0; i < vec.size(); ++i)
cin >> vec[i];
}
int main() {
int A, B, C;
get(A, B, C);
print(!(C < B ^ A < C) ? "Yes" : "No");
return 0;
} | [
"call.arguments.add",
"control_flow.loop.for.condition.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 877,783 | 877,784 | u656771711 | cpp |
p03067 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_set>
#include <vector>
using namespace std;
#define FOR(i, N) for (int i = 0; i < (int)N; i++)
#define FORIN(i, a, b) for (int i = a; i < (int)b; i++)
#define ALL(x) (x).begin(), (x).end()
#define MOD 1000000007
#define DEBUG(...) debug(__LINE__, ":" __VA_ARGS__)
using Pi = pair<int, int>;
using ll = long long;
const int INF = 1 << 28;
string to_string(string s) { return s; }
template <class T> string to_string(vector<T> v) {
string ret = "{";
for (int i = 0; i < v.size() - 1; ++i) {
ret += to_string(v[i]) + ",";
}
if (v.size() > 0) {
ret += to_string(v.back());
}
ret += "}";
return ret;
}
void debug() { cerr << endl; }
template <class Head, class... Tail> void debug(Head head, Tail... tail) {
cerr << to_string(head) << " ";
debug(tail...);
}
void print() { cout << endl; }
template <class Head, class... Tail> void print(Head head, Tail... tail) {
cout << to_string(head);
print(tail...);
}
void get() {}
template <class Head, class... Tail> void get(Head &head, Tail &...tail) {
cin >> head;
get(tail...);
}
template <class T> void getv(vector<T> &vec) {
for (int i = 0; i < vec.size(); ++i)
cin >> vec[i];
}
int main() {
int A, B, C;
get(A, B, C);
print(A < B & B < C ? "Yes" : "No");
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_set>
#include <vector>
using namespace std;
#define FOR(i, N) for (int i = 0; i < (int)N; i++)
#define FORIN(i, a, b) for (int i = a; i < (int)b; i++)
#define ALL(x) (x).begin(), (x).end()
#define MOD 1000000007
#define DEBUG(...) debug(__LINE__, ":" __VA_ARGS__)
using Pi = pair<int, int>;
using ll = long long;
const int INF = 1 << 28;
string to_string(string s) { return s; }
template <class T> string to_string(vector<T> v) {
string ret = "{";
for (int i = 0; i < v.size() - 1; ++i) {
ret += to_string(v[i]) + ",";
}
if (v.size() > 0) {
ret += to_string(v.back());
}
ret += "}";
return ret;
}
void debug() { cerr << endl; }
template <class Head, class... Tail> void debug(Head head, Tail... tail) {
cerr << to_string(head) << " ";
debug(tail...);
}
void print() { cout << endl; }
template <class Head, class... Tail> void print(Head head, Tail... tail) {
cout << to_string(head);
print(tail...);
}
void get() {}
template <class Head, class... Tail> void get(Head &head, Tail &...tail) {
cin >> head;
get(tail...);
}
template <class T> void getv(vector<T> &vec) {
for (int i = 0; i < vec.size(); ++i)
cin >> vec[i];
}
int main() {
int A, B, C;
get(A, B, C);
print(!(C < B ^ A < C) ? "Yes" : "No");
return 0;
} | [
"control_flow.loop.for.condition.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 877,785 | 877,784 | u656771711 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (c <= max(a, b) && c >= max(a, b)) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (c <= max(a, b) && c >= min(a, b)) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} | [
"misc.opposites",
"identifier.change",
"call.function.change",
"control_flow.branch.if.condition.change"
] | 877,795 | 877,796 | u244626757 | cpp |
p03067 | #include <algorithm>
#include <stdio.h>
#include <utility>
using namespace std;
int main() {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
printf("%s", (min(a, b) < c && c < min(b, a)) ? "Yes" : "No");
return 0;
} | #include <algorithm>
#include <stdio.h>
#include <utility>
using namespace std;
int main() {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
printf("%s", (min(a, b) < c && c < max(b, a)) ? "Yes" : "No");
return 0;
} | [
"misc.opposites",
"identifier.change",
"call.function.change",
"control_flow.loop.for.condition.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 877,799 | 877,800 | u114234520 | cpp |
p03067 | #include <algorithm>
#include <complex>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
int main() {
complex<long double> cmpmp;
const long long int mod = 1000000007;
map<long long int, long long int> mp;
// cout << fixed << setprecision(10);
long long int N, A, B, h[200] = {}, left = 0, right = 1000000000, bomb,
sum[15] = {};
string str;
cin >> h[0] >> h[1] >> h[2];
A = h[1];
sort(h, h + 3);
if (h[1] == A) {
cout << "Yes";
} else {
cout << "No";
}
} | #include <algorithm>
#include <complex>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
int main() {
complex<long double> cmpmp;
const long long int mod = 1000000007;
map<long long int, long long int> mp;
// cout << fixed << setprecision(10);
long long int N, A, B, h[200] = {}, left = 0, right = 1000000000, bomb,
sum[15] = {};
string str;
cin >> h[0] >> h[1] >> h[2];
A = h[2];
sort(h, h + 3);
if (h[1] == A) {
cout << "Yes";
} else {
cout << "No";
}
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change"
] | 877,801 | 877,802 | u018872912 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if ((C > A && C < B) || (C > B && C < A))
cout << "yes" << endl;
else
cout << "no" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if ((C > A && C < B) || (C > B && C < A))
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 877,807 | 877,808 | u757389058 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (C > A && C < B || C > B && C < A)
cout << "yes" << endl;
else
cout << "no" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if ((C > A && C < B) || (C > B && C < A))
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} | [
"control_flow.branch.if.condition.change",
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 877,810 | 877,808 | u757389058 | cpp |
p03067 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int a[3];
int b;
int main() {
cin >> a[0] >> a[1] >> a[2];
b = a[2];
sort(a, a + 3);
if (a[2] == b)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int a[3], b;
int main() {
cin >> a[0] >> a[1] >> a[2];
b = a[2];
sort(a, a + 3);
if (a[1] == b)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} | [
"literal.number.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 877,823 | 877,824 | u519950235 | cpp |
p03067 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int a[3];
int b;
int main() {
cin >> a[0] >> a[1] >> a[2];
b = a[1];
sort(a, a + 3);
if (a[1] == b)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int a[3], b;
int main() {
cin >> a[0] >> a[1] >> a[2];
b = a[2];
sort(a, a + 3);
if (a[1] == b)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change"
] | 877,825 | 877,824 | u519950235 | cpp |
p03067 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
using namespace std;
int a[3];
int d;
int main() {
cin >> a[0] >> a[1] >> a[2];
d = a[2];
sort(a, a + 1);
if (d == a[1])
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
using namespace std;
int a[3], d;
int main() {
cin >> a[0] >> a[1] >> a[2];
d = a[2];
sort(a, a + 3);
if (d == a[1])
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 877,826 | 877,827 | u519950235 | cpp |
p03067 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int a[3];
int b;
int main() {
cin >> a[0] >> a[1] >> a[2];
b = a[2];
sort(a, a + 3);
if (a[2] == b)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int a[3];
int b;
int main() {
cin >> a[0] >> a[1] >> a[2];
b = a[2];
sort(a, a + 3);
if (a[1] == b)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| [
"literal.number.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 877,823 | 877,828 | u519950235 | cpp |
p03067 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int a[3];
int b;
int main() {
cin >> a[0] >> a[1] >> a[2];
b = a[1];
sort(a, a + 3);
if (a[1] == b)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int a[3];
int b;
int main() {
cin >> a[0] >> a[1] >> a[2];
b = a[2];
sort(a, a + 3);
if (a[1] == b)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change"
] | 877,825 | 877,828 | u519950235 | cpp |
p03067 | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a < c < b) {
cout << "Yes" << endl;
} else if (b < c < a) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a < c && c < b) {
cout << "Yes" << endl;
} else if (b < c && c < a) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 877,837 | 877,838 | u896807328 | cpp |
p03067 | #include <stdio.h>
int main(void) {
int a, b, c;
scanf("%d %d %d", a, b, c);
if (a < c && b > c) {
printf("Yes");
} else if (a > c && b < c) {
printf("Yes");
} else {
printf("No");
}
} | #include <stdio.h>
int main(void) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
if (a < c && b > c) {
printf("Yes\n");
} else if (a > c && b < c) {
printf("Yes\n");
} else {
printf("No\n");
}
} | [
"expression.operation.unary.reference.add",
"literal.string.change",
"call.arguments.change",
"io.output.change",
"io.output.newline.add"
] | 877,841 | 877,842 | u485873133 | cpp |
p03067 | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b < c < a || a < c < b)
cout << "Yes" << endl;
else
cout << "No" << endl;
} | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b < c && c < a || a < c && c < b)
cout << "Yes" << endl;
else
cout << "No" << endl;
} | [
"control_flow.branch.if.condition.change"
] | 877,847 | 877,848 | u784706568 | cpp |
p03067 | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (((b > c) && (c > a)) || ((b > c) && (c > a)))
cout << "Yes" << endl;
else
cout << "No" << endl;
}
| #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (((b > c) && (c > a)) || ((b < c) && (c < a)))
cout << "Yes" << endl;
else
cout << "No" << endl;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 877,849 | 877,850 | u587883805 | cpp |
p03067 | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (c < min(a, b) || c > max(a, b))
cout << "NO";
else
cout << "YES";
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (c <= min(a, b) || c >= max(a, b))
cout << "No";
else
cout << "Yes";
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 877,853 | 877,854 | u671291651 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define endl '\n'
#define N 1e5 + 1;
#define INF 1e9
const ll MOD = 10e9 + 7;
ll max(ll a, ll b) { return a > b ? a : b; }
ll min(ll a, ll b) { return a < b ? a : b; }
vector<int> ans;
ll a[200001];
ll b[200001];
vector<int> sorted;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int a, b, c;
cin >> a >> b >> c;
b = max(a, b);
a = min(a, b);
if (b > c && a < c)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define endl '\n'
#define N 1e5 + 1;
#define INF 1e9
const ll MOD = 10e9 + 7;
ll max(ll a, ll b) { return a > b ? a : b; }
ll min(ll a, ll b) { return a < b ? a : b; }
vector<int> ans;
ll a[200001];
ll b[200001];
vector<int> sorted;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int a, b, c;
cin >> a >> b >> c;
int bb = max(a, b);
int aa = min(a, b);
if (bb > c && aa < c)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 877,859 | 877,860 | u990641118 | cpp |
p03067 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <float.h>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define endl '\n'
#define MOD 1000000007
#define INF 1ll << 30
#define MAX 100010
#define eps 1e-11
#define bit_max 1ll << 32
#define _USE_MATH_DEFINES
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
int a, b, c;
cin >> a >> b >> c;
int mx = max(a, max(b, c));
int mn = min(a, min(b, c));
if (b == mx || b == mn)
cout << "No";
else
cout << "Yes";
return 0;
} | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <float.h>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define endl '\n'
#define MOD 1000000007
#define INF 1ll << 30
#define MAX 100010
#define eps 1e-11
#define bit_max 1ll << 32
#define _USE_MATH_DEFINES
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
int a, b, c;
cin >> a >> b >> c;
int mx = max(a, max(b, c));
int mn = min(a, min(b, c));
if (c == mx || c == mn)
cout << "No";
else
cout << "Yes";
return 0;
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 877,863 | 877,864 | u566864240 | cpp |
p03067 | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if ((a < c && c < a) || (a > c && c > b)) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if ((a < c && c < b) || (a > c && c > b)) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 877,871 | 877,872 | u813102292 | cpp |
p03067 | #include "bits/stdc++.h"
using namespace std;
#define Rep(i, n) for (int i = 0; i < (int)(n); i++)
#define For(i, n1, n2) for (int i = (int)(n1); i < (int)(n2); i++)
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define RREP(i, n) for (ll i = ((ll)(n)-1); i >= 0; i--)
#define FOR(i, n1, n2) for (ll i = (ll)(n1); i < (ll)(n2); i++)
#define put(a) cout << a << "\n"
#define all(a) (a).begin(), (a).end()
#define SORT(a) sort((a).begin(), (a).end())
#define oorret 0
#define oor(x) \
[&]() { \
try { \
x; \
} catch (const out_of_range &oor) { \
return oorret; \
} \
return x; \
}()
#define SZ(x) ((ll)(x).size())
typedef long long ll;
typedef pair<int, int> P;
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
ll a, b, c;
int main() {
cin >> a >> b >> c;
int mind = min(a, c);
int maxd = max(a, c);
if (mind <= c && c <= maxd) {
put("Yes");
} else {
put("No");
}
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
#define Rep(i, n) for (int i = 0; i < (int)(n); i++)
#define For(i, n1, n2) for (int i = (int)(n1); i < (int)(n2); i++)
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define RREP(i, n) for (ll i = ((ll)(n)-1); i >= 0; i--)
#define FOR(i, n1, n2) for (ll i = (ll)(n1); i < (ll)(n2); i++)
#define put(a) cout << a << "\n"
#define all(a) (a).begin(), (a).end()
#define SORT(a) sort((a).begin(), (a).end())
#define oorret 0
#define oor(x) \
[&]() { \
try { \
x; \
} catch (const out_of_range &oor) { \
return oorret; \
} \
return x; \
}()
#define SZ(x) ((ll)(x).size())
typedef long long ll;
typedef pair<int, int> P;
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
ll a, b, c;
int main() {
cin >> a >> b >> c;
int mind = min(a, b);
int maxd = max(a, b);
if (mind <= c && c <= maxd) {
put("Yes");
} else {
put("No");
}
return 0;
}
| [
"identifier.change",
"call.arguments.change"
] | 877,877 | 877,878 | u030685402 | cpp |
p03067 | #include <algorithm>
#include <iostream>
#include <queue>
#include <sstream>
#include <stdexcept>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a < c && c < b)
cout << "Yes" << endl;
if (b < c && c < a)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
| #include <algorithm>
#include <iostream>
#include <queue>
#include <sstream>
#include <stdexcept>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a < c && c < b)
cout << "Yes" << endl;
else if (b < c && c < a)
cout << "Yes" << endl;
else
cout << "No" << endl;
} | [
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove"
] | 877,879 | 877,880 | u139300044 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a < c && c < b) {
cout << "yes" << endl;
return 0;
}
if (b < c && c < a) {
cout << "yes" << endl;
return 0;
}
cout << "no" << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a < c && c < b) {
cout << "Yes" << endl;
return 0;
}
if (b < c && c < a) {
cout << "Yes" << endl;
return 0;
}
cout << "No" << endl;
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 877,881 | 877,882 | u832103304 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
if ((max(a, b) > c) && (c > min(a, b))) {
printf("Yes");
} else {
printf("False");
}
printf("\n");
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
if ((max(a, b) > c) && (c > min(a, b))) {
printf("Yes");
} else {
printf("No");
}
printf("\n");
} | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 877,884 | 877,885 | u597477070 | cpp |
p03067 | #include <bits/stdc++.h>
#define N 1000005
#define ll long long int
#define MP make_pair
#define pb push_back
#define ppb pop_back
#define sp " "
#define endl "\n"
#define fi first
#define se second
#define ii pair<int, int>
#define lli pair<ll, ll>
#define fast \
cin.tie(0); \
cout.tie(0); \
ios_base::sync_with_stdio(false)
#define fast2 \
freopen("myfile.in", "r", stdin); \
freopen("myfile.out", "w", stdout);
#define mod 1000000007
#define fs(x, y) \
for (int i = 1; i <= y; i++) \
cin >> x[i]
#define fo(i, x, y) for (int i = x; i <= y; i++)
using namespace std;
ll n, m, ar[N], sum;
int main() {
fast;
cin >> ar[1] >> ar[2] >> ar[3];
if (ar[3] > min(ar[1], ar[2]) && ar[3] < max(ar[1], ar[2]))
cout << "YES";
else
cout << "No";
} | #include <bits/stdc++.h>
#define N 1000005
#define ll long long int
#define MP make_pair
#define pb push_back
#define ppb pop_back
#define sp " "
#define endl "\n"
#define fi first
#define se second
#define ii pair<int, int>
#define lli pair<ll, ll>
#define fast \
cin.tie(0); \
cout.tie(0); \
ios_base::sync_with_stdio(false)
#define fast2 \
freopen("myfile.in", "r", stdin); \
freopen("myfile.out", "w", stdout);
#define mod 1000000007
#define fs(x, y) \
for (int i = 1; i <= y; i++) \
cin >> x[i]
#define fo(i, x, y) for (int i = x; i <= y; i++)
using namespace std;
ll n, m, ar[N], sum;
int main() {
fast;
cin >> ar[1] >> ar[2] >> ar[3];
if (ar[3] > min(ar[1], ar[2]) && ar[3] < max(ar[1], ar[2]))
cout << "Yes";
else
cout << "No";
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 877,900 | 877,901 | u533101919 | cpp |
p03067 | #include <bits/stdc++.h>
#define N 1000005
#define ll long long int
#define MP make_pair
#define pb push_back
#define ppb pop_back
#define sp " "
#define endl "\n"
#define fi first
#define se second
#define ii pair<int, int>
#define lli pair<ll, ll>
#define fast \
cin.tie(0); \
cout.tie(0); \
ios_base::sync_with_stdio(false)
#define fast2 \
freopen("myfile.in", "r", stdin); \
freopen("myfile.out", "w", stdout);
#define mod 1000000007
#define fs(x, y) \
for (int i = 1; i <= y; i++) \
cin >> x[i]
#define fo(i, x, y) for (int i = x; i <= y; i++)
using namespace std;
ll n, m, ar[N], sum;
int main() {
fast;
cin >> ar[1] >> ar[2] >> ar[3];
if (ar[3] >= min(ar[1], ar[2]) && ar[3] <= max(ar[1], ar[2]))
cout << "YES";
else
cout << "No";
} | #include <bits/stdc++.h>
#define N 1000005
#define ll long long int
#define MP make_pair
#define pb push_back
#define ppb pop_back
#define sp " "
#define endl "\n"
#define fi first
#define se second
#define ii pair<int, int>
#define lli pair<ll, ll>
#define fast \
cin.tie(0); \
cout.tie(0); \
ios_base::sync_with_stdio(false)
#define fast2 \
freopen("myfile.in", "r", stdin); \
freopen("myfile.out", "w", stdout);
#define mod 1000000007
#define fs(x, y) \
for (int i = 1; i <= y; i++) \
cin >> x[i]
#define fo(i, x, y) for (int i = x; i <= y; i++)
using namespace std;
ll n, m, ar[N], sum;
int main() {
fast;
cin >> ar[1] >> ar[2] >> ar[3];
if (ar[3] > min(ar[1], ar[2]) && ar[3] < max(ar[1], ar[2]))
cout << "Yes";
else
cout << "No";
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 877,902 | 877,901 | u533101919 | cpp |
p03067 | #include <bits/stdc++.h>
#define N 1000005
#define ll long long int
#define MP make_pair
#define pb push_back
#define ppb pop_back
#define sp " "
#define endl "\n"
#define fi first
#define se second
#define ii pair<int, int>
#define lli pair<ll, ll>
#define fast \
cin.tie(0); \
cout.tie(0); \
ios_base::sync_with_stdio(false)
#define fast2 \
freopen("myfile.in", "r", stdin); \
freopen("myfile.out", "w", stdout);
#define mod 1000000007
#define fs(x, y) \
for (int i = 1; i <= y; i++) \
cin >> x[i]
#define fo(i, x, y) for (int i = x; i <= y; i++)
using namespace std;
ll n, m, ar[N], sum;
int main() {
fast;
cin >> ar[1] >> ar[2] >> ar[3];
if (ar[3] >= min(ar[1], ar[2]) && ar[3] >= max(ar[1], ar[2]))
cout << "YES";
else
cout << "No";
} | #include <bits/stdc++.h>
#define N 1000005
#define ll long long int
#define MP make_pair
#define pb push_back
#define ppb pop_back
#define sp " "
#define endl "\n"
#define fi first
#define se second
#define ii pair<int, int>
#define lli pair<ll, ll>
#define fast \
cin.tie(0); \
cout.tie(0); \
ios_base::sync_with_stdio(false)
#define fast2 \
freopen("myfile.in", "r", stdin); \
freopen("myfile.out", "w", stdout);
#define mod 1000000007
#define fs(x, y) \
for (int i = 1; i <= y; i++) \
cin >> x[i]
#define fo(i, x, y) for (int i = x; i <= y; i++)
using namespace std;
ll n, m, ar[N], sum;
int main() {
fast;
cin >> ar[1] >> ar[2] >> ar[3];
if (ar[3] > min(ar[1], ar[2]) && ar[3] < max(ar[1], ar[2]))
cout << "Yes";
else
cout << "No";
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 877,903 | 877,901 | u533101919 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<string> vs;
typedef vector<long long> vl;
#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define rep(i, n) FOR(i, 0, n)
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a < c && b > c)
cout << "yes" << endl;
else if (a > c && b < c)
cout << "yes" << endl;
else
cout << "no" << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<string> vs;
typedef vector<long long> vl;
#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define rep(i, n) FOR(i, 0, n)
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a < c && b > c)
cout << "Yes" << endl;
else if (a > c && b < c)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 877,910 | 877,911 | u638752443 | cpp |
p03067 | #include <iostream>
#include <stdio.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
printf(((c >= a && c <= b) || (c >= b && c <= a)) ? "YES" : "NO");
return 0;
} | #include <iostream>
#include <stdio.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
printf(((c >= a && c <= b) || (c >= b && c <= a)) ? "Yes" : "No");
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"call.arguments.change",
"io.output.change"
] | 877,916 | 877,917 | u817141277 | cpp |
p03067 | #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(), a.end()
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
#define limit(x, l, r) max(l, min(x, r))
#define lims(x, l, r) (x = max(l, min(x, r)))
#define isin(x, l, r) ((l) <= (x) && (x) < (r))
#define pb push_back
#define sz(x) (int)(x).size()
#define pcnt __builtin_popcountll
#define uni(x) x.erase(unique(rng(x)), x.end())
#define snuke srand((unsigned)clock() + (unsigned)time(NULL));
#define show(x) cout << #x << " = " << x << endl;
#define PQ(T) priority_queue<T, v(T), greater<T>>
#define bn(x) ((1 << x) - 1)
#define dup(x, y) (((x) + (y)-1) / (y))
#define newline puts("")
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef unsigned uint;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
template <typename T> inline istream &operator>>(istream &i, v(T) & v) {
rep(j, sz(v)) i >> v[j];
return i;
}
template <typename T> string join(const v(T) & v) {
stringstream s;
rep(i, sz(v)) s << ' ' << v[i];
return s.str().substr(1);
}
template <typename T> inline ostream &operator<<(ostream &o, const v(T) & v) {
if (sz(v))
o << join(v);
return o;
}
template <typename T1, typename T2>
inline istream &operator>>(istream &i, pair<T1, T2> &v) {
return i >> v.fi >> v.se;
}
template <typename T1, typename T2>
inline ostream &operator<<(ostream &o, const pair<T1, T2> &v) {
return o << v.fi << "," << v.se;
}
template <typename T> inline ll suma(const v(T) & a) {
ll res(0);
for (auto &&x : a)
res += x;
return res;
}
const double eps = 1e-10;
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
#define dame \
{ \
puts("-1"); \
return 0; \
}
#define yn \
{ puts("Yes"); } \
else { \
puts("No"); \
}
const int MX = 200005;
#define RET(ans) \
{ \
cout << ans << endl; \
return 0; \
}
// 二次元ベクターの基本
/*
vector<vector<int>> dp; // 宣言
dp.resize(n); // 1次元めの要素数決定
dp[i].push_back(int); // プッシュバック
rep(i,n){
sort(dp[i].begin(),dp[i].end()); // 二次元めを昇順ソート
}
*/
// 整数スキャン（複数）
/*
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
// n個の整数のスキャン
/*
ll a[n] = {};
rep(i,n){
scanf("%lld",&a[i]);
}
*/
// 文字列スキャン
/*
string s; cin >> s;
*/
// n個の文字列スキャン
/*
vector<string> slist;
rep(i,n){
string s; cin >> s;
slist.push_back(s);
}
*/
int main() {
int a, b, c;
cin >> a >> b >> c;
if (min(a, c) < b && b < max(a, c))
yn;
return 0;
}
| #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(), a.end()
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
#define limit(x, l, r) max(l, min(x, r))
#define lims(x, l, r) (x = max(l, min(x, r)))
#define isin(x, l, r) ((l) <= (x) && (x) < (r))
#define pb push_back
#define sz(x) (int)(x).size()
#define pcnt __builtin_popcountll
#define uni(x) x.erase(unique(rng(x)), x.end())
#define snuke srand((unsigned)clock() + (unsigned)time(NULL));
#define show(x) cout << #x << " = " << x << endl;
#define PQ(T) priority_queue<T, v(T), greater<T>>
#define bn(x) ((1 << x) - 1)
#define dup(x, y) (((x) + (y)-1) / (y))
#define newline puts("")
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef unsigned uint;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
template <typename T> inline istream &operator>>(istream &i, v(T) & v) {
rep(j, sz(v)) i >> v[j];
return i;
}
template <typename T> string join(const v(T) & v) {
stringstream s;
rep(i, sz(v)) s << ' ' << v[i];
return s.str().substr(1);
}
template <typename T> inline ostream &operator<<(ostream &o, const v(T) & v) {
if (sz(v))
o << join(v);
return o;
}
template <typename T1, typename T2>
inline istream &operator>>(istream &i, pair<T1, T2> &v) {
return i >> v.fi >> v.se;
}
template <typename T1, typename T2>
inline ostream &operator<<(ostream &o, const pair<T1, T2> &v) {
return o << v.fi << "," << v.se;
}
template <typename T> inline ll suma(const v(T) & a) {
ll res(0);
for (auto &&x : a)
res += x;
return res;
}
const double eps = 1e-10;
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
#define dame \
{ \
puts("-1"); \
return 0; \
}
#define yn \
{ puts("Yes"); } \
else { \
puts("No"); \
}
const int MX = 200005;
#define RET(ans) \
{ \
cout << ans << endl; \
return 0; \
}
// 二次元ベクターの基本
/*
vector<vector<int>> dp; // 宣言
dp.resize(n); // 1次元めの要素数決定
dp[i].push_back(int); // プッシュバック
rep(i,n){
sort(dp[i].begin(),dp[i].end()); // 二次元めを昇順ソート
}
*/
// 整数スキャン（複数）
/*
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
// n個の整数のスキャン
/*
ll a[n] = {};
rep(i,n){
scanf("%lld",&a[i]);
}
*/
// 文字列スキャン
/*
string s; cin >> s;
*/
// n個の文字列スキャン
/*
vector<string> slist;
rep(i,n){
string s; cin >> s;
slist.push_back(s);
}
*/
int main() {
int a, b, c;
cin >> a >> b >> c;
if (min(a, b) < c && c < max(a, b))
yn;
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 877,936 | 877,937 | u791593901 | cpp |
p03067 | #include <iostream>
using namespace std;
int main() {
int a[3];
for (int &i : a)
cin >> i;
if (a[2] > a[0] and a[2] < a[1])
cout << "Yes";
else if (a[2] < a[0] and a[2] > a[1])
cout << "yes";
else
cout << "No";
} | #include <iostream>
using namespace std;
int main() {
int a[3];
for (int &i : a)
cin >> i;
if (a[2] > a[0] and a[2] < a[1])
cout << "Yes";
else if (a[2] < a[0] and a[2] > a[1])
cout << "Yes";
else
cout << "No";
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 877,940 | 877,941 | u169909396 | cpp |
p03067 | #include <iostream>
using namespace std;
int main() {
int a[3];
for (int &i : a)
cin >> i;
if (a[2] > a[0] and a[2] < a[1])
cout << "yes";
else if (a[2] < a[0] and a[2] > a[1])
cout << "yes";
else
cout << "no";
} | #include <iostream>
using namespace std;
int main() {
int a[3];
for (int &i : a)
cin >> i;
if (a[2] > a[0] and a[2] < a[1])
cout << "Yes";
else if (a[2] < a[0] and a[2] > a[1])
cout << "Yes";
else
cout << "No";
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 877,942 | 877,941 | u169909396 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (A < C && C < B && A < B) {
cout << "Yes" << endl;
}
else if (B < C && C < A && B < A) {
cout << "Yes" << endl;
}
else {
cout << "Yo" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (A < C && C < B && A < B) {
cout << "Yes" << endl;
}
else if (B < C && C < A && B < A) {
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
} | [
"literal.string.change",
"io.output.change"
] | 877,943 | 877,944 | u562915225 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A;
cin >> B;
cin >> C;
if ((A > C && C > B) || (A < C && A < B)) {
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A;
cin >> B;
cin >> C;
if ((A > C && C > B) || (A < C && C < B)) {
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 877,945 | 877,946 | u783598783 | cpp |
p03067 | #include "bits/stdc++.h"
using namespace std;
int main(void) {
int a, b, c;
cin >> a >> b >> c;
if (a < b) {
if (b > c) {
cout << "Yes";
} else {
cout << "No";
}
} else {
if (b < c) {
cout << "Yes";
} else {
cout << "No";
}
}
return 0;
} | #include "bits/stdc++.h"
using namespace std;
int main(void) {
int a, b, c;
cin >> a >> b >> c;
if (a < c) {
if (b > c) {
cout << "Yes";
} else {
cout << "No";
}
} else {
if (b < c) {
cout << "Yes";
} else {
cout << "No";
}
}
return 0;
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 877,949 | 877,950 | u700598037 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (A > C > B) {
cout << "Yes" << endl;
} else if (B > C > A) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (A > C && C > B) {
cout << "Yes" << endl;
} else if (B > C && C > A) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} | [
"control_flow.branch.if.condition.change"
] | 877,953 | 877,954 | u801530021 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (A > C > B) {
cout << "Yes" << endl;
} else if (B > C > A) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (A > C && C > B) {
cout << "Yes" << endl;
} else if (B > C && C > A) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
| [
"control_flow.branch.if.condition.change"
] | 877,953 | 877,955 | u801530021 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
int x[3] = {A, B, C};
sort(x, x + 3);
if (x[1] == B) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
int x[3] = {A, B, C};
sort(x, x + 3);
if (x[1] == C) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 877,969 | 877,970 | u618697411 | cpp |
p03067 | #include <iostream>
using namespace std;
void yorimichi(int a, int b, int c) {
if ((c - b) * (b - a) < 0) {
cout << "Yes" << endl;
} else
cout << "No" << endl;
}
int main() {
int A, B, C;
cin >> A >> B >> C;
yorimichi(A, B, C);
return 0;
}
| #include <iostream>
using namespace std;
void yorimichi(int a, int b, int c) {
if ((c - b) * (c - a) < 0) {
cout << "Yes" << endl;
} else
cout << "No" << endl;
}
int main() {
int A, B, C;
cin >> A >> B >> C;
yorimichi(A, B, C);
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 877,977 | 877,978 | u070471279 | cpp |
p03067 | #include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; ++i)
#define FOR(i, a, b) for (int i = a; i <= b; ++i)
#define FORR(i, a, b) for (int i = a; i >= b; --i)
#define ALL(c) (c).begin(), (c).end()
typedef long long ll;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef vector<VI> VVI;
typedef vector<VL> VVL;
typedef pair<int, int> P;
typedef pair<ll, ll> PL;
typedef vector<double> VD;
typedef vector<VD> VVD;
int in() {
int x;
scanf("%d", &x);
return x;
}
ll lin() {
ll x;
scanf("%lld", &x);
return x;
}
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << ((a - b) * (c - b) < 0 ? "Yes" : "No") << endl;
return 0;
}
| #include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; ++i)
#define FOR(i, a, b) for (int i = a; i <= b; ++i)
#define FORR(i, a, b) for (int i = a; i >= b; --i)
#define ALL(c) (c).begin(), (c).end()
typedef long long ll;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef vector<VI> VVI;
typedef vector<VL> VVL;
typedef pair<int, int> P;
typedef pair<ll, ll> PL;
typedef vector<double> VD;
typedef vector<VD> VVD;
int in() {
int x;
scanf("%d", &x);
return x;
}
ll lin() {
ll x;
scanf("%lld", &x);
return x;
}
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << ((a - c) * (b - c) < 0 ? "Yes" : "No") << endl;
return 0;
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"io.output.change",
"expression.operation.binary.remove"
] | 877,981 | 877,982 | u016572066 | cpp |
p03067 | #include <cstdio>
#include <iostream>
using namespace std;
int main() {
int inputnum = 3;
int input[inputnum];
for (int i = 0; i < inputnum; i++) {
cin >> input[i];
}
if (input[1] > input[0]) {
if (input[2] >= input[0] & input[2] <= input[1]) {
cout << "Yes";
} else {
cout << "No";
}
} else {
if (input[2] >= input[1] & input[2] <= input[0]) {
cout << "YES";
} else {
cout << "NO";
}
}
return 0;
} | #include <cstdio>
#include <iostream>
using namespace std;
int main() {
int inputnum = 3;
int input[inputnum];
for (int i = 0; i < inputnum; i++) {
cin >> input[i];
}
if (input[1] > input[0]) {
if (input[2] >= input[0] & input[2] <= input[1]) {
cout << "Yes";
} else {
cout << "No";
}
} else {
if (input[2] >= input[1] & input[2] <= input[0]) {
cout << "Yes";
} else {
cout << "No";
}
}
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 877,983 | 877,984 | u987547145 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
int a, b, c;
int main() {
cin >> a >> b >> c;
if (min(a, b) >= c && max(a, b) <= c) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int a, b, c;
int main() {
cin >> a >> b >> c;
if (min(a, b) <= c && max(a, b) >= c) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 877,989 | 877,990 | u191196346 | cpp |
p03067 | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if ((b < c && b < a) || (b > a && b > c)) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if ((b < c && c < a) || (c > a && b > c)) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 877,991 | 877,992 | u201188078 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
using ll = long long int;
const int MAX = (int)(1e5 + 5);
const ll INF = (ll)(1e10 + 5);
int a, b, c;
int main(void) {
// Here your code !
scanf("%d %d %d", &a, &b, &c);
if ((a <= c && c <= b) || (b <= c && c <= a)) {
printf("Yes\n");
} else {
printf("%No\n");
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long int;
const int MAX = (int)(1e5 + 5);
const ll INF = (ll)(1e10 + 5);
int a, b, c;
int main(void) {
// Here your code !
scanf("%d %d %d", &a, &b, &c);
if ((a <= c && c <= b) || (b <= c && c <= a)) {
printf("Yes\n");
} else {
printf("No\n");
}
return 0;
}
| [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 877,997 | 877,998 | u497422208 | cpp |
p03067 | #include <iostream>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if ((C >= A && C <= B) || (C <= A && C >> B)) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} | #include <iostream>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if ((C >= A && C <= B) || (C <= A && C >= B)) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} | [
"control_flow.branch.if.condition.change"
] | 877,999 | 878,000 | u841494167 | cpp |
p03067 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
/*
int main() {
int N;
string S;
int K;
cin >> N >> S >> K;
return 0;
}
*/
int main() {
int A, B, C;
cin >> A >> B >> C;
string ans;
if ((A < C && C < B) || (B < C && C << A)) {
ans = "Yes";
} else {
ans = "No";
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
string ans;
if ((A < C && C < B) || (B < C && C < A)) {
ans = "Yes";
} else {
ans = "No";
}
cout << ans << endl;
return 0;
} | [
"misc.typo",
"control_flow.branch.if.condition.change"
] | 878,001 | 878,002 | u654115954 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if ((A - B) * (B - C) < 0)
cout << "Yes" << endl;
else
cout << "No" << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if ((A - C) * (B - C) < 0)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 878,003 | 878,004 | u889812821 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (A < C && C < B) {
cout << "Yes" << endl;
}
if (B < C && C < A) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (A < C && C < B) {
cout << "Yes" << endl;
} else if (B < C && C < A) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} | [
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove"
] | 878,005 | 878,006 | u626463672 | cpp |
p03067 | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a < b) {
cout << (c < b ? "Yes" : "No") << endl;
} else {
cout << (b < c ? "Yes" : "No") << endl;
}
}
| #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a < c) {
cout << (c < b ? "Yes" : "No") << endl;
} else {
cout << (b < c ? "Yes" : "No") << endl;
}
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 878,009 | 878,010 | u081445141 | cpp |
p03067 | #include <iostream>
using namespace std;
int main(void) {
int a, b, c;
cin >> a >> b >> c;
if ((c > a and c > b) or (c < a and c < b)) {
cout << "no" << endl;
} else {
cout << "yes" << endl;
}
return 0;
}
| #include <iostream>
using namespace std;
int main(void) {
int a, b, c;
cin >> a >> b >> c;
if ((c > a and c > b) or (c < a and c < b)) {
cout << "No" << endl;
} else {
cout << "Yes" << endl;
}
return 0;
}
| [
"literal.string.change",
"literal.string.case.change",
"expression.operation.binary.change"
] | 878,013 | 878,014 | u471030817 | cpp |
p03067 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#define rg register
#define il inline
using namespace std;
typedef long long ll;
ll read() {
ll ans = 0, flag = 1;
char ch;
while ((ch = getchar()) < '0' || ch > '9')
if (ch == '-')
flag = -1;
ans = ch ^ 48;
while ((ch = getchar()) >= '0' && ch <= '9')
ans = (ans << 3) + (ans << 1) + (ch ^ 48);
return flag * ans;
}
int main() {
int a, b, c;
cin >> a >> b >> c;
if (c <= max(a, c) && c >= min(a, c))
puts("Yes");
else
puts("No");
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#define rg register
#define il inline
using namespace std;
typedef long long ll;
ll read() {
ll ans = 0, flag = 1;
char ch;
while ((ch = getchar()) < '0' || ch > '9')
if (ch == '-')
flag = -1;
ans = ch ^ 48;
while ((ch = getchar()) >= '0' && ch <= '9')
ans = (ans << 3) + (ans << 1) + (ch ^ 48);
return flag * ans;
}
int main() {
int a, b, c;
cin >> a >> b >> c;
if (c < max(a, b) && c > min(a, b))
puts("Yes");
else
puts("No");
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"identifier.change"
] | 878,025 | 878,026 | u361558096 | cpp |
p03067 | #include <bits/stdc++.h>
//#pragma warning( disable : 4996 )
#define ll long long
#define pb push_back
#define endl '\n'
#define fastIO \
cin.tie(0); \
ios_base::sync_with_stdio(false)
#define pii pair<int, int>
#define eps 1e-13
#define N 14
using namespace std;
inline void init() {
int a, b, c;
cin >> a >> b >> c;
if (a < b)
swap(a, b);
if (c <= a && a >= b)
cout << "Yes";
else
cout << "No";
}
inline void solve() { cout << endl; }
int main() {
fastIO;
init();
solve();
return 0;
} | #include <bits/stdc++.h>
//#pragma warning( disable : 4996 )
#define ll long long
#define pb push_back
#define endl '\n'
#define fastIO \
cin.tie(0); \
ios_base::sync_with_stdio(false)
#define pii pair<int, int>
#define eps 1e-13
#define N 14
using namespace std;
inline void init() {
int a, b, c;
cin >> a >> b >> c;
if (a < b)
swap(a, b);
if (c <= a && c >= b)
cout << "Yes";
else
cout << "No";
}
inline void solve() { cout << endl; }
int main() {
fastIO;
init();
solve();
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 878,031 | 878,030 | u630936832 | cpp |
p03067 | #include <bits/stdc++.h>
//#pragma warning( disable : 4996 )
#define ll long long
#define pb push_back
#define endl '\n'
#define fastIO \
cin.tie(0); \
ios_base::sync_with_stdio(false)
#define pii pair<int, int>
#define eps 1e-13
#define N 14
using namespace std;
inline void init() {
int a, b, c;
cin >> a >> b >> c;
if (a < b)
swap(a, b);
if (c <= a && a >= b)
cout << "yes";
else
cout << "no";
}
inline void solve() { cout << endl; }
int main() {
fastIO;
init();
solve();
return 0;
} | #include <bits/stdc++.h>
//#pragma warning( disable : 4996 )
#define ll long long
#define pb push_back
#define endl '\n'
#define fastIO \
cin.tie(0); \
ios_base::sync_with_stdio(false)
#define pii pair<int, int>
#define eps 1e-13
#define N 14
using namespace std;
inline void init() {
int a, b, c;
cin >> a >> b >> c;
if (a < b)
swap(a, b);
if (c <= a && c >= b)
cout << "Yes";
else
cout << "No";
}
inline void solve() { cout << endl; }
int main() {
fastIO;
init();
solve();
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change",
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 878,032 | 878,030 | u630936832 | cpp |
p03067 | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (((a < c) && (c < b)) && ((b < c) && (c < a))) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (((a < c) && (c < b)) || ((b < c) && (c < a))) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | [
"misc.opposites",
"control_flow.branch.if.condition.change"
] | 878,035 | 878,036 | u509936198 | cpp |
p03067 | #define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define repn(i, n) for (int i = 1; i <= (int)(n); i++)
#define reprn(i, n) for (int i = ((int)(n)); i > 0; i--)
#define all(x) (x).begin(), (x).end()
using llint = long long int;
using lint = long int;
#include <algorithm>
#include <array>
#include <iomanip>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
string s;
if (a < c && c < b) {
s = "Yes";
}
if (b < c && c < a) {
s = "Yes";
} else {
s = "No";
}
cout << s << endl;
return 0;
} | #define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define repn(i, n) for (int i = 1; i <= (int)(n); i++)
#define reprn(i, n) for (int i = ((int)(n)); i > 0; i--)
#define all(x) (x).begin(), (x).end()
using llint = long long int;
using lint = long int;
#include <algorithm>
#include <array>
#include <iomanip>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
string s;
if (a < c && c < b) {
s = "Yes";
} else if (b < c && c < a) {
s = "Yes";
} else {
s = "No";
}
cout << s << endl;
return 0;
} | [
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove"
] | 878,039 | 878,040 | u659075382 | cpp |
p03067 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define REP1(i, n) for (int i = 1; i <= (n); i++)
#define pb push_back
#define mp make_pair
#define scan(argument) cin >> argument
#define prin(argument) cout << argument << endl
#define kaigyo cout << endl
#define EPS 1e-7
#define ALL(obj) (obj).begin(), (obj).end()
using ul = unsigned long;
using ll = long long;
using ld = long double;
using vint = vector<int>;
using vll = vector<ll>;
using pint = pair<int, int>;
using pll = pair<ll, ll>;
using vpint = vector<pint>;
using vpll = vector<pll>;
const int INF = (int)1e9 + 1;
const int MOD = (int)1e9 + 7;
int n;
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int a, b, c;
scan(a);
scan(b);
scan(c);
// vint s(n);
// REP(i, n) scan(s[i]);
if ((a < c && c < b) || (a > c || c > b))
cout << "Yes";
else
cout << "No";
// cout << << endl;
return 0;
}
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define REP1(i, n) for (int i = 1; i <= (n); i++)
#define pb push_back
#define mp make_pair
#define scan(argument) cin >> argument
#define prin(argument) cout << argument << endl
#define kaigyo cout << endl
#define EPS 1e-7
#define ALL(obj) (obj).begin(), (obj).end()
using ul = unsigned long;
using ll = long long;
using ld = long double;
using vint = vector<int>;
using vll = vector<ll>;
using pint = pair<int, int>;
using pll = pair<ll, ll>;
using vpint = vector<pint>;
using vpll = vector<pll>;
const int INF = (int)1e9 + 1;
const int MOD = (int)1e9 + 7;
int n;
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int a, b, c;
scan(a);
scan(b);
scan(c);
// vint s(n);
// REP(i, n) scan(s[i]);
if ((a < c && c < b) || (a > c && c > b))
cout << "Yes";
else
cout << "No";
// cout << << endl;
return 0;
}
| [
"misc.opposites",
"control_flow.branch.if.condition.change"
] | 878,043 | 878,044 | u863104798 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
#define fol(i, n) for (int i = 0; i < n; i++)
#define pb push_back
typedef long long ll;
typedef pair<int, int> P;
typedef vector<P> vip;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a > c)
swap(a, c);
if (a < c && c < b) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define fol(i, n) for (int i = 0; i < n; i++)
#define pb push_back
typedef long long ll;
typedef pair<int, int> P;
typedef vector<P> vip;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a > b)
swap(a, b);
if (a < c && c < b) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change",
"call.arguments.change"
] | 878,060 | 878,061 | u171026188 | cpp |
p03067 | #include <bits/stdc++.h>
using namespace std;
#define fol(i, n) for (int i = 0; i < n; i++)
#define pb push_back
typedef long long ll;
typedef pair<int, int> P;
typedef vector<P> vip;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a < c)
swap(a, c);
if (a < c && c < b) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define fol(i, n) for (int i = 0; i < n; i++)
#define pb push_back
typedef long long ll;
typedef pair<int, int> P;
typedef vector<P> vip;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a > b)
swap(a, b);
if (a < c && c < b) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| [
"identifier.change",
"call.arguments.change"
] | 878,062 | 878,061 | u171026188 | cpp |
p03067 | #include <algorithm>
#include <bitset>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <random>
#include <sstream>
#include <stack>
#include <string.h>
#include <string>
#include <type_traits>
#include <vector>
using namespace std;
#define ll long long int
#define all(v) begin(v), end(v)
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define reps(i, s, n) for (int i = (int)(s); i < (int)(n); i++)
// typedef vector<int> V;
// typedef vector<VV> VVV;
template <typename T> void remove(std::vector<T> &vector, unsigned int index) {
vector.erase(vector.begin() + index);
}
int main() {
int a, b, c;
cin >> a >> b >> c;
if ((a < c && c < b) || (a > c && c > b)) {
cout << "Yse" << endl;
} else {
cout << "No" << endl;
}
}
| #include <algorithm>
#include <bitset>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <random>
#include <sstream>
#include <stack>
#include <string.h>
#include <string>
#include <type_traits>
#include <vector>
using namespace std;
#define ll long long int
#define all(v) begin(v), end(v)
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define reps(i, s, n) for (int i = (int)(s); i < (int)(n); i++)
// typedef vector<int> V;
// typedef vector<VV> VVV;
template <typename T> void remove(std::vector<T> &vector, unsigned int index) {
vector.erase(vector.begin() + index);
}
int main() {
int a, b, c;
cin >> a >> b >> c;
if ((a < c && c < b) || (a > c && c > b)) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
| [
"literal.string.change",
"io.output.change"
] | 878,067 | 878,068 | u065923107 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.