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 |
|---|---|---|---|---|---|---|---|
p03077 | #include <iostream>
using namespace std;
int main() {
long long n;
cin >> n;
long long a;
cin >> a;
for (int i = 1; i < 5; i++) {
long long temp;
cin >> temp;
if (temp < a)
a = temp;
}
if (n < a)
cout << 5;
else {
long long time = n / a + 4;
if (n & a == 0)
cout << (time + 1);
else
cout << (time + 1);
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
long long n;
cin >> n;
long long a;
cin >> a;
for (int i = 1; i < 5; i++) {
long long temp;
cin >> temp;
if (temp < a)
a = temp;
}
if (n <= a)
cout << 5;
else {
long long time = n / a + 4;
if (n % a == 0)
cout << time;
else
cout << (time + 1);
}
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 893,472 | 893,471 | u606107557 | cpp |
p03077 | #include <iostream>
using namespace std;
int main() {
long long n;
cin >> n;
long long a;
cin >> a;
for (int i = 1; i < 5; i++) {
long long temp;
cin >> temp;
if (temp < a)
a = temp;
}
if (n < a)
cout << 5;
else {
long long time = n / a + 4;
if (n & a == 0)
cout << time;
else
cout << (time + 1);
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
long long n;
cin >> n;
long long a;
cin >> a;
for (int i = 1; i < 5; i++) {
long long temp;
cin >> temp;
if (temp < a)
a = temp;
}
if (n <= a)
cout << 5;
else {
long long time = n / a + 4;
if (n % a == 0)
cout << time;
else
cout << (time + 1);
}
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 893,473 | 893,471 | u606107557 | cpp |
p03077 | #include <bits/stdc++.h>
#define INF 1e9
using namespace std;
int main() {
long long N;
cin >> N;
vector<long long> t(5);
for (int i = 0; i < 5; ++i) {
cin >> t[i];
}
long long t_min = 0;
t_min = *min_element(t.begin(), t.end());
long long ans = 0;
if (N <= t_min) {
ans = 5;
} else {
if (N / t_min == 0) {
ans = N / t_min + 4;
} else {
ans = N / t_min + 5;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define INF 1e9
using namespace std;
int main() {
long long N;
cin >> N;
vector<long long> t(5);
for (int i = 0; i < 5; ++i) {
cin >> t[i];
}
long long t_min = 0;
t_min = *min_element(t.begin(), t.end());
long long ans = 0;
if (N <= t_min) {
ans = 5;
} else {
if (N % t_min == 0) {
ans = N / t_min + 4;
} else {
ans = N / t_min + 5;
}
}
cout << ans << endl;
} | [
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 893,476 | 893,477 | u701556979 | cpp |
p03077 | #include <bits/stdc++.h>
#define INF 1e9
using namespace std;
int main() {
long long N;
cin >> N;
vector<long long> t(5);
for (int i = 0; i < 5; ++i) {
cin >> t[i];
}
long long t_min = 0;
t_min = *min_element(t.begin(), t.end());
long long ans = 0;
if (N <= t_min) {
ans = 5;
} else {
if (N / t_min == 0) {
ans = N / t_min + 5;
} else {
ans = N / t_min + 4;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define INF 1e9
using namespace std;
int main() {
long long N;
cin >> N;
vector<long long> t(5);
for (int i = 0; i < 5; ++i) {
cin >> t[i];
}
long long t_min = 0;
t_min = *min_element(t.begin(), t.end());
long long ans = 0;
if (N <= t_min) {
ans = 5;
} else {
if (N % t_min == 0) {
ans = N / t_min + 4;
} else {
ans = N / t_min + 5;
}
}
cout << ans << endl;
} | [
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change",
"literal.number.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 893,479 | 893,477 | u701556979 | cpp |
p03077 | #include <iostream>
#include <vector>
using namespace std;
int main(void) {
unsigned long long N, min, tmp;
std::cin >> N >> min;
for (int i = 0; i < 4; i++) {
std::cin >> tmp;
if (tmp < min)
min = tmp;
}
if (N <= min) {
std::cout << 5 << std::endl;
return 0;
}
unsigned long long ans = N / min;
if (N / min != 0)
ans++;
std::cout << ans + 4 << std::endl;
return 0;
}
| #include <iostream>
#include <vector>
using namespace std;
int main(void) {
unsigned long long N, min, tmp;
std::cin >> N >> min;
for (int i = 0; i < 4; i++) {
std::cin >> tmp;
if (tmp < min)
min = tmp;
}
if (N <= min) {
std::cout << 5 << std::endl;
return 0;
}
unsigned long long ans = N / min;
if (N % min != 0)
ans++;
std::cout << ans + 4 << std::endl;
return 0;
}
| [
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 893,480 | 893,481 | u481487723 | cpp |
p03077 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <numeric>
#include <queue>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
typedef long int li;
bool compare_by_b(pair<int, int> a, pair<int, int> b) {
if (a.second != b.second) {
return a.second < b.second;
} else {
return a.first < b.first;
}
}
int main() {
ll ans = 0;
ll n, a[5];
cin >> n >> a[0] >> a[1] >> a[2] >> a[3] >> a[4];
ll ti = 12345;
for (int i = 0; i < 5; i++)
ti = min(a[i], ti);
ll x;
if (n % ti == 0)
x = n / ti + 1;
else
x = n / ti;
ans = 5 + x;
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <math.h>
#include <numeric>
#include <queue>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
typedef long int li;
bool compare_by_b(pair<int, int> a, pair<int, int> b) {
if (a.second != b.second) {
return a.second < b.second;
} else {
return a.first < b.first;
}
}
int main() {
ll ans = 0;
ll n, a[5];
cin >> n >> a[0] >> a[1] >> a[2] >> a[3] >> a[4];
ll ti = 1000000000000007;
for (int i = 0; i < 5; i++)
ti = min(a[i], ti);
ll x;
if (n % ti == 0)
x = n / ti - 1;
else
x = n / ti;
ans = 5 + x;
cout << ans << endl;
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 893,493 | 893,492 | u795009336 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
// Your code here!
long long int n;
long long int a[5];
cin >> n;
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
sort(a, a + 5);
if (n % a[0] == 10)
cout << 4 + n / a[0] << endl;
else
cout << 5 + n / a[0] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main(void) {
// Your code here!
long long int n;
long long int a[5];
cin >> n;
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
sort(a, a + 5);
if (n % a[0] == 0)
cout << 4 + n / a[0] << endl;
else
cout << 5 + n / a[0] << endl;
return 0;
}
| [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 893,494 | 893,495 | u098700286 | cpp |
p03077 | #include <bits/stdc++.h>
#include <sys/time.h>
using namespace std;
// hamko utils
#define rep(i, n) for (long long i = 0; i < static_cast<long long>(n); i++)
#define repi(i, a, b) \
for (long long i = static_cast<long long>(a); i < static_cast<long long>(b); \
i++)
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define fi first
#define se second
#define mt make_tuple
#define mp make_pair
template <class T1, class T2> bool chmin(T1 &a, T2 b) {
return b < a && (a = b, true);
}
template <class T1, class T2> bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vll>;
using P = pair<ll, ll>;
using ld = long double;
using vld = vector<ld>;
using vi = vector<int>;
using vvi = vector<vi>;
vll conv(vi &v) {
vll r(v.size());
rep(i, v.size()) r[i] = v[i];
return r;
}
inline void input(int &v) {
v = 0;
char c = 0;
int p = 1;
while (c < '0' || c > '9') {
if (c == '-')
p = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
v = (v << 3) + (v << 1) + c - '0';
c = getchar();
}
v *= p;
} // これを使うならば、tieとかを消して！！
template <typename T, typename U>
ostream &operator<<(ostream &o, const pair<T, U> &v) {
o << "(" << v.first << ", " << v.second << ")";
return o;
}
template <size_t...> struct seq {};
template <size_t N, size_t... Is>
struct gen_seq : gen_seq<N - 1, N - 1, Is...> {};
template <size_t... Is> struct gen_seq<0, Is...> : seq<Is...> {};
template <class Ch, class Tr, class Tuple, size_t... Is>
void print_tuple(basic_ostream<Ch, Tr> &os, Tuple const &t, seq<Is...>) {
using s = int[];
(void)s{0, (void(os << (Is == 0 ? "" : ", ") << get<Is>(t)), 0)...};
}
template <class Ch, class Tr, class... Args>
auto operator<<(basic_ostream<Ch, Tr> &os, tuple<Args...> const &t)
-> basic_ostream<Ch, Tr> & {
os << "(";
print_tuple(os, t, gen_seq<sizeof...(Args)>());
return os << ")";
}
ostream &operator<<(ostream &o, const vvll &v) {
rep(i, v.size()) {
rep(j, v[i].size()) o << v[i][j] << " ";
o << endl;
}
return o;
}
template <typename T> ostream &operator<<(ostream &o, const vector<T> &v) {
o << '[';
rep(i, v.size()) o << v[i] << (i != v.size() - 1 ? ", " : "");
o << "]";
return o;
}
template <typename T> ostream &operator<<(ostream &o, const deque<T> &v) {
o << '[';
rep(i, v.size()) o << v[i] << (i != v.size() - 1 ? ", " : "");
o << "]";
return o;
}
template <typename T> ostream &operator<<(ostream &o, const set<T> &m) {
o << '[';
for (auto it = m.begin(); it != m.end(); it++)
o << *it << (next(it) != m.end() ? ", " : "");
o << "]";
return o;
}
template <typename T>
ostream &operator<<(ostream &o, const unordered_set<T> &m) {
o << '[';
for (auto it = m.begin(); it != m.end(); it++)
o << *it << (next(it) != m.end() ? ", " : "");
o << "]";
return o;
}
template <typename T, typename U>
ostream &operator<<(ostream &o, const map<T, U> &m) {
o << '[';
for (auto it = m.begin(); it != m.end(); it++)
o << *it << (next(it) != m.end() ? ", " : "");
o << "]";
return o;
}
template <typename T, typename U, typename V>
ostream &operator<<(ostream &o, const unordered_map<T, U, V> &m) {
o << '[';
for (auto it = m.begin(); it != m.end(); it++)
o << *it;
o << "]";
return o;
}
vector<int> range(const int x, const int y) {
vector<int> v(y - x + 1);
iota(v.begin(), v.end(), x);
return v;
}
template <typename T> istream &operator>>(istream &i, vector<T> &o) {
rep(j, o.size()) i >> o[j];
return i;
}
template <typename T, typename S, typename U>
ostream &operator<<(ostream &o, const priority_queue<T, S, U> &v) {
auto tmp = v;
while (tmp.size()) {
auto x = tmp.top();
tmp.pop();
o << x << " ";
}
return o;
}
template <typename T> ostream &operator<<(ostream &o, const queue<T> &v) {
auto tmp = v;
while (tmp.size()) {
auto x = tmp.front();
tmp.pop();
o << x << " ";
}
return o;
}
template <typename T> ostream &operator<<(ostream &o, const stack<T> &v) {
auto tmp = v;
while (tmp.size()) {
auto x = tmp.top();
tmp.pop();
o << x << " ";
}
return o;
}
template <typename T> unordered_map<T, ll> counter(vector<T> vec) {
unordered_map<T, ll> ret;
for (auto &&x : vec)
ret[x]++;
return ret;
};
string substr(string s, P x) { return s.substr(x.fi, x.se - x.fi); }
void vizGraph(vvll &g, int mode = 0, string filename = "out.png") {
ofstream ofs("./out.dot");
ofs << "digraph graph_name {" << endl;
set<P> memo;
rep(i, g.size()) rep(j, g[i].size()) {
if (mode && (memo.count(P(i, g[i][j])) || memo.count(P(g[i][j], i))))
continue;
memo.insert(P(i, g[i][j]));
ofs << " " << i << " -> " << g[i][j]
<< (mode ? " [arrowhead = none]" : "") << endl;
}
ofs << "}" << endl;
ofs.close();
system((string("dot -T png out.dot >") + filename).c_str());
}
class ScopedTime {
public:
ScopedTime(const std::string &msg = "") : msg_(msg) {
start_ = std::chrono::system_clock::now();
}
void lap(const std::string &msg) {
const auto duration_time = std::chrono::system_clock::now() - start_;
const auto duration_ms =
std::chrono::duration_cast<std::chrono::milliseconds>(duration_time);
std::cerr << "[" << duration_ms.count() << " ms] " << msg << std::endl;
}
virtual ~ScopedTime() { this->lap(msg_); }
private:
std::chrono::system_clock::time_point start_;
std::string msg_;
};
size_t g_random_seed;
struct init_ {
init_() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
srand(static_cast<unsigned int>(time(NULL)));
g_random_seed = RAND_MAX / 2 + rand() / 2;
}
} init__;
namespace std {
using argument_type = P;
template <> struct hash<argument_type> {
size_t operator()(argument_type const &x) const {
size_t seed = g_random_seed;
seed ^= hash<ll>{}(x.fi);
seed ^= (hash<ll>{}(x.se) << 1);
return seed;
}
};
}; // namespace std
#define ldout fixed << setprecision(40)
#define EPS (double)1e-14
#define INF (ll)1e18
#define mo (ll)(1e9 + 7)
// end of hamko utils
template <typename T, typename X> auto vectors(T a, X x) {
return vector<T>(x, a);
}
template <typename T, typename X, typename Y, typename... Zs>
auto vectors(T a, X x, Y y, Zs... zs) {
auto cont = vectors(a, y, zs...);
return vector<decltype(cont)>(x, cont);
}
// usage: vector<vector<vector<double> > > dp = vectors(double(), 10, 20, 30);
ll N;
std::vector<ll> ts;
int main(void) {
cin >> N;
ts.resize(5);
for (int i = 0; i < ts.size(); i++) {
cin >> ts[i];
}
auto min = std::min_element(begin(ts), end(ts));
if (*min >= N) {
std::cout << 5 << std::endl;
} else {
std::cout << fixed << (ll)(std::floor(N * 1.0 / (*min)) + 5) << std::endl;
}
return 0;
}
| #include <bits/stdc++.h>
#include <sys/time.h>
using namespace std;
// hamko utils
#define rep(i, n) for (long long i = 0; i < static_cast<long long>(n); i++)
#define repi(i, a, b) \
for (long long i = static_cast<long long>(a); i < static_cast<long long>(b); \
i++)
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define fi first
#define se second
#define mt make_tuple
#define mp make_pair
template <class T1, class T2> bool chmin(T1 &a, T2 b) {
return b < a && (a = b, true);
}
template <class T1, class T2> bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vll>;
using P = pair<ll, ll>;
using ld = long double;
using vld = vector<ld>;
using vi = vector<int>;
using vvi = vector<vi>;
vll conv(vi &v) {
vll r(v.size());
rep(i, v.size()) r[i] = v[i];
return r;
}
inline void input(int &v) {
v = 0;
char c = 0;
int p = 1;
while (c < '0' || c > '9') {
if (c == '-')
p = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
v = (v << 3) + (v << 1) + c - '0';
c = getchar();
}
v *= p;
} // これを使うならば、tieとかを消して！！
template <typename T, typename U>
ostream &operator<<(ostream &o, const pair<T, U> &v) {
o << "(" << v.first << ", " << v.second << ")";
return o;
}
template <size_t...> struct seq {};
template <size_t N, size_t... Is>
struct gen_seq : gen_seq<N - 1, N - 1, Is...> {};
template <size_t... Is> struct gen_seq<0, Is...> : seq<Is...> {};
template <class Ch, class Tr, class Tuple, size_t... Is>
void print_tuple(basic_ostream<Ch, Tr> &os, Tuple const &t, seq<Is...>) {
using s = int[];
(void)s{0, (void(os << (Is == 0 ? "" : ", ") << get<Is>(t)), 0)...};
}
template <class Ch, class Tr, class... Args>
auto operator<<(basic_ostream<Ch, Tr> &os, tuple<Args...> const &t)
-> basic_ostream<Ch, Tr> & {
os << "(";
print_tuple(os, t, gen_seq<sizeof...(Args)>());
return os << ")";
}
ostream &operator<<(ostream &o, const vvll &v) {
rep(i, v.size()) {
rep(j, v[i].size()) o << v[i][j] << " ";
o << endl;
}
return o;
}
template <typename T> ostream &operator<<(ostream &o, const vector<T> &v) {
o << '[';
rep(i, v.size()) o << v[i] << (i != v.size() - 1 ? ", " : "");
o << "]";
return o;
}
template <typename T> ostream &operator<<(ostream &o, const deque<T> &v) {
o << '[';
rep(i, v.size()) o << v[i] << (i != v.size() - 1 ? ", " : "");
o << "]";
return o;
}
template <typename T> ostream &operator<<(ostream &o, const set<T> &m) {
o << '[';
for (auto it = m.begin(); it != m.end(); it++)
o << *it << (next(it) != m.end() ? ", " : "");
o << "]";
return o;
}
template <typename T>
ostream &operator<<(ostream &o, const unordered_set<T> &m) {
o << '[';
for (auto it = m.begin(); it != m.end(); it++)
o << *it << (next(it) != m.end() ? ", " : "");
o << "]";
return o;
}
template <typename T, typename U>
ostream &operator<<(ostream &o, const map<T, U> &m) {
o << '[';
for (auto it = m.begin(); it != m.end(); it++)
o << *it << (next(it) != m.end() ? ", " : "");
o << "]";
return o;
}
template <typename T, typename U, typename V>
ostream &operator<<(ostream &o, const unordered_map<T, U, V> &m) {
o << '[';
for (auto it = m.begin(); it != m.end(); it++)
o << *it;
o << "]";
return o;
}
vector<int> range(const int x, const int y) {
vector<int> v(y - x + 1);
iota(v.begin(), v.end(), x);
return v;
}
template <typename T> istream &operator>>(istream &i, vector<T> &o) {
rep(j, o.size()) i >> o[j];
return i;
}
template <typename T, typename S, typename U>
ostream &operator<<(ostream &o, const priority_queue<T, S, U> &v) {
auto tmp = v;
while (tmp.size()) {
auto x = tmp.top();
tmp.pop();
o << x << " ";
}
return o;
}
template <typename T> ostream &operator<<(ostream &o, const queue<T> &v) {
auto tmp = v;
while (tmp.size()) {
auto x = tmp.front();
tmp.pop();
o << x << " ";
}
return o;
}
template <typename T> ostream &operator<<(ostream &o, const stack<T> &v) {
auto tmp = v;
while (tmp.size()) {
auto x = tmp.top();
tmp.pop();
o << x << " ";
}
return o;
}
template <typename T> unordered_map<T, ll> counter(vector<T> vec) {
unordered_map<T, ll> ret;
for (auto &&x : vec)
ret[x]++;
return ret;
};
string substr(string s, P x) { return s.substr(x.fi, x.se - x.fi); }
void vizGraph(vvll &g, int mode = 0, string filename = "out.png") {
ofstream ofs("./out.dot");
ofs << "digraph graph_name {" << endl;
set<P> memo;
rep(i, g.size()) rep(j, g[i].size()) {
if (mode && (memo.count(P(i, g[i][j])) || memo.count(P(g[i][j], i))))
continue;
memo.insert(P(i, g[i][j]));
ofs << " " << i << " -> " << g[i][j]
<< (mode ? " [arrowhead = none]" : "") << endl;
}
ofs << "}" << endl;
ofs.close();
system((string("dot -T png out.dot >") + filename).c_str());
}
class ScopedTime {
public:
ScopedTime(const std::string &msg = "") : msg_(msg) {
start_ = std::chrono::system_clock::now();
}
void lap(const std::string &msg) {
const auto duration_time = std::chrono::system_clock::now() - start_;
const auto duration_ms =
std::chrono::duration_cast<std::chrono::milliseconds>(duration_time);
std::cerr << "[" << duration_ms.count() << " ms] " << msg << std::endl;
}
virtual ~ScopedTime() { this->lap(msg_); }
private:
std::chrono::system_clock::time_point start_;
std::string msg_;
};
size_t g_random_seed;
struct init_ {
init_() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
srand(static_cast<unsigned int>(time(NULL)));
g_random_seed = RAND_MAX / 2 + rand() / 2;
}
} init__;
namespace std {
using argument_type = P;
template <> struct hash<argument_type> {
size_t operator()(argument_type const &x) const {
size_t seed = g_random_seed;
seed ^= hash<ll>{}(x.fi);
seed ^= (hash<ll>{}(x.se) << 1);
return seed;
}
};
}; // namespace std
#define ldout fixed << setprecision(40)
#define EPS (double)1e-14
#define INF (ll)1e18
#define mo (ll)(1e9 + 7)
// end of hamko utils
template <typename T, typename X> auto vectors(T a, X x) {
return vector<T>(x, a);
}
template <typename T, typename X, typename Y, typename... Zs>
auto vectors(T a, X x, Y y, Zs... zs) {
auto cont = vectors(a, y, zs...);
return vector<decltype(cont)>(x, cont);
}
// usage: vector<vector<vector<double> > > dp = vectors(double(), 10, 20, 30);
ll N;
std::vector<ll> ts;
int main(void) {
cin >> N;
ts.resize(5);
for (int i = 0; i < ts.size(); i++) {
cin >> ts[i];
}
auto min = std::min_element(begin(ts), end(ts));
if (*min >= N) {
std::cout << 5 << std::endl;
} else {
// std::cout << fixed << (ll)((std::floor(N*1.0/(*min)) + 5) -
// (N%(*min)==0?1:0))<< std::endl;
std::cout << fixed << (ll)((std::ceil(N * 1.0 / (*min)) + 4)) << std::endl;
}
return 0;
}
| [
"call.arguments.change",
"misc.opposites",
"identifier.change",
"expression.operation.binary.change",
"literal.number.change"
] | 893,502 | 893,503 | u897282055 | cpp |
p03077 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
int main() {
ll N;
cin >> N;
ll min_value = 10000000000000000;
for (int i = 0; i < 5; i++) {
ll value;
cin >> value;
if (min_value > value) {
min_value = value;
}
}
cout << 5 + N / min_value << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
int main() {
ll N;
cin >> N;
ll min_value = 10000000000000000;
for (int i = 0; i < 5; i++) {
ll value;
cin >> value;
if (min_value > value) {
min_value = value;
}
}
cout << 5 + (N - 1) / min_value << endl;
return 0;
} | [] | 893,506 | 893,507 | u389009751 | cpp |
p03077 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
int main() {
ll N;
cin >> N;
ll min_value = 1000000000000001;
for (int i = 0; i < 5; i++) {
ll value;
cin >> value;
if (min_value > value) {
min_value = value;
}
}
cout << 5 + N / min_value << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
int main() {
ll N;
cin >> N;
ll min_value = 10000000000000000;
for (int i = 0; i < 5; i++) {
ll value;
cin >> value;
if (min_value > value) {
min_value = value;
}
}
cout << 5 + (N - 1) / min_value << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 893,508 | 893,507 | u389009751 | cpp |
p03077 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
vector<long long int> A(5);
long long int N;
cin >> N;
for (int i = 0; i < 5; i++) {
cin >> A[i];
}
sort(A.begin(), A.end());
if (A[0] % N == 0) {
cout << 5 + (N / A[0]) - 1 << endl;
} else {
cout << 5 + (N / A[0]) << endl;
}
return 0;
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
vector<long long int> A(5);
long long int N;
cin >> N;
for (int i = 0; i < 5; i++) {
cin >> A[i];
}
sort(A.begin(), A.end());
if (N % A[0] == 0) {
cout << 5 + (N / A[0]) - 1 << endl;
} else {
cout << 5 + (N / A[0]) << endl;
}
return 0;
}
| [
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 893,521 | 893,522 | u684056175 | cpp |
p03077 | #include <algorithm>
#include <iostream>
#include <string.h>
#include <vector>
#define INF 100000000
using namespace std;
int main(void) {
long N;
long trans1[5], trans2[5];
cin >> N;
for (int i = 0; i < 5; i++) {
cin >> trans1[i];
if (N % trans1[i] != 0) {
trans2[i] = N / trans1[i] + 1;
} else
trans2[i] = N / trans1[i];
}
sort(trans2, trans2 + N);
cout << trans2[0] + 4;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <string.h>
#include <vector>
#define INF 100000000
using namespace std;
int main(void) {
long N;
long trans1[5], trans2[5];
cin >> N;
for (int i = 0; i < 5; i++) {
cin >> trans1[i];
if (N % trans1[i] != 0) {
trans2[i] = N / trans1[i] + 1;
} else
trans2[i] = N / trans1[i];
}
sort(trans2, trans2 + 5);
cout << trans2[4] + 4;
return 0;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change",
"expression.operation.binary.change",
"literal.number.change",
"variable_access.subscript.index.change",
"io.output.change"
] | 893,523 | 893,524 | u238235808 | cpp |
p03077 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
long long n, x;
cin >> n;
long long mini = 1e16;
for (int i = 0; i < 5; i++) {
cin >> x;
mini = min(mini, x);
}
long long ans = (n + mini) / mini + 4;
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
long long n, x;
cin >> n;
long long mini = 1e16;
for (int i = 0; i < 5; i++) {
cin >> x;
mini = min(mini, x);
}
long long ans = (n + mini - 1) / mini + 4;
cout << ans << endl;
return 0;
}
| [
"assignment.change"
] | 893,536 | 893,537 | u590241855 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
ll min(ll a, ll b) {
if (a < b)
return a;
else
return b;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin >> n;
vector<ll> a(5);
REP(i, 5) { cin >> a[i]; }
ll m = a[0];
REP(i, 5) { m = min(a[i], m); }
if (m == n) {
cout << m << endl;
} else {
ll ans = n / m;
cout << 5 + ans << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
ll min(ll a, ll b) {
if (a < b)
return a;
else
return b;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin >> n;
vector<ll> a(5);
REP(i, 5) { cin >> a[i]; }
ll m = a[0];
REP(i, 5) { m = min(a[i], m); }
if (m == n) {
cout << 5 << endl;
} else {
ll ans = (n - 1) / m;
cout << 5 + ans << endl;
}
}
| [
"identifier.replace.remove",
"literal.replace.add",
"io.output.change"
] | 893,542 | 893,543 | u608499300 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
ll min(ll a, ll b) {
if (a < b)
return a;
else
return b;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin >> n;
vector<ll> a(5);
REP(i, 5) { cin >> a[i]; }
ll m = a[0];
REP(i, 5) { m = min(a[i], m); }
if (m == n) {
cout << 5 << endl;
} else {
ll ans = n / m;
cout << 5 + ans << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
ll min(ll a, ll b) {
if (a < b)
return a;
else
return b;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin >> n;
vector<ll> a(5);
REP(i, 5) { cin >> a[i]; }
ll m = a[0];
REP(i, 5) { m = min(a[i], m); }
if (m == n) {
cout << 5 << endl;
} else {
ll ans = (n - 1) / m;
cout << 5 + ans << endl;
}
}
| [] | 893,544 | 893,543 | u608499300 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, ans, tmp;
cin >> n;
vector<long long int> peo;
for (int i = 0; i < 5; i++) {
cin >> tmp;
peo.push_back(tmp);
}
sort(peo.begin(), peo.end());
long long int x = peo[0];
ans = n / x;
cout << ans + 5 << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, ans, tmp;
cin >> n;
vector<long long int> peo;
for (int i = 0; i < 5; i++) {
cin >> tmp;
peo.push_back(tmp);
}
sort(peo.begin(), peo.end());
long long int x = peo[0];
ans = (n - 1) / x;
cout << ans + 5 << endl;
} | [] | 893,547 | 893,548 | u148968106 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long int ull;
int main() {
ull N, array[5];
cin >> N;
for (int i = 0; i < 5; ++i) {
cin >> array[i];
}
sort(array, array + 5);
cout << N / array[0] + 5 << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long int ull;
int main() {
ull N, array[5];
cin >> N;
for (int i = 0; i < 5; ++i) {
cin >> array[i];
}
sort(array, array + 5);
cout << (N - 1) / array[0] + 5 << endl;
} | [] | 893,551 | 893,552 | u593081125 | cpp |
p03077 | #include <iostream>
using namespace std;
int main() {
long long int N, A[5];
cin >> N >> A[0] >> A[1] >> A[2] >> A[3] >> A[4];
long long int step = 0;
long long int Ncity[6] = {0};
long long int mincap = 10000000000000000;
int mincapindex = 0;
for (int i = 0; i < 5; i++) {
if (A[i] < mincap)
mincap = A[i];
}
int distance = 0;
step += 5;
step += N / mincap;
if (N % mincap != 0)
step += 1;
cout << step;
return 0;
} | #include <iostream>
using namespace std;
int main() {
long long int N, A[5];
cin >> N >> A[0] >> A[1] >> A[2] >> A[3] >> A[4];
long long int step = 0;
long long int Ncity[6] = {0};
long long int mincap = 10000000000000000;
int mincapindex = 0;
for (int i = 0; i < 5; i++) {
if (A[i] < mincap)
mincap = A[i];
}
int distance = 0;
step += 4;
step += N / mincap;
if (N % mincap != 0)
step += 1;
cout << step;
return 0;
} | [
"literal.number.change",
"assignment.value.change"
] | 893,559 | 893,560 | u412038365 | cpp |
p03077 | #include <cmath>
#include <iostream>
using namespace std;
int main() {
long N, A, B, C, D, E;
cin >> N >> A >> B >> C >> D >> E;
long min_ = min(A, min(B, min(C, min(D, E))));
long ans;
if (min_ > N)
ans = 5;
else {
double tmp = ((double)N / min_);
ans = (long)round(tmp) - 1 + 5;
}
cout << ans << endl;
return 0;
} | #include <cmath>
#include <iostream>
using namespace std;
int main() {
long N, A, B, C, D, E;
cin >> N >> A >> B >> C >> D >> E;
long min_ = min(A, min(B, min(C, min(D, E))));
long ans;
if (min_ > N)
ans = 5;
else {
double tmp = ((double)N / min_) + 0.9;
ans = (long)(tmp)-1 + 5;
}
cout << ans << endl;
return 0;
} | [
"assignment.change"
] | 893,583 | 893,584 | u262733088 | cpp |
p03077 | #include <bits/stdc++.h>
#include <cmath>
using namespace std;
int main() {
long long int n, a, b, c, d, e, mi;
long long int dure = 5;
cin >> n >> a >> b >> c >> d >> e;
mi = min(a, b);
mi = min(c, mi);
mi = min(d, mi);
mi = min(e, mi);
dure += n / mi;
cout << dure << endl;
} | #include <bits/stdc++.h>
#include <cmath>
using namespace std;
int main() {
long long int n, a, b, c, d, e, mi;
long long int dure = 5;
cin >> n >> a >> b >> c >> d >> e;
mi = min(a, b);
mi = min(c, mi);
mi = min(d, mi);
mi = min(e, mi);
dure += (n - 1) / mi;
cout << dure << endl;
} | [] | 893,589 | 893,590 | u672995180 | cpp |
p03077 | #include <iostream>
using namespace std;
int main() {
int N;
int city[5];
int min = 0;
cin >> N;
for (int i = 0; i < 5; i++) {
cin >> city[i];
if (i == 0 || min > city[i]) {
min = city[i];
}
}
int ans;
if (N % min == 0) {
ans = N / min + 4;
} else {
ans = N / min + 5;
}
printf("%d\n", ans);
}
| #include <iostream>
using namespace std;
int main() {
long int N;
long int city[5];
long int min = 0;
cin >> N;
for (int i = 0; i < 5; i++) {
cin >> city[i];
if (i == 0 || min > city[i]) {
min = city[i];
}
}
long int ans;
if (N % min == 0) {
ans = N / min + 4;
} else {
ans = N / min + 5;
}
printf("%ld\n", ans);
}
| [
"variable_declaration.type.widen.change",
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 893,591 | 893,592 | u366677622 | cpp |
p03077 | #include <iostream>
using namespace std;
int main() {
int N;
int T[5];
cin >> N >> T[0] >> T[1] >> T[2] >> T[3] >> T[4];
int i;
int min = T[0];
for (i = 1; i <= 4; i++)
if (min > T[i])
min = T[i];
int t;
if (N % min == 0)
t = N / min;
else
t = N / min + 1;
cout << t + 4 << endl;
}
| #include <iostream>
using namespace std;
int main() {
long int N;
long int T[5];
cin >> N >> T[0] >> T[1] >> T[2] >> T[3] >> T[4];
int i;
long int min = T[0];
for (i = 1; i <= 4; i++)
if (min > T[i])
min = T[i];
long int t;
if (N % min == 0)
t = N / min;
else
t = N / min + 1;
cout << t + 4 << endl;
}
| [
"variable_declaration.type.widen.change"
] | 893,593 | 893,594 | u362444129 | cpp |
p03077 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
long long int ans, a, b, c, d, e, n;
ans = 0;
cin >> n >> a >> b >> c >> d >> e;
ans = (n + min({a, b, c, d, e})) / min({a, b, c, d, e}) + 4;
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
long long int ans, a, b, c, d, e, n;
ans = 0;
cin >> n >> a >> b >> c >> d >> e;
ans = (n + min({a, b, c, d, e}) - 1) / min({a, b, c, d, e}) + 4;
cout << ans << endl;
return 0;
} | [
"assignment.change"
] | 893,595 | 893,596 | u173648629 | cpp |
p03077 | // Shift-JIS（シフトジス）
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N, A, B, C, D, E;
cin >> N >> A >> B >> C >> D >> E;
long long c[] = {A, B, C, D, E};
long long x;
x = A;
long long ans;
for (int i = 0; i < 5; i++) {
x = min(x, c[i]);
}
if (N % x == 0) {
ans = N / x + 6;
} else {
ans = N / x + 5;
}
cout << ans << endl;
} | // Shift-JIS（シフトジス）
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N, A, B, C, D, E;
cin >> N >> A >> B >> C >> D >> E;
long long c[] = {A, B, C, D, E};
long long x;
x = A;
long long ans;
for (int i = 0; i < 5; i++) {
x = min(x, c[i]);
}
if (N % x == 0) {
ans = N / x + 4;
} else {
ans = N / x + 5;
}
cout << ans << endl;
} | [
"literal.number.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 893,597 | 893,598 | u380317210 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define per(i, a, b) for (int i = a; i >= b; i--)
#define clr(a, x) memset(a, x, sizeof(a))
#define SZ(x) ((int)(x).size())
#define lson rt << 1
#define rson rt << 1 | 1
#define pb push_back
#define fi first
#define se second
#define what_is(x) cerr << #x << " " << x << endl;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
template <typename T> inline void _read(T &x) { cin >> x; }
void R() {}
template <typename T, typename... U> void R(T &head, U &...tail) {
_read(head);
R(tail...);
}
template <typename T> inline void _write(const T &x) { cout << x << ' '; }
void W() { cout << endl; }
template <typename T, typename... U> void W(const T &head, const U &...tail) {
_write(head);
W(tail...);
}
void go();
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
go();
return 0;
}
/****************ackun*********************/
void go() {
int n;
R(n);
ll mi = 1e16;
rep(i, 1, 5) {
ll x;
R(x);
mi = min(mi, x);
}
ll ans = 5;
n -= mi;
if (n > 0) {
ans += n / mi;
if ((n % mi) != 0) {
ans++;
}
}
W(ans);
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define per(i, a, b) for (int i = a; i >= b; i--)
#define clr(a, x) memset(a, x, sizeof(a))
#define SZ(x) ((int)(x).size())
#define lson rt << 1
#define rson rt << 1 | 1
#define pb push_back
#define fi first
#define se second
#define what_is(x) cerr << #x << " " << x << endl;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
template <typename T> inline void _read(T &x) { cin >> x; }
void R() {}
template <typename T, typename... U> void R(T &head, U &...tail) {
_read(head);
R(tail...);
}
template <typename T> inline void _write(const T &x) { cout << x << ' '; }
void W() { cout << endl; }
template <typename T, typename... U> void W(const T &head, const U &...tail) {
_write(head);
W(tail...);
}
void go();
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
go();
return 0;
}
/****************ackun*********************/
void go() {
ll n;
R(n);
ll mi = 1e16;
rep(i, 1, 5) {
ll x;
R(x);
mi = min(mi, x);
}
ll ans = 5;
n -= mi;
if (n > 0) {
ans += n / mi;
if ((n % mi) != 0) {
ans++;
}
}
W(ans);
}
| [
"variable_declaration.type.change"
] | 893,599 | 893,600 | u749563575 | cpp |
p03077 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
int n, a, b, c, d, e;
int minutes = 4;
int main() {
std::cin >> n >> a >> b >> c >> d >> e;
int x = std::min({a, b, c, d, e});
minutes += std::ceil(((double)n) / x);
std::cout << minutes << std::endl;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
long n, a, b, c, d, e;
long long minutes = 4;
int main() {
std::cin >> n >> a >> b >> c >> d >> e;
long long x = std::min({a, b, c, d, e});
minutes += std::ceil(((double)n) / x);
std::cout << minutes << std::endl;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 893,603 | 893,602 | u537538698 | cpp |
p03077 | #include <array>
#include <iostream>
int main() {
std::array<unsigned long long, 5> Five;
unsigned long long N;
std::cin >> N;
for (auto &f : Five)
std::cin >> f;
unsigned long long bn = Five[0];
for (int i = 1; i < 5; i++) {
if (Five[i] < bn)
bn = Five[i];
}
int ans = (N + bn - 1) / bn + 5;
std::cout << ans << std::endl;
return 0;
}
| #include <array>
#include <iostream>
int main() {
std::array<unsigned long long, 5> Five;
unsigned long long N;
std::cin >> N;
for (auto &f : Five)
std::cin >> f;
unsigned long long bn = Five[0];
for (int i = 1; i < 5; i++) {
if (Five[i] < bn)
bn = Five[i];
}
unsigned long long ans = (N + bn - 1) / bn + 4;
std::cout << ans << std::endl;
return 0;
}
/*
10000000007
2
3
5
7
11
*/ | [
"variable_declaration.type.primitive.change",
"literal.number.change",
"expression.operation.binary.change"
] | 893,610 | 893,611 | u896932701 | cpp |
p03077 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
long long N;
cin >> N;
long long s[5];
for (int i = 0; i < 5; i++) {
cin >> s[i];
}
long long mini = s[0];
for (int i = 0; i < 5; i++) {
mini = min(s[i], mini);
}
int ans = 5;
if (N > mini) {
if (N % mini == 0) {
ans += N / mini - 1;
} else {
ans += N / mini;
}
}
cout << ans << endl;
}
| #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
long long N;
cin >> N;
long long s[5];
for (int i = 0; i < 5; i++) {
cin >> s[i];
}
long long mini = s[0];
for (int i = 0; i < 5; i++) {
mini = min(s[i], mini);
}
long long ans = 5;
if (N > mini) {
if (N % mini == 0) {
ans += N / mini - 1;
} else {
ans += N / mini;
}
}
cout << ans << endl;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 893,624 | 893,625 | u791220701 | cpp |
p03077 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <stdio.h>
#include <string>
#include <typeinfo>
#include <vector>
using namespace std;
int main() {
//最悪のケースからかかる時間を予測する
long long N; // 32bit seisu
std::cin >> N;
std::vector<long long> trafic_cap(5);
for (int i = 0; i < 5; ++i) {
std::cin >> trafic_cap[i];
if (i == 0) {
if (trafic_cap[i] > N)
trafic_cap[i] = N;
continue;
}
if (trafic_cap[i] > trafic_cap[i - 1])
trafic_cap[i] = trafic_cap[i - 1];
// std::cout << i << "pppp" << trafic_cap[i] << "\n";
}
// std::cout << N/2 + N%2 + 4<< "\n";
// std::cout << 3%3 << "\n";
long long time = N / trafic_cap[4] + N % trafic_cap[4] + 4;
std::cout << time << "\n";
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <stdio.h>
#include <string>
#include <typeinfo>
#include <vector>
using namespace std;
int main() {
//最悪のケースからかかる時間を予測する
long long N; // 32bit seisu
std::cin >> N;
std::vector<long long> trafic_cap(5);
for (int i = 0; i < 5; ++i) {
std::cin >> trafic_cap[i];
if (i == 0) {
if (trafic_cap[i] > N)
trafic_cap[i] = N;
continue;
}
if (trafic_cap[i] > trafic_cap[i - 1])
trafic_cap[i] = trafic_cap[i - 1];
// std::cout << i << "pppp" << trafic_cap[i] << "\n";
}
// std::cout << N/2 + N%2 + 4<< "\n";
// std::cout << 3%3 << "\n";
long long time = (N + trafic_cap[4] - 1) / trafic_cap[4] + 4;
std::cout << time << "\n";
} | [
"expression.operator.arithmetic.change",
"expression.operation.binary.change"
] | 893,626 | 893,627 | u395248672 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b, c, d, e;
cin >> n >> a >> b >> c >> d >> e;
long long m = min(min(min(min(a, b), c), d), e);
long long ans = (n - m + 1) / m + 4;
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b, c, d, e;
cin >> n >> a >> b >> c >> d >> e;
long long m = min(min(min(min(a, b), c), d), e);
long long ans = (n + m - 1) / m + 4;
cout << ans << endl;
} | [
"expression.operation.binary.remove"
] | 893,634 | 893,635 | u655975843 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b, c, d, e;
cin >> n >> a >> b >> c >> d >> e;
long long m = min(min(min(min(a, b), c), d), e);
long long ans = (n - m + 1) / m + 5;
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b, c, d, e;
cin >> n >> a >> b >> c >> d >> e;
long long m = min(min(min(min(a, b), c), d), e);
long long ans = (n + m - 1) / m + 4;
cout << ans << endl;
} | [
"expression.operation.binary.remove",
"literal.number.change",
"expression.operation.binary.change"
] | 893,636 | 893,635 | u655975843 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define F(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define FI(i, a, b) for (int i = (int)(a); i <= (int)(b); i++)
#define RF(i, a, b) for (int i = (int)(a); i >= (int)(b); i--)
#define what_is(x) cerr << #x << " is " << x << endl;
#define ms(x, a) memset(x, (int)(a), sizeof(x))
#define all(x) (x).begin(), (x).end()
#define sz(x) ((int)(x).size())
#define pii pair<int, int>
#define vi vector<int>
#define pb push_back
#define endl '\n'
#define mp make_pair
#define ff first
#define ss second
#define MOD 1000000007
const int N = 1e6 + 7;
string s;
int main() {
fast;
int n, k;
vector<int> a(5);
cin >> n;
F(i, 0, 5)
cin >> a[i];
int mx = -1;
F(i, 0, 5) {
int x = ceil((n - 1) / a[i]);
mx = max(mx, x);
}
cout << mx + 5 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define ld long double
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define F(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define FI(i, a, b) for (int i = (int)(a); i <= (int)(b); i++)
#define RF(i, a, b) for (int i = (int)(a); i >= (int)(b); i--)
#define what_is(x) cerr << #x << " is " << x << endl;
#define ms(x, a) memset(x, (int)(a), sizeof(x))
#define all(x) (x).begin(), (x).end()
#define sz(x) ((int)(x).size())
#define pii pair<int, int>
#define vi vector<int>
#define pb push_back
#define endl '\n'
#define mp make_pair
#define ff first
#define ss second
#define MOD 1000000007
const int N = 1e6 + 7;
string s;
int32_t main() {
fast;
int n, k;
vector<int> a(5);
cin >> n;
F(i, 0, 5)
cin >> a[i];
int mx = -1;
F(i, 0, 5) {
int x = ceil((n - 1) / a[i]);
mx = max(mx, x);
}
cout << mx + 5 << endl;
}
| [
"identifier.change",
"function.return_type.change"
] | 893,637 | 893,638 | u144432905 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, d, e;
cin >> n >> a >> b >> c >> d >> e;
int k = min({a, b, c, d, e});
cout << (n / k) + ((n % k) != 0) + 4 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b, c, d, e;
cin >> n >> a >> b >> c >> d >> e;
long long k = min({a, b, c, d, e});
cout << (n / k) + (n % k != 0) + 4 << endl;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 893,646 | 893,647 | u704064492 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, d, e;
cin >> n >> a >> b >> c >> d >> e;
int k = min({a, b, c, d, e});
cout << (n / k) + (n % k != 0) + 4 << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b, c, d, e;
cin >> n >> a >> b >> c >> d >> e;
long long k = min({a, b, c, d, e});
cout << (n / k) + (n % k != 0) + 4 << endl;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 893,648 | 893,647 | u704064492 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, d, e;
cin >> n >> a >> b >> c >> d >> e;
int k = min({a, b, c, d, e});
cout << (n / k) + ((n % k) != 0 ? 1 : 0) + 4 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b, c, d, e;
cin >> n >> a >> b >> c >> d >> e;
long long k = min({a, b, c, d, e});
cout << (n / k) + ((n % k) != 0 ? 1 : 0) + 4 << endl;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 893,649 | 893,650 | u704064492 | cpp |
p03077 | #include <algorithm>
#include <cstdio>
using namespace std;
int main() {
long n, a, b, c, d, e;
scanf("%ld\n%ld\n%ld\n%ld\n%ld\n%ld", &n, &a, &b, &c, &d, &e);
long slow = min({a, b, c, d, e});
printf("%ld\n", 5 + n / slow);
return 0;
} | #include <algorithm>
#include <cstdio>
using namespace std;
int main() {
long n, a, b, c, d, e;
scanf("%ld\n%ld\n%ld\n%ld\n%ld\n%ld", &n, &a, &b, &c, &d, &e);
long slow = min({a, b, c, d, e});
printf("%ld\n", 5 + (n - 1) / slow);
return 0;
} | [
"call.arguments.change"
] | 893,653 | 893,654 | u956758464 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int main() {
ll n, a, b, c, d, e;
scanf("%lld%lld%lld%lld%lld%lld", &n, &a, &b, &c, &d, &e);
ll minN = min({a, b, c, d, e});
cout << 5 + n / minN << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int main() {
ll n, a, b, c, d, e;
scanf("%lld%lld%lld%lld%lld%lld", &n, &a, &b, &c, &d, &e);
ll minN = min({a, b, c, d, e});
cout << 5 + (n - 1) / minN << endl; //((n-minN)+minN-1)/minN
} | [] | 893,655 | 893,656 | u874723578 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int main() {
ll n, a, b, c, d, e;
scanf("%lld%lld%lld%lld%lld%lld", &n, &a, &b, &c, &d, &e);
ll minN = min({a, b, c, d, e});
cout << 5 + n / minN << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int main() {
ll n, a, b, c, d, e;
scanf("%lld%lld%lld%lld%lld%lld", &n, &a, &b, &c, &d, &e);
ll minN = min({a, b, c, d, e});
cout << 5 + (n - 1) / minN << endl;
} | [] | 893,655 | 893,657 | u874723578 | cpp |
p03077 | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
long long int N, A, B, C, D, E;
cin >> N >> A >> B >> C >> D >> E;
long long int Min = min(A, min(B, min(C, min(D, E))));
long long int kiriage = 0;
if (N % Min == 0) {
kiriage = N / Min;
} else {
kiriage = N / Min + 1;
}
cout << N / Min + 4 << endl;
} | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
long long int N, A, B, C, D, E;
cin >> N >> A >> B >> C >> D >> E;
long long int Min = min(A, min(B, min(C, min(D, E))));
long long int kiriage = 0;
if (N % Min == 0) {
kiriage = N / Min;
} else {
kiriage = (N / Min) + 1;
}
cout << kiriage + 4 << endl;
} | [
"identifier.change",
"io.output.change",
"expression.operation.binary.remove"
] | 893,658 | 893,659 | u421308322 | cpp |
p03077 | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
long long int N, A, B, C, D, E;
cin >> N >> A >> B >> C >> D >> E;
long long int Min = min(A, min(B, min(C, min(D, E))));
long long int kiriage = 0;
if (N % Min == 0) {
kiriage = N / Min;
} else {
kiriage = N / Min + 1;
}
cout << N / Min + 5 << endl;
} | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
long long int N, A, B, C, D, E;
cin >> N >> A >> B >> C >> D >> E;
long long int Min = min(A, min(B, min(C, min(D, E))));
long long int kiriage = 0;
if (N % Min == 0) {
kiriage = N / Min;
} else {
kiriage = (N / Min) + 1;
}
cout << kiriage + 4 << endl;
} | [
"identifier.change",
"io.output.change",
"expression.operation.binary.remove",
"literal.number.change"
] | 893,660 | 893,659 | u421308322 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
const ll MOD = 1e9 + 7;
int main() {
ll n, a, b, c, d, e;
cin >> n >> a >> b >> c >> d >> e;
cout << (n + min({a, b, c, d, e})) / min({a, b, c, d, e}) + 4 << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
const ll MOD = 1e9 + 7;
int main() {
ll n, a, b, c, d, e;
cin >> n >> a >> b >> c >> d >> e;
cout << (n - 1 + min({a, b, c, d, e})) / min({a, b, c, d, e}) + 4 << endl;
return 0;
} | [
"expression.operation.binary.add"
] | 893,661 | 893,662 | u568419568 | cpp |
p03077 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i < (n); i++)
#define repe(i, n) for (auto &&i : n)
#define all(v) (v).begin(), (v).end()
#define decimal fixed << setprecision(20)
#define fastcin() \
cin.tie(0); \
ios::sync_with_stdio(false)
using namespace std;
using LL = long long;
const int INF = 1e9;
const LL LLINF = 1e16;
const int mod = 1e9 + 7;
int main() {
LL n;
cin >> n;
vector<LL> a(5);
rep(i, 5) cin >> a[i];
LL ans = 5;
ans += n / *min_element(all(a));
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i < (n); i++)
#define repe(i, n) for (auto &&i : n)
#define all(v) (v).begin(), (v).end()
#define decimal fixed << setprecision(20)
#define fastcin() \
cin.tie(0); \
ios::sync_with_stdio(false)
using namespace std;
using LL = long long;
const int INF = 1e9;
const LL LLINF = 1e16;
const int mod = 1e9 + 7;
int main() {
LL n;
cin >> n;
vector<LL> a(5);
rep(i, 5) cin >> a[i];
LL ans = 5;
ans += (n - 1) / *min_element(all(a));
cout << ans << endl;
} | [] | 893,666 | 893,667 | u996252264 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b, c, d, e, ans = 0;
cin >> n >> a >> b >> c >> d >> e;
long long mn = min(a, min(b, min(c, min(d, e))));
ans = ((n + mn) / mn) + 4;
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b, c, d, e, ans = 0;
cin >> n >> a >> b >> c >> d >> e;
long long mn = min(a, min(b, min(c, min(d, e))));
ans = ((n + mn - 1) / mn) + 4;
cout << ans;
} | [
"assignment.change"
] | 893,672 | 893,673 | u168820186 | cpp |
p03077 | #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
int main() {
int n, a, b, c, d, e;
cin >> n >> a >> b >> c >> d >> e;
cout << max({(n - 1) / a, (n - 1) / b, (n - 1) / c, (n - 1) / d,
(n - 1) / e}) +
5
<< endl;
return 0;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
int main() {
long long n, a, b, c, d, e;
cin >> n >> a >> b >> c >> d >> e;
cout << max({(n - 1) / a, (n - 1) / b, (n - 1) / c, (n - 1) / d,
(n - 1) / e}) +
5
<< endl;
return 0;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 893,684 | 893,685 | u959815036 | cpp |
p03077 | #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
int main() {
int n, a, b, c, d, e;
cin >> n >> a >> b >> c >> d >> e;
cout << max({(n - 1) / a, (n - 1) / b, (n - 1) / c, (n - 1) / d,
(n - 1) / e}) +
5
<< endl;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
int main() {
long long n, a, b, c, d, e;
cin >> n >> a >> b >> c >> d >> e;
cout << max({(n - 1) / a, (n - 1) / b, (n - 1) / c, (n - 1) / d,
(n - 1) / e}) +
5
<< endl;
return 0;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"control_flow.return.add",
"control_flow.return.0.add"
] | 893,686 | 893,685 | u959815036 | cpp |
p03077 | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
long long n;
long long a[5];
long long m = 99999999;
cin >> n;
long long sum = 0;
long long tmp = 0;
for (int i = 0; i < 5; ++i) {
cin >> a[i];
}
for (int i = 0; i < 5; ++i) {
if (a[i] < m) {
m = a[i];
tmp = i;
}
}
sum += (n + (m - 1)) / m;
sum += 5 - tmp;
cout << sum << endl;
} | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
long long n;
long long a[5];
long long m = 9223372036854775807;
cin >> n;
long long sum = 0;
long long tmp = 0;
for (int i = 0; i < 5; ++i) {
cin >> a[i];
}
for (int i = 0; i < 5; ++i) {
if (a[i] < m) {
m = a[i];
tmp = i;
}
}
sum += (n + (m - 1)) / m;
sum += 4;
cout << sum << endl;
} | [
"literal.number.change",
"variable_declaration.value.change",
"assignment.value.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 893,689 | 893,688 | u527806673 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
vector<int> a(5);
cin >> n;
int min;
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
min = *min_element(a.begin(), a.end());
cout << 4 + (n + min - 1) / min << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
vector<long long> a(5);
cin >> n;
long long min;
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
min = *min_element(a.begin(), a.end());
cout << 4 + (n + min - 1) / min << endl;
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 893,692 | 893,691 | u843574076 | cpp |
p03077 | #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 a[5], n;
cin >> n;
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
int cur_time = 0;
for (int i = 0; i < 5; i++) {
if (n % a[i] == 0) {
cur_time = max((n / a[i]) + i, cur_time + 1);
} else {
cur_time = max((n / a[i]) + i, cur_time + 1);
}
}
cout << cur_time << 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 a[5], n;
cin >> n;
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
int cur_time = 0;
for (int i = 0; i < 5; i++) {
if (n % a[i] == 0) {
cur_time = max((n / a[i]) + i, cur_time + 1);
} else {
cur_time = max((n / a[i]) + i + 1, cur_time + 1);
}
}
cout << cur_time << endl;
return 0;
} | [
"assignment.change"
] | 893,693 | 893,694 | u124992729 | cpp |
p03077 | #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 a[5], n;
cin >> n;
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
int x = *(min_element(a, a + 5));
int ans = n / x;
if (n % x == 0) {
ans += 1;
}
ans += 5;
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 a[5], n;
cin >> n;
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
int x = *(min_element(a, a + 5));
int ans = n / x;
if (n % x == 0) {
ans -= 1;
}
ans += 5;
cout << ans << endl;
return 0;
}
| [
"expression.operator.change"
] | 893,695 | 893,696 | u124992729 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long N;
cin >> N;
vector<long long> X(5);
for (int i = 0; i < 5; i++) {
cin >> X[i];
}
sort(X.begin(), X.end());
long long ans = ceil((float)N / X[0]) + 4;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long N;
cin >> N;
vector<long long> X(5);
for (int i = 0; i < 5; i++) {
cin >> X[i];
}
sort(X.begin(), X.end());
long long ans = ceil((long double)N / X[0]) + 4;
cout << ans << endl;
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 893,700 | 893,701 | u471030817 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long N;
cin >> N;
vector<long long> X(5);
for (int i = 0; i < 5; i++) {
cin >> X[i];
}
sort(X.begin(), X.end());
long long ans = ceil(N / X[0]) + 5;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long N;
cin >> N;
vector<long long> X(5);
for (int i = 0; i < 5; i++) {
cin >> X[i];
}
sort(X.begin(), X.end());
long long ans = ceil((long double)N / X[0]) + 4;
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"expression.operation.binary.change"
] | 893,702 | 893,701 | u471030817 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rrep(i, a, b) for (int i = a; i >= b; i--)
#define all(v) v.begin(), v.end()
#define mod 1000000007
//'A' = 65, 'Z' = 90, 'a' = 97, 'z' = 122
int main() {
ll n, a, b, c, d, e;
cin >> n >> a >> b >> c >> d >> e;
cout << 5 + n / min({a, b, c, d, e}) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rrep(i, a, b) for (int i = a; i >= b; i--)
#define all(v) v.begin(), v.end()
#define mod 1000000007
//'A' = 65, 'Z' = 90, 'a' = 97, 'z' = 122
int main() {
ll n, a, b, c, d, e;
cin >> n >> a >> b >> c >> d >> e;
cout << 5 + (n - 1) / min({a, b, c, d, e}) << endl;
return 0;
}
| [] | 893,703 | 893,704 | u214304095 | cpp |
p03077 | #include <algorithm>
#include <iostream>
#include <list>
#include <map>
#include <string>
#include <vector>
using namespace std;
int main() {
long long N, A, B, C, D, E;
cin >> N >> A >> B >> C >> D >> E;
long long min = A;
if (min > B)
min = B;
if (min > C)
min = C;
if (min > D)
min = D;
if (min > E)
min = E;
cout << N / min + 5 << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <list>
#include <map>
#include <string>
#include <vector>
using namespace std;
int main() {
long long N, A, B, C, D, E;
cin >> N >> A >> B >> C >> D >> E;
long long min = A;
if (min > B)
min = B;
if (min > C)
min = C;
if (min > D)
min = D;
if (min > E)
min = E;
cout << (N - 1) / min + 5 << endl;
return 0;
} | [] | 893,716 | 893,717 | u544361885 | cpp |
p03077 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int move(int move_num, int original_num) {
if (move_num > original_num)
move_num = original_num;
return move_num;
}
int main(void) {
long long a[5];
long long N;
cin >> N;
cin >> a[0] >> a[1] >> a[2] >> a[3] >> a[4];
long long X = min({a[0], a[1], a[2], a[3], a[4]});
cout << (long long)(ceil(N / X) + 5) << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int move(int move_num, int original_num) {
if (move_num > original_num)
move_num = original_num;
return move_num;
}
int main(void) {
long long a[5];
long long N;
cin >> N;
cin >> a[0] >> a[1] >> a[2] >> a[3] >> a[4];
long long X = min({a[0], a[1], a[2], a[3], a[4]});
cout << (long long)(ceil((double)N / X) + 4) << endl;
return 0;
} | [
"literal.number.change",
"io.output.change"
] | 893,722 | 893,723 | u867671099 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
vector<long long int> capacity(5);
for (int i = 0; i < 5; i++) {
cin >> capacity[i];
}
sort(capacity.begin(), capacity.end());
if (n % capacity[0] == 0) {
n -= capacity[0];
}
cout << n / capacity[0] + 4;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
vector<long long int> capacity(5);
for (int i = 0; i < 5; i++) {
cin >> capacity[i];
}
sort(capacity.begin(), capacity.end());
if (n % capacity[0] == 0) {
n -= capacity[0];
}
cout << (n / capacity[0]) + 5;
}
| [
"literal.number.change",
"io.output.change"
] | 893,727 | 893,728 | u544165468 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
int main() {
int64_t n;
cin >> n;
vector<int64_t> A(5);
for (auto &a : A)
cin >> a;
int64_t mi = *min_element(A.begin(), A.end());
cout << ((n + mi) / mi) + 4;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int64_t n;
cin >> n;
vector<int64_t> A(5);
for (auto &a : A)
cin >> a;
int64_t mi = *min_element(A.begin(), A.end());
cout << ((n + mi - 1) / mi) + 4;
}
| [
"expression.operation.binary.add"
] | 893,729 | 893,730 | u268793453 | cpp |
p03077 | #include <algorithm>
#include <cassert>
#include <functional>
#include <iostream>
using namespace std;
int main() {
long N, A, B, C, D, E;
cin >> N >> A >> B >> C >> D >> E;
int m;
m = min(min(min(min(A, B), C), D), E);
int t = (N + m - 1) / m; //一番遅い人がBまでいく時間
cout << t + 4 << endl;
} | #include <algorithm>
#include <cassert>
#include <functional>
#include <iostream>
using namespace std;
int main() {
long long N, A, B, C, D, E;
cin >> N >> A >> B >> C >> D >> E;
long long m;
m = min(min(min(min(A, B), C), D), E);
// m=min({A, B, C, D, E});
long long t = (N + m - 1) / m; //一番遅い人がBまでいく時間
cout << t + 4 << endl;
} | [
"variable_declaration.type.widen.change",
"variable_declaration.type.primitive.change"
] | 893,746 | 893,747 | u824310141 | cpp |
p03077 | #include <algorithm>
#include <cassert>
#include <functional>
#include <iostream>
using namespace std;
int main() {
int N, A, B, C, D, E;
cin >> N >> A >> B >> C >> D >> E;
int m;
m = min(min(min(min(A, B), C), D), E);
int t = (N + m - 1) / m; //一番遅い人がBまでいく時間
cout << t + 4 << endl;
} | #include <algorithm>
#include <cassert>
#include <functional>
#include <iostream>
using namespace std;
int main() {
long long N, A, B, C, D, E;
cin >> N >> A >> B >> C >> D >> E;
long long m;
m = min(min(min(min(A, B), C), D), E);
// m=min({A, B, C, D, E});
long long t = (N + m - 1) / m; //一番遅い人がBまでいく時間
cout << t + 4 << endl;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 893,748 | 893,747 | u824310141 | cpp |
p03077 | #include <algorithm>
#include <cassert>
#include <functional>
#include <iostream>
using namespace std;
int main() {
long long N, A, B, C, D, E;
cin >> N >> A >> B >> C >> D >> E;
int m;
// m= min( min( min( min(A, B), C), D), E);
m = min({A, B, C, D, E});
int t = (N + m - 1) / m; //一番遅い人がBまでいく時間
cout << t + 4 << endl;
} | #include <algorithm>
#include <cassert>
#include <functional>
#include <iostream>
using namespace std;
int main() {
long long N, A, B, C, D, E;
cin >> N >> A >> B >> C >> D >> E;
long long m;
// m= min( min( min( min(A, B), C), D), E);
m = min({A, B, C, D, E});
long long t = (N + m - 1) / m; //一番遅い人がBまでいく時間
cout << t + 4 << endl;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 893,749 | 893,750 | u824310141 | cpp |
p03077 | #include <algorithm>
#include <iostream>
using namespace std;
int main(void) {
// Your code here!
long long N, A, B, C, D, E;
cin >> N >> A >> B >> C >> D >> E;
long long MinTime = min({A, B, C, D, E});
int ans = (N + MinTime - 1) / MinTime + 4;
cout << ans << endl;
} | #include <algorithm>
#include <iostream>
using namespace std;
int main(void) {
// Your code here!
long long N, A, B, C, D, E;
cin >> N >> A >> B >> C >> D >> E;
long long MinTime = min({A, B, C, D, E});
long long ans = (N + MinTime - 1) / MinTime + 4;
cout << ans << endl;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 893,756 | 893,757 | u652286295 | cpp |
p03077 | #include <algorithm>
#include <iostream>
using namespace std;
int main(void) {
// Your code here!
long long N, A, B, C, D, E;
cin >> N >> A >> B >> C >> D >> E;
long long MinTime = min({A, B, C, D, E});
int ans = (N + MinTime - 1) / MinTime + 4;
cout << ans << endl;
} | #include <algorithm>
#include <iostream>
using namespace std;
int main(void) {
// Your code here!
long long N, A, B, C, D, E;
cin >> N >> A >> B >> C >> D >> E;
long long MinTime = min({A, B, C, D, E});
long long ans = (N + MinTime - 1) / MinTime + 4;
cout << ans << endl;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 893,756 | 893,758 | u652286295 | cpp |
p03077 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
long long n;
long long mn = 1e15 + 1;
cin >> n;
for (int i = 0; i < 5; i++) {
long long tmp;
cin >> tmp;
mn = min(mn, tmp);
}
long long ans = n / mn + 5;
if (n % mn == 0) {
ans++;
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
long long n;
long long mn = 1e16 + 1;
cin >> n;
for (int i = 0; i < 5; i++) {
long long tmp;
cin >> tmp;
mn = min(mn, tmp);
}
long long ans = n / mn + 4;
if (n % mn != 0) {
ans++;
}
cout << ans << endl;
return 0;
}
| [
"literal.number.change",
"expression.operation.binary.change",
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 893,764 | 893,765 | u696583119 | cpp |
p03077 | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
long long N, A, B, C, D, E;
long long m;
long long tmp;
cin >> N >> A >> B >> C >> D >> E;
m = min(A, min(B, min(C, min(D, E))));
tmp = N / m == 0 ? N / m : N / m + 1;
cout << tmp + 4 << endl;
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
long long N, A, B, C, D, E;
long long m;
long long tmp;
cin >> N >> A >> B >> C >> D >> E;
m = min(A, min(B, min(C, min(D, E))));
tmp = N % m == 0 ? N / m : N / m + 1;
cout << tmp + 4 << endl;
return 0;
} | [
"expression.operator.arithmetic.change",
"assignment.value.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 893,770 | 893,771 | u945273850 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b, c, d, e;
cin >> n >> a >> b >> c >> d >> e;
long long m = min({a, b, c, d, e});
cout << 4 + n / m + (n % m == 0) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b, c, d, e;
cin >> n >> a >> b >> c >> d >> e;
long long m = min({a, b, c, d, e});
cout << 4 + n / m + (n % m != 0) << endl;
} | [
"misc.opposites",
"expression.operator.compare.change",
"io.output.change"
] | 893,773 | 893,774 | u706790759 | cpp |
p03077 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <vector>
using namespace std;
typedef long long ll;
int main(void) {
ll a[5], n, mn = 200;
cin >> n >> a[0] >> a[1] >> a[2] >> a[3] >> a[4];
for (int i = 0; i < 5; i++) {
mn = min(mn, a[i]);
}
cout << ((n - 1) / mn + 1) + 4 << endl;
}
| #include <algorithm>
#include <iostream>
#include <math.h>
#include <vector>
using namespace std;
typedef long long ll;
int main(void) {
ll a[5], n, mn = 1e18;
cin >> n >> a[0] >> a[1] >> a[2] >> a[3] >> a[4];
for (int i = 0; i < 5; i++) {
mn = min(mn, a[i]);
}
cout << ((n - 1) / mn + 1) + 4 << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 893,775 | 893,776 | u921168761 | cpp |
p03077 | #include <algorithm>
#include <climits>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
int main(void) {
long int n;
cin >> n;
long int min = LONG_MAX;
for (int i = 0; i < 5; i++) {
long int a;
cin >> a;
if (a < min) {
min = a;
}
}
long int ans = n % min == 0l ? n / min + 3l : n / min + 4l;
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
int main(void) {
long int n;
cin >> n;
long int min = LONG_MAX;
for (int i = 0; i < 5; i++) {
long int a;
cin >> a;
if (a < min) {
min = a;
}
}
long int ans = n % min == 0l ? n / min + 4l : n / min + 5l;
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"expression.operation.binary.change"
] | 893,800 | 893,801 | u254766083 | cpp |
p03077 | #include <algorithm>
#include <iostream>
#include <vector>
#define ll long long
using namespace std;
int main() {
ll N;
ll A, B, C, D, E;
cin >> N;
cin >> A >> B >> C >> D >> E;
ll MinMove = min({A, B, C, D, E});
ll ans = (N + MinMove - 1) / MinMove;
cout << ans << endl;
}
| #include <algorithm>
#include <iostream>
#include <vector>
#define ll long long
using namespace std;
int main() {
ll N;
ll A, B, C, D, E;
cin >> N;
cin >> A >> B >> C >> D >> E;
ll MinMove = min({A, B, C, D, E});
ll ans = (N + MinMove - 1) / MinMove;
cout << ans + 4 << endl;
}
| [
"expression.operation.binary.add"
] | 893,813 | 893,814 | u847913816 | cpp |
p03077 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <vector>
using namespace std;
using ll = long long;
const ll INF = pow(10, 18) + 1;
#define FOR(i, a, n) for (int i = (int)(a); i < (int)(n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define pb(a) push_back(a)
#define all(x) (x).begin(), (x).end()
template <typename T> bool chmin(T &a, T b) {
return a > b ? a = b, true : false;
}
template <typename T> bool chmax(T &a, T b) {
return a < b ? a = b, true : false;
}
int main() {
ll N, A[10];
cin >> N;
REP(i, 5) { cin >> A[i]; }
ll mn = min(A[0], min(A[1], min(A[2], min(A[3], A[4]))));
ll res = ceil(N / mn) + 5;
cout << res << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <math.h>
#include <vector>
using namespace std;
using ll = long long;
const ll INF = pow(10, 18) + 1;
#define FOR(i, a, n) for (int i = (int)(a); i < (int)(n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define pb(a) push_back(a)
#define all(x) (x).begin(), (x).end()
template <typename T> bool chmin(T &a, T b) {
return a > b ? a = b, true : false;
}
template <typename T> bool chmax(T &a, T b) {
return a < b ? a = b, true : false;
}
int main() {
ll N, A[10];
cin >> N;
REP(i, 5) { cin >> A[i]; }
ll mn = min(A[0], min(A[1], min(A[2], min(A[3], A[4]))));
ll res = ceil((N - 1) / mn) + 5;
cout << res << endl;
return 0;
} | [
"call.arguments.change"
] | 893,819 | 893,820 | u155088988 | cpp |
p03077 | #include <algorithm>
#include <assert.h>
#include <complex>
#include <ctime>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <memory.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
const int INF = 1e9 + 1;
const ll LLINF = 1e18 + 1;
int main() {
ll N;
cin >> N;
vector<ll> v(5);
for (int i = 0; i < 5; i++)
cin >> v[i];
sort(v.begin(), v.end());
cout << 4 + ((N + v[0]) / v[0]) << endl;
return 0;
} | #include <algorithm>
#include <assert.h>
#include <complex>
#include <ctime>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <memory.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
const int INF = 1e9 + 1;
const ll LLINF = 1e18 + 1;
int main() {
ll N;
cin >> N;
vector<ll> v(5);
for (int i = 0; i < 5; i++)
cin >> v[i];
sort(v.begin(), v.end());
cout << 4LL + ((N + v[0] - 1) / v[0]) << endl;
return 0;
} | [
"literal.number.type.widen.change"
] | 893,821 | 893,822 | u262288723 | cpp |
p03077 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#define rep(i, a, n) for (int i = a; i < n; ++i)
#define per(i, a, n) for (int i = n - 1; i >= a; --i)
#define fill0(n) setfill('0') << right << setw(n)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define INF 1000000007
using namespace std;
typedef long long ll;
int main() {
const int size = 5;
ll N;
cin >> N;
vector<ll> vehicle(size);
rep(i, 0, size) cin >> vehicle[i];
sort(all(vehicle));
ll mini = vehicle[0];
ll move = (N + mini) / mini;
ll time = move + 4;
cout << time << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#define rep(i, a, n) for (int i = a; i < n; ++i)
#define per(i, a, n) for (int i = n - 1; i >= a; --i)
#define fill0(n) setfill('0') << right << setw(n)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define INF 1000000007
using namespace std;
typedef long long ll;
int main() {
const int size = 5;
ll N;
cin >> N;
vector<ll> vehicle(size);
rep(i, 0, size) cin >> vehicle[i];
sort(all(vehicle));
ll mini = vehicle[0];
ll move = (N - 1) / mini;
ll time = move + 5;
cout << time << endl;
return 0;
} | [
"literal.number.change",
"expression.operation.binary.change"
] | 893,825 | 893,826 | u148555958 | cpp |
p03077 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#define rep(i, a, n) for (int i = a; i < n; ++i)
#define per(i, a, n) for (int i = n - 1; i >= a; --i)
#define fill0(n) setfill('0') << right << setw(n)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define INF 1000000007
using namespace std;
typedef long long ll;
int main() {
const int size = 5;
ll N;
cin >> N;
vector<ll> vehicle(size);
rep(i, 0, size) cin >> vehicle[i];
sort(all(vehicle));
int mini = vehicle[0];
ll move = (N + mini) / mini;
ll time = move + 4;
cout << time << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#define rep(i, a, n) for (int i = a; i < n; ++i)
#define per(i, a, n) for (int i = n - 1; i >= a; --i)
#define fill0(n) setfill('0') << right << setw(n)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define INF 1000000007
using namespace std;
typedef long long ll;
int main() {
const int size = 5;
ll N;
cin >> N;
vector<ll> vehicle(size);
rep(i, 0, size) cin >> vehicle[i];
sort(all(vehicle));
ll mini = vehicle[0];
ll move = (N - 1) / mini;
ll time = move + 5;
cout << time << endl;
return 0;
} | [
"variable_declaration.type.change",
"literal.number.change",
"expression.operation.binary.change"
] | 893,827 | 893,826 | u148555958 | cpp |
p03077 | // Bartek Kostka
// You are not prepared!
#include "bits/stdc++.h"
using namespace std;
#define x first
#define y second
#define SZ(x) int(x.size())
#define ll long long
#define pii pair<int, int>
#define vi vector<int>
#define ALL(x) x.begin(), x.end()
#ifdef LOCAL
template <class TH> void _dbg(const char *sdbg, TH h) {
cerr << sdbg << " = " << h << endl;
}
template <class TH, class... TA> void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',')
cerr << *sdbg++;
cerr << " = " << h << ", ";
_dbg(sdbg + 1, a...);
}
#define dbg(...) _dbg(#__VA_ARGS__, __VA_ARGS__)
#else
#define dbg(...)
#define cerr \
if (false) \
cout
#endif
int main() {
ll n;
cin >> n;
vector<ll> A(5);
for (int i = 0; i < 5; i++)
cin >> A[i];
ll res = 0;
for (int i = 0; i < 5; i++) {
res = max(res, 5 + (A[i] - 1 + n) / A[i]);
}
cout << res << "\n";
}
| // Bartek Kostka
// You are not prepared!
#include "bits/stdc++.h"
using namespace std;
#define x first
#define y second
#define SZ(x) int(x.size())
#define ll long long
#define pii pair<int, int>
#define vi vector<int>
#define ALL(x) x.begin(), x.end()
#ifdef LOCAL
template <class TH> void _dbg(const char *sdbg, TH h) {
cerr << sdbg << " = " << h << endl;
}
template <class TH, class... TA> void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',')
cerr << *sdbg++;
cerr << " = " << h << ", ";
_dbg(sdbg + 1, a...);
}
#define dbg(...) _dbg(#__VA_ARGS__, __VA_ARGS__)
#else
#define dbg(...)
#define cerr \
if (false) \
cout
#endif
int main() {
ll n;
cin >> n;
vector<ll> A(5);
for (int i = 0; i < 5; i++)
cin >> A[i];
ll res = 0;
for (int i = 0; i < 5; i++) {
res = max(res, 5 + (A[i] - 1 + n) / A[i]);
}
cout << res - 1 << "\n";
}
| [
"expression.operation.binary.add"
] | 893,830 | 893,831 | u805485630 | cpp |
p03077 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
long long int N, A, B, C, D, E;
cin >> N >> A >> B >> C >> D >> E;
long long int num_min = min(A, min(B, min(C, min(D, E))));
long long int time2pass;
if (N % num_min == 0) {
time2pass = N / num_min;
} else {
long long int time2pass = N / num_min + 1;
}
cout << time2pass + 4 << endl;
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
long long int N, A, B, C, D, E;
cin >> N >> A >> B >> C >> D >> E;
long long int num_min = min(A, min(B, min(C, min(D, E))));
long long int time2pass;
if (N % num_min == 0) {
time2pass = N / num_min;
} else {
time2pass = N / num_min + 1;
}
cout << time2pass + 4 << endl;
} | [] | 893,832 | 893,833 | u860597287 | cpp |
p03077 | #include <iostream>
using namespace std;
typedef long long ll;
ll N, A[5], ans, mini = 1000000000000000;
int main() {
cin >> N;
for (int i = 0; i < 5; i++) {
cin >> A[i];
mini = min(mini, A[i]);
}
ans = N / mini;
cout << ans + 5 << endl;
}
| #include <iostream>
using namespace std;
typedef long long ll;
ll N, A[5], ans, mini = 1000000000000000;
int main() {
cin >> N;
for (int i = 0; i < 5; i++) {
cin >> A[i];
mini = min(mini, A[i]);
}
ans = (N - 1) / mini;
cout << ans + 5 << endl;
} | [] | 893,834 | 893,835 | u016531517 | cpp |
p03077 | #include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
ull N;
int main() {
cin >> N;
ll minrate = 1.1e15;
int minidx = 0;
vector<ll> v;
for (int i = 0; i < 5; i++) {
ll a;
cin >> a;
v.push_back(a);
if (minrate > a) {
minrate = a;
minidx = i;
}
}
ll ans = (N + minrate - 1) / minrate + 4 - minidx;
cout << ans << endl;
return 0;
} | #include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
ull N;
int main() {
cin >> N;
ll minrate = 1.1e15;
int minidx = 0;
vector<ull> v;
for (int i = 0; i < 5; i++) {
ull a;
cin >> a;
v.push_back(a);
if (minrate > a) {
minrate = a;
minidx = i;
}
}
ull ans = (N + minrate - 1) / minrate + 4;
cout << ans << endl;
return 0;
} | [
"variable_declaration.type.change",
"expression.operation.binary.remove"
] | 893,840 | 893,841 | u286493216 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(void) {
ll N, A, B, C, D, E;
cin >> N >> A >> B >> C >> D >> E;
ll min = A;
if (B < min)
min = B;
if (C < min)
min = C;
if (D < min)
min = D;
if (E < min)
min = E;
cout << N / min + 5;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(void) {
ll N, A, B, C, D, E;
cin >> N >> A >> B >> C >> D >> E;
ll min = A;
if (B < min)
min = B;
if (C < min)
min = C;
if (D < min)
min = D;
if (E < min)
min = E;
cout << (N - 1) / min + 5;
} | [] | 893,842 | 893,843 | u671687924 | cpp |
p03077 | #include <algorithm>
#include <iostream>
using namespace std;
long long N, A[5];
int main() {
cin >> N >> A[0] >> A[1] >> A[2] >> A[3] >> A[4];
sort(A, A + 5);
cout << N / A[0] + 5;
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
long long N, A[5];
int main() {
cin >> N >> A[0] >> A[1] >> A[2] >> A[3] >> A[4];
sort(A, A + 5);
cout << (N - 1) / A[0] + 5;
return 0;
} | [] | 893,848 | 893,849 | u740232619 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
long long trips[5];
scanf("%lld", &n);
if (n == 0) {
printf("0");
return 0;
}
scanf("%lld", &trips[0]);
for (int i = 1; i < 5; i++) {
scanf("%d", &trips[i]);
trips[i] = min(trips[i], trips[i - 1]);
}
printf("%lld", 5 + (n - 1) / trips[4]);
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
long long trips[5];
scanf("%lld", &n);
if (n == 0) {
printf("0");
return 0;
}
scanf("%lld", &trips[0]);
for (int i = 1; i < 5; i++) {
scanf("%lld", &trips[i]);
trips[i] = min(trips[i], trips[i - 1]);
// printf("%lld", trips[i]);
}
// printf("%lld", trips[4]);
printf("%lld", 5 + (n - 1) / trips[4]);
}
| [
"literal.string.change",
"call.arguments.change"
] | 893,850 | 893,851 | u887755635 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll N;
cin >> N;
vector<ll> Q(5);
for (int i = 0; i < 5; i++) {
cin >> Q[i];
}
sort(Q.begin(), Q.end());
cout << N / Q[0] + 5 << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll N;
cin >> N;
vector<ll> Q(5);
for (int i = 0; i < 5; i++) {
cin >> Q[i];
}
sort(Q.begin(), Q.end());
cout << (N - 1) / Q[0] + 5 << endl;
} | [] | 893,854 | 893,855 | u045811375 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll N;
cin >> N;
vector<int> Q(5);
for (int i = 0; i < 5; i++) {
cin >> Q[i];
}
sort(Q.begin(), Q.end());
cout << N / Q[0] + 5 << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll N;
cin >> N;
vector<ll> Q(5);
for (int i = 0; i < 5; i++) {
cin >> Q[i];
}
sort(Q.begin(), Q.end());
cout << (N - 1) / Q[0] + 5 << endl;
} | [] | 893,856 | 893,855 | u045811375 | cpp |
p03077 | #include <bits/stdc++.h>
#define rep(i, m) for (long long i = 0; i < m; i++)
#define per(i, m) for (long long i = m - 1; i >= 0; i--)
#define FOR(i, n, m) for (long long i = n; i < m; i++)
#define ROF(i, n, m) for (long long i = m - 1; i >= n; i--)
#define SORT(v, n) \
do { \
sort(v, v + n); \
reverse(v, v + n); \
} while (0)
#define all(x) (x).begin(), (x).end()
#define EPS (1e-7)
#define INF (1e18)
#define PI (acos(-1))
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
typedef pair<ll, ll> LP;
ll POW(ll x, ll n) {
if (n == 0)
return 1;
if (n % 2 == 0)
return POW(x * x, n / 2) % MOD;
return x % MOD * POW(x, n - 1) % MOD;
}
ll POW2(ll x, ll n) {
if (n == 0)
return 1;
if (n % 2 == 0)
return POW2(x * x, n / 2);
return x * POW2(x, n - 1);
}
ll gcd(ll u, ll v) {
ll r;
while (0 != v) {
r = u % v;
u = v;
v = r;
}
return u;
}
ll KAI(ll m) {
if (m < 0)
return 0;
if (m == 0)
return 1;
return m * KAI(m - 1) % MOD;
}
ll KAI2(ll m) {
if (m < 0)
return 0;
if (m == 0)
return 1;
return m * KAI2(m - 1);
}
ll extGCD(ll a, ll b, ll &x, ll &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
ll d = extGCD(b, a % b, y, x);
y -= a / b * x;
return d;
}
inline ll mod(ll a, ll m) { return (a % m + m) % m; }
ll modinv(ll a) {
ll x, y;
extGCD(a, MOD, x, y);
return mod(x, MOD);
}
ll COM(ll m, ll n) {
if (m < n)
return 0;
if (n < 0)
return 0;
if (n == 0)
return 1;
if (m == n)
return 1;
return KAI(m) % MOD * modinv(KAI(n) % MOD * KAI(m - n) % MOD) % MOD;
}
ll COM2(ll m, ll n) {
if (m < n)
return 0;
if (n < 0)
return 0;
if (n == 0)
return 1;
if (m == n)
return 1;
return KAI2(m) / KAI2(n) / KAI2(m - n);
}
ll DEC(ll x, ll m, ll n) { return x % POW(m, n + 1) / POW(m, n); }
ll keta(ll x, ll n) {
if (x == 0)
return 0;
return keta(x / n, n) + 1;
}
ll DIV(ll x, ll n) {
if (x == 0)
return 0;
return x / n + DIV(x / n, n);
}
ll ORD(ll x, ll n) {
if (x == 0)
return INF;
if (x % n != 0)
return 0;
return 1 + ORD(x / n, n);
}
int main() {
ll n, a[20];
cin >> n;
rep(i, 5) cin >> a[i];
sort(a, a + 5);
printf("%lld", n / a[0] + 5);
} | #include <bits/stdc++.h>
#define rep(i, m) for (long long i = 0; i < m; i++)
#define per(i, m) for (long long i = m - 1; i >= 0; i--)
#define FOR(i, n, m) for (long long i = n; i < m; i++)
#define ROF(i, n, m) for (long long i = m - 1; i >= n; i--)
#define SORT(v, n) \
do { \
sort(v, v + n); \
reverse(v, v + n); \
} while (0)
#define all(x) (x).begin(), (x).end()
#define EPS (1e-7)
#define INF (1e18)
#define PI (acos(-1))
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
typedef pair<ll, ll> LP;
ll POW(ll x, ll n) {
if (n == 0)
return 1;
if (n % 2 == 0)
return POW(x * x, n / 2) % MOD;
return x % MOD * POW(x, n - 1) % MOD;
}
ll POW2(ll x, ll n) {
if (n == 0)
return 1;
if (n % 2 == 0)
return POW2(x * x, n / 2);
return x * POW2(x, n - 1);
}
ll gcd(ll u, ll v) {
ll r;
while (0 != v) {
r = u % v;
u = v;
v = r;
}
return u;
}
ll KAI(ll m) {
if (m < 0)
return 0;
if (m == 0)
return 1;
return m * KAI(m - 1) % MOD;
}
ll KAI2(ll m) {
if (m < 0)
return 0;
if (m == 0)
return 1;
return m * KAI2(m - 1);
}
ll extGCD(ll a, ll b, ll &x, ll &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
ll d = extGCD(b, a % b, y, x);
y -= a / b * x;
return d;
}
inline ll mod(ll a, ll m) { return (a % m + m) % m; }
ll modinv(ll a) {
ll x, y;
extGCD(a, MOD, x, y);
return mod(x, MOD);
}
ll COM(ll m, ll n) {
if (m < n)
return 0;
if (n < 0)
return 0;
if (n == 0)
return 1;
if (m == n)
return 1;
return KAI(m) % MOD * modinv(KAI(n) % MOD * KAI(m - n) % MOD) % MOD;
}
ll COM2(ll m, ll n) {
if (m < n)
return 0;
if (n < 0)
return 0;
if (n == 0)
return 1;
if (m == n)
return 1;
return KAI2(m) / KAI2(n) / KAI2(m - n);
}
ll DEC(ll x, ll m, ll n) { return x % POW(m, n + 1) / POW(m, n); }
ll keta(ll x, ll n) {
if (x == 0)
return 0;
return keta(x / n, n) + 1;
}
ll DIV(ll x, ll n) {
if (x == 0)
return 0;
return x / n + DIV(x / n, n);
}
ll ORD(ll x, ll n) {
if (x == 0)
return INF;
if (x % n != 0)
return 0;
return 1 + ORD(x / n, n);
}
int main() {
ll n, a[20];
cin >> n;
rep(i, 5) cin >> a[i];
sort(a, a + 5);
printf("%lld", (n - 1) / a[0] + 5);
} | [
"call.arguments.change"
] | 893,857 | 893,858 | u107995903 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
long long n, a, b, c, d, e, ans = 0;
cin >> n >> a >> b >> c >> d >> e;
long long mi = min(a, min(b, min(c, min(d, e))));
cout << (n - mi + 1) / mi + 5 << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
long long n, a, b, c, d, e, ans = 0;
cin >> n >> a >> b >> c >> d >> e;
long long mi = min(a, min(b, min(c, min(d, e))));
cout << (n + mi - 1) / mi + 4 << endl;
} | [
"expression.operation.binary.remove",
"literal.number.change",
"io.output.change"
] | 893,861 | 893,862 | u314988220 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, t, Min = -1;
cin >> n;
for (int i = 0; i < 5; i++) {
cin >> t;
if (Min == -1)
Min = t;
Min = min(Min, t);
}
cout << n / Min + 5;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, t, Min = -1;
cin >> n;
for (int i = 0; i < 5; i++) {
cin >> t;
if (Min == -1)
Min = t;
Min = min(Min, t);
}
cout << (n - 1) / Min + 5;
return 0;
}
| [] | 893,884 | 893,885 | u047554023 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
signed main() {
int n, a, b, c, d, e;
cin >> n >> a >> b >> c >> d >> e;
int MIN = min({a, b, c, d, e});
cout << 5 + (n - 1) / MIN;
}
| #include <bits/stdc++.h>
#define int long long
using namespace std;
signed main() {
int n, a, b, c, d, e;
cin >> n >> a >> b >> c >> d >> e;
int MIN = min({a, b, c, d, e});
cout << 5 + (n - 1) / MIN;
}
| [] | 893,886 | 893,887 | u016612263 | cpp |
p03077 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_set>
#include <vector>
#define ll long long
#define P pair<int, int>
#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 LAST(x) (x)[(x).size() - 1]
#define GI(name) \
int(name); \
scanf("%d", &(name))
#define GI2(name1, name2) \
int(name1), (name2); \
scanf("%d %d", &(name1), &(name2))
#define GI3(name1, name2, name3) \
int(name1), (name2), (name3); \
scanf("%d %d %d", &(name1), &(name2), &(name3))
#define GVI(name, size) \
vector<int>(name)(size); \
FOR(i, (size)) scanf("%d", &(name)[i])
using namespace std;
string to_hex(int x) {
stringstream ss;
ss << hex << x;
return ss.str();
}
inline int get_int() {
int ret;
scanf("%d", &ret);
return ret;
}
inline vector<int> get_ints(int n) {
vector<int> ret(n);
FOR(i, n) { scanf("%d", &ret[i]); }
return ret;
}
inline string get_str() {
string ret;
cin >> ret;
return ret;
}
bool is_prime(int n) {
int s = sqrt(n) + 1;
for (int i = 2; i <= s; ++i) {
if (n % i == 0) {
return 0;
}
}
return 1;
}
vector<P> prime_division(int n) {
vector<P> ret;
int s = sqrt(n) + 1;
int c = 0;
for (int i = 2; i <= s; ++i) {
if (n % i == 0) {
c = 0;
do {
++c;
n /= i;
} while (n % i == 0);
ret.push_back(P(i, c));
}
}
return ret;
}
string to_string(string s) { return s; }
template <class T> string to_string(vector<T> v) {
string ret = "{";
FOR(i, v.size() - 1) { ret += to_string(v[i]) + ","; }
if (v.size() > 0) {
ret += to_string(LAST(v));
}
ret += "}";
return ret;
}
void debug_print() { cerr << endl; }
template <class Head, class... Tail> void debug_print(Head head, Tail... tail) {
cerr << to_string(head) << " ";
debug_print(tail...);
}
template <class... T> void debug(T... args) {
cerr << "[" << __LINE__ << "]: ";
debug_print(args...);
}
void print() { cout << endl; }
template <class Head, class... Tail> void print(Head head, Tail... tail) {
cout << to_string(head);
print(tail...);
}
int main() {
ll N;
cin >> N;
vector<ll> A(5);
FOR(i, 5) cin >> A[i];
ll neck = *min_element(ALL(A));
print(5 + N / neck);
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_set>
#include <vector>
#define ll long long
#define P pair<int, int>
#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 LAST(x) (x)[(x).size() - 1]
#define GI(name) \
int(name); \
scanf("%d", &(name))
#define GI2(name1, name2) \
int(name1), (name2); \
scanf("%d %d", &(name1), &(name2))
#define GI3(name1, name2, name3) \
int(name1), (name2), (name3); \
scanf("%d %d %d", &(name1), &(name2), &(name3))
#define GVI(name, size) \
vector<int>(name)(size); \
FOR(i, (size)) scanf("%d", &(name)[i])
using namespace std;
string to_hex(int x) {
stringstream ss;
ss << hex << x;
return ss.str();
}
inline int get_int() {
int ret;
scanf("%d", &ret);
return ret;
}
inline vector<int> get_ints(int n) {
vector<int> ret(n);
FOR(i, n) { scanf("%d", &ret[i]); }
return ret;
}
inline string get_str() {
string ret;
cin >> ret;
return ret;
}
bool is_prime(int n) {
int s = sqrt(n) + 1;
for (int i = 2; i <= s; ++i) {
if (n % i == 0) {
return 0;
}
}
return 1;
}
vector<P> prime_division(int n) {
vector<P> ret;
int s = sqrt(n) + 1;
int c = 0;
for (int i = 2; i <= s; ++i) {
if (n % i == 0) {
c = 0;
do {
++c;
n /= i;
} while (n % i == 0);
ret.push_back(P(i, c));
}
}
return ret;
}
string to_string(string s) { return s; }
template <class T> string to_string(vector<T> v) {
string ret = "{";
FOR(i, v.size() - 1) { ret += to_string(v[i]) + ","; }
if (v.size() > 0) {
ret += to_string(LAST(v));
}
ret += "}";
return ret;
}
void debug_print() { cerr << endl; }
template <class Head, class... Tail> void debug_print(Head head, Tail... tail) {
cerr << to_string(head) << " ";
debug_print(tail...);
}
template <class... T> void debug(T... args) {
cerr << "[" << __LINE__ << "]: ";
debug_print(args...);
}
void print() { cout << endl; }
template <class Head, class... Tail> void print(Head head, Tail... tail) {
cout << to_string(head);
print(tail...);
}
int main() {
ll N;
cin >> N;
vector<ll> A(5);
FOR(i, 5) cin >> A[i];
ll neck = *min_element(ALL(A));
print(5 + (N - 1) / neck);
return 0;
} | [
"call.arguments.change"
] | 893,888 | 893,889 | u656771711 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll n;
cin >> n;
vector<ll> a(5);
for (auto &e : a) {
cin >> e;
}
ll b = a.front();
for (auto e : a) {
b = min(b, e);
}
cout << 5 + n / b << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll n;
cin >> n;
vector<ll> a(5);
for (auto &e : a) {
cin >> e;
}
ll b = a.front();
for (auto e : a) {
b = min(b, e);
}
cout << 5 + (n - 1) / b << endl;
}
| [] | 893,896 | 893,897 | u848737670 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
#define int long long
int INF = 1e9 + 7;
signed main() {
int a[5], n;
cin >> n;
for (int i = 0; i < 5; i++)
cin >> a[i];
sort(a, a + 5);
cout << 5 + n / a[0];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
int INF = 1e9 + 7;
signed main() {
int a[5], n;
cin >> n;
for (int i = 0; i < 5; i++)
cin >> a[i];
sort(a, a + 5);
cout << 5 + (n - 1) / a[0];
return 0;
} | [] | 893,902 | 893,903 | u651317892 | cpp |
p03077 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
int main() {
long a[5], n;
cin >> n;
long m;
cin >> a[0];
m = a[0];
for (int i = 1; i < 5; i++) {
cin >> a[i];
m = min(m, a[i]);
}
int c = n / m;
if (n % m != 0) {
c++;
}
cout << c + 4 << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
int main() {
long a[5], n;
cin >> n;
long m;
cin >> a[0];
m = a[0];
for (int i = 1; i < 5; i++) {
cin >> a[i];
m = min(m, a[i]);
}
long c = n / m;
if (n % m != 0) {
c++;
}
cout << c + 4 << endl;
return 0;
} | [
"variable_declaration.type.primitive.change"
] | 893,910 | 893,911 | u793275002 | cpp |
p03077 |
#include <algorithm>
#include <array>
#include <chrono>
#include <cmath>
#include <cstring>
#include <ctgmath>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <ostream>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define int long long
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> all;
int mini = 99999999999999999LL;
for (int i = 0; i < 5; i++) {
int x;
cin >> x;
mini = min(mini, x);
all.push_back(x);
}
cout << 5 + (n / mini) << "\n";
}
|
#include <algorithm>
#include <array>
#include <chrono>
#include <cmath>
#include <cstring>
#include <ctgmath>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <ostream>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define int long long
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> all;
int mini = 99999999999999999LL;
for (int i = 0; i < 5; i++) {
int x;
cin >> x;
mini = min(mini, x);
all.push_back(x);
}
cout << 5 + ((n - 1) / mini) << "\n";
}
| [] | 893,912 | 893,913 | u972954150 | cpp |
p03077 | // スタックサイズ: 100MB
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
typedef int64_t ll;
typedef vector<ll> vll;
typedef pair<ll, ll> pll;
const ll INF = 1000000000000000000;
#define fori(i, a, b) for (ll i = (a); i < (b); ++i)
#define ford(i, a, b) for (ll i = (b - 1); (a) <= i; --i)
#define rep(i, n) fori(i, 0, n)
#define all(v) (v).begin(), (v).end()
#define fst first
#define snd second
ll pw(ll x, ll y) {
ll r = 1;
rep(i, y) { r *= x; };
return r;
}
int main() {
ll N;
cin >> N;
vll a(5);
rep(i, 5) cin >> a[i];
sort(all(a));
cout << 5 + N / a[0] << endl;
} | // スタックサイズ: 100MB
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
typedef int64_t ll;
typedef vector<ll> vll;
typedef pair<ll, ll> pll;
const ll INF = 1000000000000000000;
#define fori(i, a, b) for (ll i = (a); i < (b); ++i)
#define ford(i, a, b) for (ll i = (b - 1); (a) <= i; --i)
#define rep(i, n) fori(i, 0, n)
#define all(v) (v).begin(), (v).end()
#define fst first
#define snd second
ll pw(ll x, ll y) {
ll r = 1;
rep(i, y) { r *= x; };
return r;
}
int main() {
ll N;
cin >> N;
vll a(5);
rep(i, 5) cin >> a[i];
sort(all(a));
cout << 5 + (N - 1) / a[0] << endl;
} | [] | 893,914 | 893,915 | u511401499 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;
template <class T> using VVV = V<VV<T>>;
template <class S, class T> using P = pair<S, T>;
template <class... T> using TP = tuple<T...>;
using ll = long long;
using ull = unsigned long long;
using dbl = double;
using str = string;
using vll = V<ll>;
using vvll = V<vll>;
using vvvll = V<vvll>;
using pl = P<ll, ll>;
using tl = TP<ll, ll, ll>;
using vpl = V<pl>;
using vvpl = V<vpl>;
using vtl = V<tl>;
using vvtl = V<vtl>;
using vs = V<str>;
using vvs = V<vs>;
using vd = V<dbl>;
using vvd = V<vd>;
using vvvd = V<vvd>;
using qll = queue<ll>;
using qpl = queue<pl>;
using stll = stack<ll>;
using stpl = stack<pl>;
using mapll = map<ll, ll>;
using setll = set<ll>;
using pqll = priority_queue<ll>;
//#define int ll
#define fi first
#define se second
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define pob pop_back()
#define pf push_front
#define pof pop_front()
#define sz size()
#define bgn begin()
#define en end()
#define asn assign
#define emp empty()
#define fr front()
#define bk back()
#define clr clear()
#define ins insert
#define ers erase
#define res resize
#define tp top()
#define p_q priority_queue
#define inv inverse()
#define FOR(i, a, b) for (ll i = (a); i <= (ll)(b); i++)
#define rFOR(i, a, b) for (ll i = (b); i >= (ll)(a); i--)
#define REP(i, a) FOR((i), 0, (ll)(a)-1)
#define REP0(i, a) FOR((i), 0, (ll)(a))
#define REP1(i, a) FOR((i), 1, (ll)(a))
#define rREP(i, a) rFOR((i), 0, (ll)(a)-1)
#define rREP0(i, a) rFOR((i), 0, (ll)(a))
#define rREP1(i, a) rFOR((i), 1, (ll)(a))
#define ROR(v, i) for (auto &(i) : (v))
#define IOTA(a, n) iota((a).bgn, (a).en, (n))
#define SORT(a) sort((a).bgn, (a).en)
#define rSORT(a) sort((a).rbegin(), (a).rend())
#define UNIQUE(a) (a).erase(unique((a).bgn, (a).en), (a).en)
#define PREVP(a) prev_permutation((a).bgn, (a).en)
#define NEXTP(a) next_permutation((a).bgn, (a).en)
#define BINS(a, b) binary_search((a).bgn, (a).en, (b))
#define LOWB(a, b) (lower_bound((a).bgn, (a).en, (b)) - (a).bgn)
#define UPB(a, b) (upper_bound((a).bgn, (a).en, (b)) - (a).bgn)
#define CNT(a, b) count((a).bgn, (a).en, b)
#define SUM(a) accumulate((a).bgn, (a).en, 0)
#define REV(a) reverse((a).bgn, (a).en)
#define REGS(a, b) regex_search((a), regex(b))
#define REGM(a, b) regex_match((a), regex(b))
#define yn(a) cout << ((a) ? "yes" : "no") << "\n";
#define Yn(a) cout << ((a) ? "Yes" : "No") << "\n";
#define YN(a) cout << ((a) ? "YES" : "NO") << "\n";
#define imp(a) cout << ((a) ? "possible" : "impossible") << "\n";
#define Imp(a) cout << ((a) ? "Possible" : "Impossible") << "\n";
#define IMP(a) cout << ((a) ? "POSSIBLE" : "IMPOSSIBLE") << "\n";
#define fs(a) cout << ((a) ? "second" : "first") << "\n";
#define Fs(a) cout << ((a) ? "Second" : "First") << "\n";
#define FS(a) cout << ((a) ? "SECOND" : "FIRST") << "\n";
//#define say(a) cout <<(a);
//#define sal(a) cout <<(a)<<"\n";
#define sak cout << "\n";
#define sas cout << " ";
#define sat cout << "\t";
#define dbg(a) cerr << (#a) << ": " << (a) << "\n";
#define dbgs(...) \
dal(#__VA_ARGS__); \
dal(__VA_ARGS__);
#define c2l(a) ((ll)(a - 48))
#define a2l(a) ((ll)(a - 97))
#define A2l(a) ((ll)(a - 65))
#define l2c(a) ((char)(a + 48))
#define l2a(a) ((char)(a + 97))
#define l2A(a) ((char)(a + 65))
#define DigN2(a) ((llabs(a) == 0) ? (1) : ((ll)(log2(double(llabs(a)))) + 1))
#define DigN10(a) ((llabs(a) == 0) ? (1) : ((ll)(log10(double(llabs(a)))) + 1))
#define Dig2(a, b) (((a) >> (b)) & 1)
#define Dig10(a, b) (ll)(((a) / ((ll)(pow(10.0, (double)(b))))) % 10)
#define Pow2(a) ((ll)(1) << (a))
#define Pow10(a) ((ll)(pow(10.0, double(a))))
#define LSB(a) ((a) & (-(a)))
/*#define llin(a) ll (a);cin >>(a);
#define llin2(a,b) ll (a),(b);cin >>(a)>>(b);
#define llin3(a,b,c) ll (a),(b),(c);cin >>(a)>>(b)>>(c);
#define stin(a) string (a);cin >>(a);*/
#define vin(v) \
ROR((v), (i)) { cin >> (i); };
#define vllin(N, v) \
vll(v)((N)); \
vin(v);
#define vllin2(N, a, b) \
vll(a)(N), (b)(N); \
REP(i, N) { cin >> (a)[i] >> (b)[i]; };
#define vsin(N, v) \
vs(v)((N)); \
vin(v);
#define rdn(a, b) ((a) / (b))
#define rou(a, b) \
((((double(a) / double(b)) - ((a) / (b))) < 0.5) ? ((a) / (b)) \
: (((a) / (b)) + 1))
#define rup(a, b) ((((a) % (b)) == 0) ? ((a) / (b)) : (((a) / (b)) + 1))
#define powll(a, b) (ll)(pow((double)(a), (double)(b)))
#define Triangle(x1, y1, x2, y2, x3, y3) \
(((x1) - (x2)) * ((y1) - (y3)) - ((x1) - (x3)) * ((y1) - (y2)))
#define tg(t, i) get<i>(t)
#define Id(x) get<0>(x)
#define Act(x) get<1>(x)
#define InvAct(x) get<2>(x)
#define mg(id, act) mt(id, act, lam(l))
//#define MonoidSet(T) TP<T, function<T(T, T)>>
#define GroupSet(T) TP<T, function<T(T, T)>, function<T(T, T)>>
#define CompareSet(T) TP<T, function<bool(T, T)>>
#define lam(lr) ([](auto l, auto r) { return (lr); })
#define elam(lr) ([=](auto l, auto r) { return (lr); })
#define clam(lr) ([&](auto l, auto r) { return (lr); })
#define lamr(lr) ([](auto l, auto r) { lr })
#define elamr(lr) ([=](auto l, auto r) { lr })
#define clamr(lr) ([&](auto l, auto r) { lr })
#define min(...) Operation(MIN, __VA_ARGS__)
#define max(...) Operation(MAX, __VA_ARGS__)
#define gcd(...) Operation(GCD, __VA_ARGS__)
#define lcm(...) Operation(LCM, __VA_ARGS__)
#define vmin(...) VOperation(MIN, __VA_ARGS__)
#define vmax(...) VOperation(MAX, __VA_ARGS__)
#define vgcd(...) VOperation(GCD, __VA_ARGS__)
#define vlcm(...) VOperation(LCM, __VA_ARGS__)
#define vsum(...) VOperation(ADD, __VA_ARGS__)
#define vpro(...) VOperation(MUL, __VA_ARGS__)
#define emin(a, ...) ((a) = min((a), __VA_ARGS__))
#define emax(a, ...) ((a) = max((a), __VA_ARGS__))
#define egcd(a, ...) ((a) = gcd((a), __VA_ARGS__))
#define elcm(a, ...) ((a) = lcm((a), __VA_ARGS__))
#define ope Operation
#define vope VOperation
#define svll SumV<ll>
#define svvll SumV2<ll>
#define li(...) \
ll __VA_ARGS__; \
Input(__VA_ARGS__);
#define si(...) \
str __VA_ARGS__; \
Input(__VA_ARGS__);
//#define vli(size, ...) vll __VA_ARGS__;vInitInput(size,__VA_ARGS__);
#define vlr(size, ...) \
vll __VA_ARGS__; \
vInitInputR(size, __VA_ARGS__);
#define vlc(size, ...) \
vll __VA_ARGS__; \
vInitInputC(size, __VA_ARGS__);
#define vli(size, ...) \
vll __VA_ARGS__; \
vInitInputR(size, __VA_ARGS__);
#define vsr(size, ...) \
vs __VA_ARGS__; \
vInitInputR(size, __VA_ARGS__);
#define vsc(size, ...) \
vs __VA_ARGS__; \
vInitInputC(size, __VA_ARGS__);
#define vsi(size, ...) \
vs __VA_ARGS__; \
vInitInputR(size, __VA_ARGS__);
#define vli2(rowSize, columnSize, ...) \
vvll __VA_ARGS__; \
vInitInput2(rowSize, columnSize, __VA_ARGS__);
#define vplr(size, ...) \
vpl __VA_ARGS__; \
vInitInputR(size, __VA_ARGS__);
#define vplc(size, ...) \
vpl __VA_ARGS__; \
vInitInputC(size, __VA_ARGS__);
#define vpli(size, ...) \
vpl __VA_ARGS__; \
vInitInputR(size, __VA_ARGS__);
const ll MOD = 1e9 + 7;
// const ll MOD = 998244353;
// const ll MOD = 924844033;
// const ll MOD = 9007199254740881;
const ll INF = 1LL << 60; // 1.15e18
const double PI = acos(-1.0);
const vll DX = {0, -1, 0, 1, 0, -1, 1, 1, -1};
const vll DY = {0, 0, -1, 0, 1, -1, -1, 1, 1};
const str alp = "abcdefghijklmnopqrstuvwxyz";
const str ALP = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
template <class T> auto GetVectorValueType(T v) { return v; }
template <class T> auto GetVectorValueType(V<T> v) {
return GetVectorValueType(T());
}
template <class S, class T> istream &operator>>(istream &in, P<S, T> &p) {
return in >> p.fi >> p.se;
}
template <class T> istream &operator>>(istream &in, V<T> &v) {
REP(i, v.sz) in >> v[i];
return in;
}
void Input() {}
template <class Var, class... Args> void Input(Var &var, Args &...args) {
cin >> var;
Input(args...);
}
void vInit(ll size) {}
template <class T, class... Args> void vInit(ll size, V<T> &v, Args &...args) {
v.res(size);
vInit(size, args...);
}
void vInput(ll size) {}
template <class T, class... Args> void vInput(ll size, V<T> &v, Args &...args) {
REP(i, size) cin >> v[i];
vInput(size, args...);
}
void vInputR(ll size) {}
template <class T, class... Args>
void vInputR(ll size, V<T> &v, Args &...args) {
REP(i, size) cin >> v[i];
vInputR(size, args...);
}
void vInputNumC(ll num) {}
template <class T, class... Args>
void vInputNumC(ll num, V<T> &v, Args &...args) {
cin >> v[num];
vInputNumC(num, args...);
}
void vInputC(ll size) {}
template <class... Args> void vInputC(ll size, Args &...args) {
REP(i, size) vInputNumC(i, args...);
}
void vInitInputR(ll size) {}
template <class... Args> void vInitInputR(ll size, Args &...args) {
vInit(size, args...);
vInputR(size, args...);
}
void vInitInputC(ll size) {}
template <class... Args> void vInitInputC(ll size, Args &...args) {
vInit(size, args...);
vInputC(size, args...);
}
void vInit2(ll rowSize, ll columnSize) {}
template <class T, class... Args>
void vInit2(ll rowSize, ll columnSize, VV<T> &v, Args &...args) {
v.asn(rowSize, V<T>(columnSize));
vInit2(rowSize, columnSize, args...);
}
void vInput2(ll rowSize, ll columnSize) {}
template <class T, class... Args>
void vInput2(ll rowSize, ll columnSize, VV<T> &v, Args &...args) {
REP(r, rowSize) {
REP(c, columnSize) { cin >> v[r][c]; }
}
vInput2(rowSize, columnSize, args...);
}
void vInitInput2(ll rowSize, ll columnSize) {}
template <class... Args>
void vInitInput2(ll rowSize, ll columnSize, Args &...args) {
vInit2(rowSize, columnSize, args...);
vInput2(rowSize, columnSize, args...);
}
template <class S, class T>
ostream &operator<<(ostream &out, const P<S, T> &p) {
return out << "[" << p.fi << ", " << p.se << "]";
}
template <class T> ostream &operator<<(ostream &out, V<T> &v) {
if (v.emp)
return out << "{}";
else {
auto itr = v.bgn;
out << "{" << *itr;
itr++;
while (itr != v.en) {
out << ", " << *itr;
itr++;
}
out << "}";
return out;
}
}
template <class S, class T>
ostream &operator<<(ostream &out, const map<S, T> &m) {
if (m.emp)
return out << "<[]>";
else {
auto itr = m.bgn;
out << "< [" << (itr->fi) << ": " << (itr->se);
itr++;
while (itr != m.en) {
out << "], [" << (itr->fi) << ": " << (itr->se);
itr++;
}
out << "] >";
return out;
}
}
template <class T> ostream &operator<<(ostream &out, const set<T> &s) {
if (s.emp)
return out << "<>";
else {
auto itr = s.bgn;
out << "<" << *itr;
itr++;
while (itr != s.en) {
out << ", " << *itr;
itr++;
}
out << ">";
return out;
}
}
void say() {}
template <class T> void say(T t) { cout << t; }
template <class Head, class... Body> void say(Head head, Body... body) {
cout << head << " ";
say(body...);
}
void sal() { cout << "\n"; }
template <class... Args> void sal(Args... args) {
say(args...);
cout << "\n";
}
void day() {}
template <class T> void day(T t) { cerr << t; }
template <class Head, class... Body> void day(Head head, Body... body) {
cerr << head << " ";
day(body...);
}
void dal() { cerr << "\n"; }
template <class... Args> void dal(Args... args) {
day(args...);
cerr << "\n";
}
void salv() {}
template <class T> void salv(V<T> v) {
if (v.emp)
sal();
else {
auto itr = v.bgn;
say(*itr);
itr++;
while (itr != v.en) {
sas;
say(*itr);
itr++;
}
sak;
}
}
template <class T> void salv(VV<T> v) {
if (v.emp)
sal();
else {
ROR(v, i) salv(i);
}
}
template <class T, class... Args> void salv(T v, Args... args) {
salv(v);
salv(args...);
}
template <class L, class R> auto Gcd(L l, R r) -> decltype(l + r) {
if (l < r)
swap(l, r);
return r ? Gcd(r, l % r) : l;
}
template <class L, class R> auto Lcm(L l, R r) {
if (!l || !r)
return 0;
return l / Gcd(l, r) * r;
}
/*
auto LES = mp(INF, lam(return l < r;));
auto GRT = mp(-INF, lam(return l > r;));
auto EQ = mp(0, lam(return l == r;));
auto ADD = mp(0, lam(return l + r;));
auto SUB = mp(0, lam(return l - r;));
auto MUL = mp(1, lam(return l * r;));
auto DIV = mp(1, lam(return l / r;));
auto MDL = mp(1, lam(return l % r;));
auto XOR = mp(0, lam(return l ^ r;));
auto OR = mp(0, lam(return l | r;));
auto AND = mp(((ll)(1) << 63) - 1, lam(return l & r;));
auto MIN = mp(INF, lam(return (l < r) ? l : r;));
auto MAX = mp(-INF, lam(return (l > r) ? l : r;));
auto GCD = mp(0, lam(return Gcd(l, r);));
auto LCM = mp(1, lam(return Lcm(l, r);));
*/
auto LES = mp(INF, lam(l < r));
auto GRT = mp(-INF, lam(l > r));
auto EQ = mp(0, lam(l == r));
auto ADD = mt(0, lam(l + r), lam(l - r));
auto MUL = mt(1, lam(l *r), lam(l / r));
auto XOR = mt(0, lam(l ^ r), lam(l ^ r));
auto OR = mg(0, lam(l | r));
auto AND = mg(((ll)(1) << 63) - 1, lam(l &r));
auto MIN = mg(0, lam((l < r) ? l : r));
auto MAX = mg(0, lam((l > r) ? l : r));
auto GCD = mg(0, lam(Gcd(l, r)));
auto LCM = mg(0, lam(Lcm(l, r)));
template <class OperationType> auto Operation(OperationType A) { return Id(A); }
template <class OperationType, class T> auto Operation(OperationType A, T x) {
return x;
}
template <class OperationType, class T, class... Args>
auto Operation(OperationType A, T x, Args... args) {
auto tmp = Operation(A, args...);
return Act(A)(x, tmp);
}
template <class OperationType> auto VOperation(OperationType A) {
return Id(A);
}
template <class OperationType, class T> auto VOperation(OperationType A, T x) {
return x;
}
template <class OperationType, class T>
auto VOperation(OperationType A, V<T> v) {
if (v.emp) {
decltype(GetVectorValueType(T())) tmp = Id(A);
return tmp;
}
auto tmp = VOperation(A, v[0]);
FOR(i, 1, v.sz - 1) tmp = Act(A)(tmp, VOperation(A, v[i]));
return tmp;
}
template <class OperationType, class T, class... Args>
auto VOperation(OperationType A, T x, Args... args) {
auto xResult = VOperation(A, x);
auto tmp = VOperation(A, args...);
return Act(A)(xResult, tmp);
}
ll Bset(ll a, ll b, ll c) {
if (c)
a |= b;
else
a &= ~b;
return a;
}
struct UFT {
public:
ll tsize;
ll mode;
vll par;
vll rank;
UFT(ll tsizeget, ll modeget = 0) {
tsize = tsizeget;
mode = modeget;
par.asn(tsize, -1);
if (!mode)
rank.res(tsize, 0);
}
ll root(ll x) { return par[x] < 0 ? x : par[x] = root(par[x]); }
bool isRoot(ll x) { return x == root(x); }
bool same(ll x, ll y) { return root(x) == root(y); }
void merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (mode) {
par[x] += par[y];
par[y] = x;
} else {
if (rank[x] < rank[y]) {
par[y] += par[x];
par[x] = y;
} else {
par[x] += par[y];
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
}
}
}
ll size(ll x) { return -par[root(x)]; }
};
template <class T> struct pUFT {
public:
ll tsize;
ll now;
vll par;
vll rank;
vll mtime;
vvll sizepi;
VV<T> sizepv;
V<T> elm;
GroupSet(T) Add;
pUFT(ll tsize, GroupSet(T) Add = ADD) : tsize(tsize), Add(Add) { init(); }
void init() {
now = 0;
par.asn(tsize, -1);
rank.asn(tsize, 0);
mtime.asn(tsize, INF);
sizepi.asn(tsize, {0});
sizepv.asn(tsize, {});
}
void set(ll x, T s) {
elm[x] = s;
sizepv[x] = {s};
}
ll root(ll x, ll t) { return (mtime[x] > t) ? x : root(par[x], t); }
bool same(ll x, ll y, ll t) { return root(x, t) == root(y, t); }
ll merge(ll x, ll y) {
now++;
x = root(x, now);
y = root(y, now);
if (x != y) {
if (rank[x] < rank[y]) {
elm[y] = Act(Add)(elm[x], elm[y]);
sizepi[y].pb(now);
sizepv[y].pb(elm[y]);
par[x] = y;
mtime[x] = now;
} else {
elm[x] = Act(Add)(elm[x], elm[y]);
sizepi[x].pb(now);
sizepv[x].pb(elm[x]);
par[y] = x;
mtime[y] = now;
if (rank[x] == rank[y])
rank[x]++;
}
}
return now;
}
T size(ll x, ll t) {
x = root(x, t);
return sizepv[x][UPB(sizepi[x], t) - 1];
}
};
struct wUFT {
public:
ll tsize;
ll mode;
vll par;
vll rank;
vll dweight;
wUFT(ll tsizeget, ll modeget = 0) {
tsize = tsizeget;
mode = modeget;
par.asn(tsize, -1);
if (!mode)
rank.res(tsize, 0);
dweight.asn(tsize, 0);
}
ll root(ll x) {
if (par[x] < 0)
return x;
else {
ll r = root(par[x]);
dweight[x] += dweight[par[x]];
return par[x] = r;
}
}
ll weight(ll x) {
root(x);
return dweight[x];
}
ll diff(ll x, ll y) { return weight(y) - weight(x); }
bool isRoot(ll x) { return x == root(x); }
bool same(ll x, ll y) { return root(x) == root(y); }
void merge(ll x, ll y, ll w) {
w += weight(x);
w -= weight(y);
x = root(x);
y = root(y);
if (x == y)
return;
if (mode) {
par[x] += par[y];
par[y] = x;
dweight[y] = w;
} else {
if (rank[x] < rank[y]) {
par[y] += par[x];
par[x] = y;
dweight[x] = -w;
} else {
par[x] += par[y];
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
dweight[y] = w;
}
}
}
ll size(ll x) { return -par[root(x)]; }
};
template <class T> struct sUFT {
public:
ll tsize;
ll mode;
vll par;
vll rank;
GroupSet(T) Add;
V<T> elm;
sUFT(ll tsize, GroupSet(T) Add = ADD, ll mode = 0)
: tsize(tsize), Add(Add), mode(mode) {
init();
}
void init() {
par.asn(tsize, -1);
if (!mode)
rank.res(tsize, 0);
elm.asn(tsize, Id(Add));
}
ll root(ll x) { return par[x] < 0 ? x : par[x] = root(par[x]); }
bool isRoot(ll x) { return x == root(x); }
bool same(ll x, ll y) { return root(x) == root(y); }
void merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (mode) {
elm[x] = Act(Add)(elm[x], elm[y]);
par[y] = x;
} else {
if (rank[x] < rank[y]) {
elm[y] = Act(Add)(elm[x], elm[y]);
par[x] = y;
} else {
elm[x] = Act(Add)(elm[x], elm[y]);
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
}
}
}
T size(ll x) { return elm[root(x)]; }
T &operator[](ll x) { return elm[x]; }
};
template <typename valtype> class SegT {
public:
ll size;
vector<valtype> v;
valtype initv;
function<valtype(valtype x, valtype y)> calc;
SegT() {}
SegT(const SegT &segt) {}
SegT(ll sizeget, ll modeget = 0) {
sizeset(sizeget);
modeset(modeget);
init();
}
SegT(vector<valtype> cpyvec, ll modeget = 0) {
sizeset(cpyvec.sz);
modeset(modeget);
init();
copy(cpyvec);
}
SegT(ll sizeget, valtype initvget,
function<valtype(valtype x, valtype y)> calcget) {
sizeset(sizeget);
initv = initvget;
calc = calcget;
init();
}
SegT(vector<valtype> cpyvec, valtype initvget,
function<valtype(valtype x, valtype y)> calcget) {
sizeset(cpyvec.sz);
initv = initvget;
calc = calcget;
init();
copy(cpyvec);
}
void sizeset(ll rsize) {
size = DigN2(rsize);
if (rsize == Pow2(size - 1))
size--;
return;
}
void modeset(ll mode) {
switch (mode) {
case 0:
initv = 0;
calc = [](valtype x, valtype y) { return x + y; };
break;
case 1:
initv = INF;
calc = [](valtype x, valtype y) { return min(x, y); };
break;
case 2:
initv = -INF;
calc = [](valtype x, valtype y) { return max(x, y); };
break;
}
return;
}
void init() { v.asn(Pow2(size + 1) - 1, initv); }
void copy(vector<valtype> cpyvec) {
REP(i, min(cpyvec.sz, Pow2(size))) set(i, cpyvec[i]);
}
ll i2v(ll i) const {
if (i < 0 || i >= Pow2(size))
return -1;
return Pow2(size) + i - 1;
}
ll top(ll i) const {
if (i == 0)
return -1;
return (i - 1) / 2;
}
pl bot(ll i) const {
if (i + 1 >= Pow2(size))
return mp(-1, -1);
return mp(2 * i + 1, 2 * i + 2);
}
void set(ll i, valtype x) {
i = i2v(i);
v[i] = x;
while (i > 0) {
i = top(i);
v[i] = calc(v[bot(i).fi], v[bot(i).se]);
}
return;
}
void add(ll i, valtype x) {
set(i, v[i2v(i)] + x);
return;
}
valtype operator[](const ll &i) const { return v[i2v(i)]; }
// valtype que(ll a = 0, ll b = Pow2(size) - 1) {
valtype que(ll a, ll b) {
if (a == b)
return v[i2v(a)];
if (a > b)
return initv; // swap(a, b);
valtype ans = initv;
ll ai = i2v(a);
ll bi = i2v(b);
FOR(i, 1, size + 1) {
if (a > b)
break;
if (a % Pow2(i)) {
ans = calc(ans, v[ai]);
a += Pow2(i - 1);
ai = top(ai) + 1;
} else {
ai = top(ai);
}
if (a > b)
break;
if ((b + 1) % Pow2(i)) {
ans = calc(ans, v[bi]);
b -= Pow2(i - 1);
bi = top(bi) - 1;
} else {
bi = top(bi);
}
if (a > b)
break;
}
return ans;
}
valtype que(ll b) { return que(0, b); }
valtype que() { return que(0, Pow2(size) - 1); }
};
/*template <class Type> class DP {
public:
vector<Type> v;
Type initv;
vll size, block;
DP() {}
DP(const DP &dp) {}
template<class... Args> DP(Args... args) {
block.asn(1, 1);
Initialize(args...);
}
void Initialize(Type initv_) {
initv = initv_;
v.asn(block.bk, initv);
}
template<class... Args> void Initialize(ll val, Args... args) {
size.pb(val);
block.pb(block.bk*val);
Initialize(args...);
}
};*/
pl Bezout(ll a, ll b) {
if (b != 0) {
pl xy;
xy = Bezout(b, a % b);
return mp(xy.se, xy.fi - ((a / b) * xy.se));
} else {
return mp(1, 0);
}
}
pl Bez(ll a, ll b, ll c) {
pl xy;
ll x, y, z, gc;
xy = Bezout(a, b);
gc = gcd(a, b);
if (c % gc != 0)
return mp(-1, -1);
x = xy.fi * (c / gc);
y = xy.se * (c / gc);
if (x < 0)
z = rup(-x, (b / gc));
if (x >= 0)
z = -x / (b / gc);
x += z * (b / gc);
y -= z * (a / gc);
return mp(x, y);
}
ll DigS10(ll n) {
ll ans = 0;
while (1) {
ans += n % 10;
n /= 10;
if (!n)
break;
}
return ans;
}
ll isP(ll n) {
if (n <= 1)
return 0;
FOR(i, 2, (ll)sqrt(n) + 1) {
if (n % i == 0)
return 0;
}
return 1;
}
ll Tot(ll n) {
if (n <= 0)
return 0;
ll ans = n, x = 2;
while (x * x <= n) {
if (n % x == 0) {
ans -= ans / x;
while (n % x == 0)
n /= x;
}
x++;
}
if (n > 1)
ans -= ans / n;
return ans;
}
template <class T> struct Graph {
public:
ll vSize;
ll eMode;
ll mapMode;
GroupSet(T) Add;
CompareSet(T) Less;
CompareSet(T) Equal;
VV<P<T, ll>> adj;
map<pl, T> len;
Graph(ll vSize, ll eMode = 0, ll mapMode = 0, GroupSet(T) Add = ADD,
CompareSet(T) Less = LES, CompareSet(T) Equal = EQ)
: vSize(vSize), eMode(eMode), mapMode(mapMode), Add(Add), Less(Less),
Equal(Equal) {}
void Init() { adj.asn(vSize, V<P<T, ll>>()); }
void AddE(ll x, ll y, T cost) {
iAddE(x, y, cost);
if (!eMode)
iAddE(y, x, cost);
}
void iAddE(ll x, ll y, T cost) {
adj[x].pb(mp(cost, y));
if (mapMode)
len[mp(x, y)] = cost;
}
P<bool, T> getE(ll x, ll y) {
if (!len.count(mp(x, y)))
return mp(false, Id(Less));
return mp(true, len[mp(x, y)]);
}
V<T> Dijk(ll x) {
V<T> ans(vSize, Id(Less));
if (x < 0 || x >= vSize)
return ans;
SegT<P<T, ll>> segt(vSize, mp(Id(Less), -1),
clamr(if (l.se < 0) return r; if (r.se < 0) return l;
return Act(Less)(l.fi, r.fi) ? l : r;));
segt.set(x, mp(Id(Add), x));
P<T, ll> now;
while ((now = segt.que(0, vSize - 1)).se >= 0) {
ans[now.se] = segt[now.se].fi;
segt.set(now.se, mp(Id(Less), -2));
ROR(adj[now.se], i) {
if (segt[i.se].se == -2)
continue;
if (segt[i.se].se == -1) {
segt.set(i.se, mp(Act(Add)(ans[now.se], i.fi), i.se));
continue;
}
if (Act(Less)(Act(Add)(ans[now.se], i.fi), segt[i.se].fi)) {
segt.set(i.se, mp(Act(Add)(ans[now.se], i.fi), i.se));
continue;
}
}
}
return ans;
}
V<P<T, vll>> rDijk(ll x) {
V<P<T, vll>> ans(vSize, mp(Id(Less), vll()));
if (x < 0 || x >= vSize)
return ans;
SegT<P<T, ll>> segt(vSize, mp(Id(Less), -1),
clamr(if (l.se < 0) return r; if (r.se < 0) return l;
return Act(Less)(l.fi, r.fi) ? l : r;));
segt.set(x, mp(Id(Add), x));
P<T, ll> now;
while ((now = segt.que(0, vSize - 1)).se >= 0) {
ans[now.se].fi = segt[now.se].fi;
segt.set(now.se, mp(Id(Less), -2));
ROR(adj[now.se], i) {
if (segt[i.se].se == -2)
continue;
if (segt[i.se].se == -1) {
segt.set(i.se, mp(Act(Add)(ans[now.se].fi, i.fi), i.se));
ans[i.se].se = {now.se};
continue;
}
if (Act(Less)(Act(Add)(ans[now.se].fi, i.fi), segt[i.se].fi)) {
segt.set(i.se, mp(Act(Add)(ans[now.se].fi, i.fi), i.se));
ans[i.se].se = {now.se};
continue;
}
if (Act(Equal)(Act(Add)(ans[now.se].fi, i.fi), segt[i.se].fi)) {
ans[i.se].se.pb(now.se);
continue;
}
}
}
return ans;
}
T Prim(ll x = 0) {
T ans = Id(Add);
if (x < 0 || x >= vSize)
return ans;
SegT<P<T, ll>> segt(vSize, mp(Id(Less), -1),
clamr(if (l.se < 0) return r; if (r.se < 0) return l;
return Act(Less)(l.fi, r.fi) ? l : r;));
segt.set(x, mp(Id(Add), x));
P<T, ll> now;
while ((now = segt.que(0, vSize - 1)).se >= 0) {
ans = Act(Add)(ans, segt[now.se].fi);
segt.set(now.se, mp(Id(Less), -2));
ROR(adj[now.se], i) {
if (segt[i.se].se == -2)
continue;
if (segt[i.se].se == -1) {
segt.set(i.se, i);
continue;
}
if (Act(Less)(i.fi, segt[i.se].fi)) {
segt.set(i.se, i);
continue;
}
}
}
return ans;
}
P<T, V<P<T, vll>>> rPrim(ll x = 0) {
P<T, V<P<T, vll>>> ans =
mp(Id(Add), V<P<T, vll>>(vSize, mp(Id(Less), vll())));
if (x < 0 || x >= vSize)
return ans;
SegT<P<T, ll>> segt(vSize, mp(Id(Less), -1),
clamr(if (l.se < 0) return r; if (r.se < 0) return l;
return Act(Less)(l.fi, r.fi) ? l : r;));
segt.set(x, mp(Id(Add), x));
P<T, ll> now;
while ((now = segt.que(0, vSize - 1)).se >= 0) {
ans.se[now.se].fi = segt[now.se].fi;
ans.fi = Act(Add)(ans.fi, ans.se[now.se].fi);
segt.set(now.se, mp(Id(Less), -2));
ROR(adj[now.se], i) {
if (segt[i.se].se == -2)
continue;
if (segt[i.se].se == -1) {
segt.set(i.se, i);
ans.se[i.se].se = {now.se};
continue;
}
if (Act(Less)(i.fi, segt[i.se].fi)) {
segt.set(i.se, i);
ans.se[i.se].se = {now.se};
continue;
}
if (Act(Equal)(i.fi, segt[i.se].fi)) {
ans.se[i.se].se.pb(now.se);
continue;
}
}
}
return ans;
}
};
template <class T> struct Sum {
public:
V<T> v, s;
ll size;
GroupSet(T) Add;
Sum(V<T> v, GroupSet(T) Add = ADD) : v(v), size(v.sz), Add(Add) {
Init();
Calc();
}
void Init() { s.asn(size + 1, Id(Add)); }
void Calc() { REP(i, size) s[i + 1] = Act(Add)(s[i], v[i]); }
T operator()(ll x) {
if (x < -1)
x = -1;
if (x > size - 1)
x = size - 1;
return s[x + 1];
}
T operator()(ll l, ll r) {
if (l < 0)
l = 0;
if (r >= size)
r = size - 1;
if (l > r)
return Id(Add);
return InvAct(Add)(s[r + 1], s[l]);
}
};
using sumll = Sum<ll>;
template <class T> struct Sum2 {
public:
VV<T> v, s;
ll RowSize, ColumnSize;
GroupSet(T) Add;
Sum2(VV<T> v, GroupSet(T) Add = ADD)
: v(v), RowSize(v.sz), ColumnSize(v.sz ? v[0].sz : 0), Add(Add) {
Init();
Calc();
}
void Init() { s.asn(RowSize + 1, V<T>(ColumnSize + 1, Id(Add))); }
void Calc() {
REP1(r, RowSize) {
REP1(c, ColumnSize) {
// s[r][c] = InvAct(Add)(Act(Add)(Act(Add)(v[r -
//1][c - 1], operator()(r - 1, c - 2)), operator()(r - 2, c - 1)),
//operator()(r - 2, c - 2));
s[r][c] = Act(Add)(s[r][c - 1], v[r - 1][c - 1]);
}
}
REP1(r, RowSize) {
REP1(c, ColumnSize) { s[r][c] = Act(Add)(s[r - 1][c], s[r][c]); }
}
}
T operator()(ll r, ll c) {
if (r < -1)
r = -1;
if (c < -1)
c = -1;
if (r > RowSize - 1)
r = RowSize - 1;
if (c > ColumnSize - 1)
c = ColumnSize - 1;
return s[r + 1][c + 1];
}
T operator()(ll r1, ll c1, ll r2, ll c2) {
if (r1 < 0)
r1 = 0;
if (c1 < 0)
c1 = 0;
if (r2 >= RowSize)
r2 = RowSize - 1;
if (c2 >= ColumnSize)
c2 = ColumnSize - 1;
if (r1 > r2)
return Id(Add);
if (c1 > c2)
return Id(Add);
return InvAct(Add)(Act(Add)(s[r2 + 1][c2 + 1], s[r1][c1]),
Act(Add)(s[r2 + 1][c1], s[r1][c2 + 1]));
}
};
using sumll2 = Sum2<ll>;
template <class T> struct Point2 {
public:
VV<T> v;
ll h, w;
Point2() : h(0), w(0) {}
Point2(ll h, ll w) : h(h), w(w) { asn(h, w); }
Point2(ll h, ll w, T val) : h(h), w(w) { asn(h, w, val); }
Point2(VV<T> cv) : h(cv.sz), w(cv.sz ? cv[0].sz : 0) {
asn(h, w);
copy(cv);
}
void assign(ll h, ll w) { v.asn(h, V<T>(w)); }
void assign(ll h, ll w, ll val) { v.asn(h, V<T>(w, val)); }
void copy(VV<T> cv) { REP(_h, h) REP(_w, w) v[_h][_w] = cv[_h][_w]; }
T &operator()(ll h, ll w) { return v[h][w]; }
T &operator()(pl p) { return v[p.fi][p.se]; }
T &operator[](pl p) { return v[p.fi][p.se]; }
};
template <class T> using P2 = Point2<T>;
template <ll Mod> struct Modll {
public:
ll v;
Modll() : v(0) {}
Modll(ll _v) { set(_v % Mod + Mod); }
Modll &set(ll _v) {
v = (_v < Mod) ? _v : (_v - Mod);
return *this;
}
Modll pow(ll n) const {
Modll x = *this, ans = 1;
while (n) {
if (n & 1)
ans *= x;
x *= x;
n >>= 1;
}
return ans;
}
Modll inverse() const { return (*this).pow(Mod - 2); }
Modll operator+(const Modll &m) const { return Modll().set(v + m.v); }
Modll operator-(const Modll &m) const { return Modll().set(Mod + v - m.v); }
Modll operator*(const Modll &m) const {
return Modll().set((ull(v) * m.v) % Mod);
}
Modll operator/(const Modll &m) const { return *this * m.inv; }
Modll &operator+=(const Modll &m) { return *this = *this + m; }
Modll &operator-=(const Modll &m) { return *this = *this - m; }
Modll &operator*=(const Modll &m) { return *this = *this * m; }
Modll &operator/=(const Modll &m) { return *this = *this / m; }
Modll operator-() const { return Modll(0) - *this; }
explicit operator bool() const { return v != 0; }
friend istream &operator>>(istream &in, Modll &m) { return in >> m.v; }
friend ostream &operator<<(ostream &out, const Modll &m) {
return out << m.v;
}
};
using mll = Modll<MOD>;
using vmll = V<mll>;
using vvmll = V<vmll>;
using vvvmll = V<vvmll>;
vmll MFactMemo(2, 1);
vmll MIFactMemo(2, 1);
mll mFact(ll n) {
if (MFactMemo.sz <= n) {
ll oldsize = MFactMemo.sz;
MFactMemo.res(n + 1, 1);
FOR(i, oldsize, n) MFactMemo[i] = MFactMemo[i - 1] * i;
}
return MFactMemo[n];
}
mll miFact(ll n) {
if (MIFactMemo.sz <= n) {
ll oldsize = MIFactMemo.sz;
MIFactMemo.res(n + 1, 1);
MIFactMemo.bk = mFact(n).inv;
rFOR(i, oldsize + 1, n) MIFactMemo[i - 1] = MIFactMemo[i] * i;
}
return MIFactMemo[n];
}
mll mComb(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
return mFact(n) * miFact(k) * miFact(n - k);
}
ll LIS(vll v, ll m = 0) {
if (v.sz > 0) {
ll ans = 0;
vll dp(v.sz, INF);
FOR(i, 0, v.sz - 1) { dp[m ? UPB(dp, v[i]) : LOWB(dp, v[i])] = v[i]; }
FOR(i, 0, v.sz - 1) {
if (dp[i] == INF)
break;
ans++;
}
return ans;
} else {
return 0;
}
}
ll Bsrch(function<bool(ll x)> f, ll mi, ll ma) {
ll ng = mi - 1, ok = ma, mid;
while (ok - ng > 1) {
mid = (ng + ok) / 2;
(f(mid) ? ok : ng) = mid;
}
return ok;
}
template <class T, class M = decltype(MUL), class S = decltype(ADD)>
VV<T> MultiMatrix(VV<T> A, VV<T> B, M Mul = MUL, S Add = ADD) {
VV<T> ans;
ll ii = A.sz;
if (!ii)
return ans;
ll jj = A[0].sz;
if (!jj)
return ans;
ll jj2 = B.sz;
if (!jj2)
return ans;
if (jj != jj2)
return ans;
ll kk = B[0].sz;
if (!kk)
return ans;
ans.asn(ii, V<T>(kk, 0));
REP(i, ii) {
REP(k, kk) {
REP(j, jj) {
ans[i][k] = Act(Add)(ans[i][k], Act(Mul)(A[i][j], B[j][k]));
}
}
}
return ans;
}
vvll CombMemo(1000, vll(1000, -1));
ll Comb(ll n, ll k) {
if ((n < 0) || (k < 0))
return 0;
if (CombMemo[n][k] == -1) {
if (n < k)
CombMemo[n][k] = 0;
else {
if (n == 0)
CombMemo[n][k] = 1;
else if (k == 0)
CombMemo[n][k] = 1;
else if (n == k)
CombMemo[n][k] = 1;
else
CombMemo[n][k] = Comb(n - 1, k - 1) + Comb(n - 1, k);
}
}
return CombMemo[n][k];
}
template <class T> map<T, ll> Dict(V<T> v) {
map<T, ll> m;
if (!v.sz)
return m;
SORT(v);
UNIQUE(v);
REP(i, v.sz) { m[v[i]] = i; }
return m;
}
template <class T> vll Cmprs(V<T> v) {
auto m = Dict(v);
vll ans(v.sz);
REP(i, v.sz) { ans[i] = m[v[i]]; }
return ans;
}
template <class T> vll PCmprs(V<T> v) {
if (v.sz == 0)
return V<T>();
vll tmp(v.sz);
vll ans(v.sz);
IOTA(tmp, 0);
IOTA(ans, 0);
sort(tmp.bgn, tmp.en, clam(v[l] < v[r]));
sort(ans.bgn, ans.en, clam(tmp[l] < tmp[r]));
return ans;
}
ll BblCnt(vll rv) {
vll v = PCmprs(rv);
SegT<ll> b(v.sz, 0);
ll ans = 0;
REP(i, v.sz) {
ans += (i - b.que(0, v[i]));
b.add(v[i], 1);
}
return ans;
}
pl NGrid(pl p, ll i, ll H, ll W) {
p = mp(p.fi + DX[i], p.se + DY[i]);
if (p.fi < 0 || p.fi >= H || p.se < 0 || p.se >= W)
return mp(INF, INF);
return p;
}
vvll llGrid(vs v) {
vvll r(v.sz, vll(v.sz ? v[0].sz : 0, 0));
REP(h, v.sz) REP(w, v.sz ? v[0].sz : 0) r[h][w] = (v[h][w] == '#');
return r;
}
template <class T> auto ven(T val) { return val; }
template <> auto ven<int>(int val) { return (ll)val; }
template <class T, class... Args> auto ven(T val, Args... args) {
auto tmp = ven(args...);
return V<decltype(tmp)>(val, tmp);
}
template <class T> void zind(T &v) { v--; }
template <class T> void zind(V<T> &v) { ROR(v, i) zind(i); }
template <class T, class... Args> void zind(T &v, Args &...args) {
zind(v);
zind(args...);
}
template <class S, class T> void SORTby(V<S> &i, const V<T> &x) {
sort(i.bgn, i.en, clam(x[l] < x[r]));
}
template <class S, class T> void rSORTby(V<S> &i, const V<T> &x) {
sort(i.bgn, i.en, clam(x[l] > x[r]));
}
template <typename Monoid, typename OperatorMonoid = Monoid>
struct LazySegmentTree {
using F = function<Monoid(Monoid, Monoid)>;
using G = function<Monoid(Monoid, OperatorMonoid)>;
using H = function<OperatorMonoid(OperatorMonoid, OperatorMonoid)>;
using P = function<OperatorMonoid(OperatorMonoid, ll)>;
ll size;
vector<Monoid> data;
vector<OperatorMonoid> lazy;
const F f;
const G g;
const H h;
const P p;
const Monoid M1;
const OperatorMonoid OM0;
LazySegmentTree(ll n, const F f, const G g, const H h, const P p,
const Monoid &M1, const OperatorMonoid OM0)
: f(f), g(g), h(h), p(p), M1(M1), OM0(OM0) {
size = 1;
while (size < n)
size <<= 1;
data.assign(2 * size, M1);
lazy.assign(2 * size, OM0);
}
void set(ll k, const Monoid &x) { data[k + size] = x; }
void build() {
for (ll k = size - 1; k > 0; k--) {
data[k] = f(data[2 * k + 0], data[2 * k + 1]);
}
}
void propagate(ll k, ll len) {
if (lazy[k] != OM0) {
if (k < size) {
lazy[2 * k + 0] = h(lazy[2 * k + 0], lazy[k]);
lazy[2 * k + 1] = h(lazy[2 * k + 1], lazy[k]);
}
data[k] = g(data[k], p(lazy[k], len));
lazy[k] = OM0;
}
}
Monoid update(ll a, ll b, const OperatorMonoid &x, ll k, ll l, ll r) {
propagate(k, r - l);
if (r <= a || b <= l) {
return data[k];
} else if (a <= l && r <= b) {
lazy[k] = h(lazy[k], x);
propagate(k, r - l);
return data[k];
} else {
return data[k] = f(update(a, b, x, 2 * k + 0, l, (l + r) >> 1),
update(a, b, x, 2 * k + 1, (l + r) >> 1, r));
}
}
Monoid update(ll a, ll b, const OperatorMonoid &x) {
return update(a, b, x, 1, 0, size);
}
Monoid query(ll a, ll b, ll k, ll l, ll r) {
propagate(k, r - l);
if (r <= a || b <= l) {
return M1;
} else if (a <= l && r <= b) {
return data[k];
} else {
return f(query(a, b, 2 * k + 0, l, (l + r) >> 1),
query(a, b, 2 * k + 1, (l + r) >> 1, r));
}
}
Monoid query(ll a, ll b) { return query(a, b, 1, 0, size); }
Monoid operator[](const ll &k) { return query(k, k + 1); }
};
void Solve();
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(20) << fixed;
Solve();
}
// index_sort
void Solve() {
li(N);
vli(5, A);
SORT(A);
sal(5 + N / A[0]);
} | #include <bits/stdc++.h>
using namespace std;
template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;
template <class T> using VVV = V<VV<T>>;
template <class S, class T> using P = pair<S, T>;
template <class... T> using TP = tuple<T...>;
using ll = long long;
using ull = unsigned long long;
using dbl = double;
using str = string;
using vll = V<ll>;
using vvll = V<vll>;
using vvvll = V<vvll>;
using pl = P<ll, ll>;
using tl = TP<ll, ll, ll>;
using vpl = V<pl>;
using vvpl = V<vpl>;
using vtl = V<tl>;
using vvtl = V<vtl>;
using vs = V<str>;
using vvs = V<vs>;
using vd = V<dbl>;
using vvd = V<vd>;
using vvvd = V<vvd>;
using qll = queue<ll>;
using qpl = queue<pl>;
using stll = stack<ll>;
using stpl = stack<pl>;
using mapll = map<ll, ll>;
using setll = set<ll>;
using pqll = priority_queue<ll>;
//#define int ll
#define fi first
#define se second
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define pob pop_back()
#define pf push_front
#define pof pop_front()
#define sz size()
#define bgn begin()
#define en end()
#define asn assign
#define emp empty()
#define fr front()
#define bk back()
#define clr clear()
#define ins insert
#define ers erase
#define res resize
#define tp top()
#define p_q priority_queue
#define inv inverse()
#define FOR(i, a, b) for (ll i = (a); i <= (ll)(b); i++)
#define rFOR(i, a, b) for (ll i = (b); i >= (ll)(a); i--)
#define REP(i, a) FOR((i), 0, (ll)(a)-1)
#define REP0(i, a) FOR((i), 0, (ll)(a))
#define REP1(i, a) FOR((i), 1, (ll)(a))
#define rREP(i, a) rFOR((i), 0, (ll)(a)-1)
#define rREP0(i, a) rFOR((i), 0, (ll)(a))
#define rREP1(i, a) rFOR((i), 1, (ll)(a))
#define ROR(v, i) for (auto &(i) : (v))
#define IOTA(a, n) iota((a).bgn, (a).en, (n))
#define SORT(a) sort((a).bgn, (a).en)
#define rSORT(a) sort((a).rbegin(), (a).rend())
#define UNIQUE(a) (a).erase(unique((a).bgn, (a).en), (a).en)
#define PREVP(a) prev_permutation((a).bgn, (a).en)
#define NEXTP(a) next_permutation((a).bgn, (a).en)
#define BINS(a, b) binary_search((a).bgn, (a).en, (b))
#define LOWB(a, b) (lower_bound((a).bgn, (a).en, (b)) - (a).bgn)
#define UPB(a, b) (upper_bound((a).bgn, (a).en, (b)) - (a).bgn)
#define CNT(a, b) count((a).bgn, (a).en, b)
#define SUM(a) accumulate((a).bgn, (a).en, 0)
#define REV(a) reverse((a).bgn, (a).en)
#define REGS(a, b) regex_search((a), regex(b))
#define REGM(a, b) regex_match((a), regex(b))
#define yn(a) cout << ((a) ? "yes" : "no") << "\n";
#define Yn(a) cout << ((a) ? "Yes" : "No") << "\n";
#define YN(a) cout << ((a) ? "YES" : "NO") << "\n";
#define imp(a) cout << ((a) ? "possible" : "impossible") << "\n";
#define Imp(a) cout << ((a) ? "Possible" : "Impossible") << "\n";
#define IMP(a) cout << ((a) ? "POSSIBLE" : "IMPOSSIBLE") << "\n";
#define fs(a) cout << ((a) ? "second" : "first") << "\n";
#define Fs(a) cout << ((a) ? "Second" : "First") << "\n";
#define FS(a) cout << ((a) ? "SECOND" : "FIRST") << "\n";
//#define say(a) cout <<(a);
//#define sal(a) cout <<(a)<<"\n";
#define sak cout << "\n";
#define sas cout << " ";
#define sat cout << "\t";
#define dbg(a) cerr << (#a) << ": " << (a) << "\n";
#define dbgs(...) \
dal(#__VA_ARGS__); \
dal(__VA_ARGS__);
#define c2l(a) ((ll)(a - 48))
#define a2l(a) ((ll)(a - 97))
#define A2l(a) ((ll)(a - 65))
#define l2c(a) ((char)(a + 48))
#define l2a(a) ((char)(a + 97))
#define l2A(a) ((char)(a + 65))
#define DigN2(a) ((llabs(a) == 0) ? (1) : ((ll)(log2(double(llabs(a)))) + 1))
#define DigN10(a) ((llabs(a) == 0) ? (1) : ((ll)(log10(double(llabs(a)))) + 1))
#define Dig2(a, b) (((a) >> (b)) & 1)
#define Dig10(a, b) (ll)(((a) / ((ll)(pow(10.0, (double)(b))))) % 10)
#define Pow2(a) ((ll)(1) << (a))
#define Pow10(a) ((ll)(pow(10.0, double(a))))
#define LSB(a) ((a) & (-(a)))
/*#define llin(a) ll (a);cin >>(a);
#define llin2(a,b) ll (a),(b);cin >>(a)>>(b);
#define llin3(a,b,c) ll (a),(b),(c);cin >>(a)>>(b)>>(c);
#define stin(a) string (a);cin >>(a);*/
#define vin(v) \
ROR((v), (i)) { cin >> (i); };
#define vllin(N, v) \
vll(v)((N)); \
vin(v);
#define vllin2(N, a, b) \
vll(a)(N), (b)(N); \
REP(i, N) { cin >> (a)[i] >> (b)[i]; };
#define vsin(N, v) \
vs(v)((N)); \
vin(v);
#define rdn(a, b) ((a) / (b))
#define rou(a, b) \
((((double(a) / double(b)) - ((a) / (b))) < 0.5) ? ((a) / (b)) \
: (((a) / (b)) + 1))
#define rup(a, b) ((((a) % (b)) == 0) ? ((a) / (b)) : (((a) / (b)) + 1))
#define powll(a, b) (ll)(pow((double)(a), (double)(b)))
#define Triangle(x1, y1, x2, y2, x3, y3) \
(((x1) - (x2)) * ((y1) - (y3)) - ((x1) - (x3)) * ((y1) - (y2)))
#define tg(t, i) get<i>(t)
#define Id(x) get<0>(x)
#define Act(x) get<1>(x)
#define InvAct(x) get<2>(x)
#define mg(id, act) mt(id, act, lam(l))
//#define MonoidSet(T) TP<T, function<T(T, T)>>
#define GroupSet(T) TP<T, function<T(T, T)>, function<T(T, T)>>
#define CompareSet(T) TP<T, function<bool(T, T)>>
#define lam(lr) ([](auto l, auto r) { return (lr); })
#define elam(lr) ([=](auto l, auto r) { return (lr); })
#define clam(lr) ([&](auto l, auto r) { return (lr); })
#define lamr(lr) ([](auto l, auto r) { lr })
#define elamr(lr) ([=](auto l, auto r) { lr })
#define clamr(lr) ([&](auto l, auto r) { lr })
#define min(...) Operation(MIN, __VA_ARGS__)
#define max(...) Operation(MAX, __VA_ARGS__)
#define gcd(...) Operation(GCD, __VA_ARGS__)
#define lcm(...) Operation(LCM, __VA_ARGS__)
#define vmin(...) VOperation(MIN, __VA_ARGS__)
#define vmax(...) VOperation(MAX, __VA_ARGS__)
#define vgcd(...) VOperation(GCD, __VA_ARGS__)
#define vlcm(...) VOperation(LCM, __VA_ARGS__)
#define vsum(...) VOperation(ADD, __VA_ARGS__)
#define vpro(...) VOperation(MUL, __VA_ARGS__)
#define emin(a, ...) ((a) = min((a), __VA_ARGS__))
#define emax(a, ...) ((a) = max((a), __VA_ARGS__))
#define egcd(a, ...) ((a) = gcd((a), __VA_ARGS__))
#define elcm(a, ...) ((a) = lcm((a), __VA_ARGS__))
#define ope Operation
#define vope VOperation
#define svll SumV<ll>
#define svvll SumV2<ll>
#define li(...) \
ll __VA_ARGS__; \
Input(__VA_ARGS__);
#define si(...) \
str __VA_ARGS__; \
Input(__VA_ARGS__);
//#define vli(size, ...) vll __VA_ARGS__;vInitInput(size,__VA_ARGS__);
#define vlr(size, ...) \
vll __VA_ARGS__; \
vInitInputR(size, __VA_ARGS__);
#define vlc(size, ...) \
vll __VA_ARGS__; \
vInitInputC(size, __VA_ARGS__);
#define vli(size, ...) \
vll __VA_ARGS__; \
vInitInputR(size, __VA_ARGS__);
#define vsr(size, ...) \
vs __VA_ARGS__; \
vInitInputR(size, __VA_ARGS__);
#define vsc(size, ...) \
vs __VA_ARGS__; \
vInitInputC(size, __VA_ARGS__);
#define vsi(size, ...) \
vs __VA_ARGS__; \
vInitInputR(size, __VA_ARGS__);
#define vli2(rowSize, columnSize, ...) \
vvll __VA_ARGS__; \
vInitInput2(rowSize, columnSize, __VA_ARGS__);
#define vplr(size, ...) \
vpl __VA_ARGS__; \
vInitInputR(size, __VA_ARGS__);
#define vplc(size, ...) \
vpl __VA_ARGS__; \
vInitInputC(size, __VA_ARGS__);
#define vpli(size, ...) \
vpl __VA_ARGS__; \
vInitInputR(size, __VA_ARGS__);
const ll MOD = 1e9 + 7;
// const ll MOD = 998244353;
// const ll MOD = 924844033;
// const ll MOD = 9007199254740881;
const ll INF = 1LL << 60; // 1.15e18
const double PI = acos(-1.0);
const vll DX = {0, -1, 0, 1, 0, -1, 1, 1, -1};
const vll DY = {0, 0, -1, 0, 1, -1, -1, 1, 1};
const str alp = "abcdefghijklmnopqrstuvwxyz";
const str ALP = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
template <class T> auto GetVectorValueType(T v) { return v; }
template <class T> auto GetVectorValueType(V<T> v) {
return GetVectorValueType(T());
}
template <class S, class T> istream &operator>>(istream &in, P<S, T> &p) {
return in >> p.fi >> p.se;
}
template <class T> istream &operator>>(istream &in, V<T> &v) {
REP(i, v.sz) in >> v[i];
return in;
}
void Input() {}
template <class Var, class... Args> void Input(Var &var, Args &...args) {
cin >> var;
Input(args...);
}
void vInit(ll size) {}
template <class T, class... Args> void vInit(ll size, V<T> &v, Args &...args) {
v.res(size);
vInit(size, args...);
}
void vInput(ll size) {}
template <class T, class... Args> void vInput(ll size, V<T> &v, Args &...args) {
REP(i, size) cin >> v[i];
vInput(size, args...);
}
void vInputR(ll size) {}
template <class T, class... Args>
void vInputR(ll size, V<T> &v, Args &...args) {
REP(i, size) cin >> v[i];
vInputR(size, args...);
}
void vInputNumC(ll num) {}
template <class T, class... Args>
void vInputNumC(ll num, V<T> &v, Args &...args) {
cin >> v[num];
vInputNumC(num, args...);
}
void vInputC(ll size) {}
template <class... Args> void vInputC(ll size, Args &...args) {
REP(i, size) vInputNumC(i, args...);
}
void vInitInputR(ll size) {}
template <class... Args> void vInitInputR(ll size, Args &...args) {
vInit(size, args...);
vInputR(size, args...);
}
void vInitInputC(ll size) {}
template <class... Args> void vInitInputC(ll size, Args &...args) {
vInit(size, args...);
vInputC(size, args...);
}
void vInit2(ll rowSize, ll columnSize) {}
template <class T, class... Args>
void vInit2(ll rowSize, ll columnSize, VV<T> &v, Args &...args) {
v.asn(rowSize, V<T>(columnSize));
vInit2(rowSize, columnSize, args...);
}
void vInput2(ll rowSize, ll columnSize) {}
template <class T, class... Args>
void vInput2(ll rowSize, ll columnSize, VV<T> &v, Args &...args) {
REP(r, rowSize) {
REP(c, columnSize) { cin >> v[r][c]; }
}
vInput2(rowSize, columnSize, args...);
}
void vInitInput2(ll rowSize, ll columnSize) {}
template <class... Args>
void vInitInput2(ll rowSize, ll columnSize, Args &...args) {
vInit2(rowSize, columnSize, args...);
vInput2(rowSize, columnSize, args...);
}
template <class S, class T>
ostream &operator<<(ostream &out, const P<S, T> &p) {
return out << "[" << p.fi << ", " << p.se << "]";
}
template <class T> ostream &operator<<(ostream &out, V<T> &v) {
if (v.emp)
return out << "{}";
else {
auto itr = v.bgn;
out << "{" << *itr;
itr++;
while (itr != v.en) {
out << ", " << *itr;
itr++;
}
out << "}";
return out;
}
}
template <class S, class T>
ostream &operator<<(ostream &out, const map<S, T> &m) {
if (m.emp)
return out << "<[]>";
else {
auto itr = m.bgn;
out << "< [" << (itr->fi) << ": " << (itr->se);
itr++;
while (itr != m.en) {
out << "], [" << (itr->fi) << ": " << (itr->se);
itr++;
}
out << "] >";
return out;
}
}
template <class T> ostream &operator<<(ostream &out, const set<T> &s) {
if (s.emp)
return out << "<>";
else {
auto itr = s.bgn;
out << "<" << *itr;
itr++;
while (itr != s.en) {
out << ", " << *itr;
itr++;
}
out << ">";
return out;
}
}
void say() {}
template <class T> void say(T t) { cout << t; }
template <class Head, class... Body> void say(Head head, Body... body) {
cout << head << " ";
say(body...);
}
void sal() { cout << "\n"; }
template <class... Args> void sal(Args... args) {
say(args...);
cout << "\n";
}
void day() {}
template <class T> void day(T t) { cerr << t; }
template <class Head, class... Body> void day(Head head, Body... body) {
cerr << head << " ";
day(body...);
}
void dal() { cerr << "\n"; }
template <class... Args> void dal(Args... args) {
day(args...);
cerr << "\n";
}
void salv() {}
template <class T> void salv(V<T> v) {
if (v.emp)
sal();
else {
auto itr = v.bgn;
say(*itr);
itr++;
while (itr != v.en) {
sas;
say(*itr);
itr++;
}
sak;
}
}
template <class T> void salv(VV<T> v) {
if (v.emp)
sal();
else {
ROR(v, i) salv(i);
}
}
template <class T, class... Args> void salv(T v, Args... args) {
salv(v);
salv(args...);
}
template <class L, class R> auto Gcd(L l, R r) -> decltype(l + r) {
if (l < r)
swap(l, r);
return r ? Gcd(r, l % r) : l;
}
template <class L, class R> auto Lcm(L l, R r) {
if (!l || !r)
return 0;
return l / Gcd(l, r) * r;
}
/*
auto LES = mp(INF, lam(return l < r;));
auto GRT = mp(-INF, lam(return l > r;));
auto EQ = mp(0, lam(return l == r;));
auto ADD = mp(0, lam(return l + r;));
auto SUB = mp(0, lam(return l - r;));
auto MUL = mp(1, lam(return l * r;));
auto DIV = mp(1, lam(return l / r;));
auto MDL = mp(1, lam(return l % r;));
auto XOR = mp(0, lam(return l ^ r;));
auto OR = mp(0, lam(return l | r;));
auto AND = mp(((ll)(1) << 63) - 1, lam(return l & r;));
auto MIN = mp(INF, lam(return (l < r) ? l : r;));
auto MAX = mp(-INF, lam(return (l > r) ? l : r;));
auto GCD = mp(0, lam(return Gcd(l, r);));
auto LCM = mp(1, lam(return Lcm(l, r);));
*/
auto LES = mp(INF, lam(l < r));
auto GRT = mp(-INF, lam(l > r));
auto EQ = mp(0, lam(l == r));
auto ADD = mt(0, lam(l + r), lam(l - r));
auto MUL = mt(1, lam(l *r), lam(l / r));
auto XOR = mt(0, lam(l ^ r), lam(l ^ r));
auto OR = mg(0, lam(l | r));
auto AND = mg(((ll)(1) << 63) - 1, lam(l &r));
auto MIN = mg(0, lam((l < r) ? l : r));
auto MAX = mg(0, lam((l > r) ? l : r));
auto GCD = mg(0, lam(Gcd(l, r)));
auto LCM = mg(0, lam(Lcm(l, r)));
template <class OperationType> auto Operation(OperationType A) { return Id(A); }
template <class OperationType, class T> auto Operation(OperationType A, T x) {
return x;
}
template <class OperationType, class T, class... Args>
auto Operation(OperationType A, T x, Args... args) {
auto tmp = Operation(A, args...);
return Act(A)(x, tmp);
}
template <class OperationType> auto VOperation(OperationType A) {
return Id(A);
}
template <class OperationType, class T> auto VOperation(OperationType A, T x) {
return x;
}
template <class OperationType, class T>
auto VOperation(OperationType A, V<T> v) {
if (v.emp) {
decltype(GetVectorValueType(T())) tmp = Id(A);
return tmp;
}
auto tmp = VOperation(A, v[0]);
FOR(i, 1, v.sz - 1) tmp = Act(A)(tmp, VOperation(A, v[i]));
return tmp;
}
template <class OperationType, class T, class... Args>
auto VOperation(OperationType A, T x, Args... args) {
auto xResult = VOperation(A, x);
auto tmp = VOperation(A, args...);
return Act(A)(xResult, tmp);
}
ll Bset(ll a, ll b, ll c) {
if (c)
a |= b;
else
a &= ~b;
return a;
}
struct UFT {
public:
ll tsize;
ll mode;
vll par;
vll rank;
UFT(ll tsizeget, ll modeget = 0) {
tsize = tsizeget;
mode = modeget;
par.asn(tsize, -1);
if (!mode)
rank.res(tsize, 0);
}
ll root(ll x) { return par[x] < 0 ? x : par[x] = root(par[x]); }
bool isRoot(ll x) { return x == root(x); }
bool same(ll x, ll y) { return root(x) == root(y); }
void merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (mode) {
par[x] += par[y];
par[y] = x;
} else {
if (rank[x] < rank[y]) {
par[y] += par[x];
par[x] = y;
} else {
par[x] += par[y];
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
}
}
}
ll size(ll x) { return -par[root(x)]; }
};
template <class T> struct pUFT {
public:
ll tsize;
ll now;
vll par;
vll rank;
vll mtime;
vvll sizepi;
VV<T> sizepv;
V<T> elm;
GroupSet(T) Add;
pUFT(ll tsize, GroupSet(T) Add = ADD) : tsize(tsize), Add(Add) { init(); }
void init() {
now = 0;
par.asn(tsize, -1);
rank.asn(tsize, 0);
mtime.asn(tsize, INF);
sizepi.asn(tsize, {0});
sizepv.asn(tsize, {});
}
void set(ll x, T s) {
elm[x] = s;
sizepv[x] = {s};
}
ll root(ll x, ll t) { return (mtime[x] > t) ? x : root(par[x], t); }
bool same(ll x, ll y, ll t) { return root(x, t) == root(y, t); }
ll merge(ll x, ll y) {
now++;
x = root(x, now);
y = root(y, now);
if (x != y) {
if (rank[x] < rank[y]) {
elm[y] = Act(Add)(elm[x], elm[y]);
sizepi[y].pb(now);
sizepv[y].pb(elm[y]);
par[x] = y;
mtime[x] = now;
} else {
elm[x] = Act(Add)(elm[x], elm[y]);
sizepi[x].pb(now);
sizepv[x].pb(elm[x]);
par[y] = x;
mtime[y] = now;
if (rank[x] == rank[y])
rank[x]++;
}
}
return now;
}
T size(ll x, ll t) {
x = root(x, t);
return sizepv[x][UPB(sizepi[x], t) - 1];
}
};
struct wUFT {
public:
ll tsize;
ll mode;
vll par;
vll rank;
vll dweight;
wUFT(ll tsizeget, ll modeget = 0) {
tsize = tsizeget;
mode = modeget;
par.asn(tsize, -1);
if (!mode)
rank.res(tsize, 0);
dweight.asn(tsize, 0);
}
ll root(ll x) {
if (par[x] < 0)
return x;
else {
ll r = root(par[x]);
dweight[x] += dweight[par[x]];
return par[x] = r;
}
}
ll weight(ll x) {
root(x);
return dweight[x];
}
ll diff(ll x, ll y) { return weight(y) - weight(x); }
bool isRoot(ll x) { return x == root(x); }
bool same(ll x, ll y) { return root(x) == root(y); }
void merge(ll x, ll y, ll w) {
w += weight(x);
w -= weight(y);
x = root(x);
y = root(y);
if (x == y)
return;
if (mode) {
par[x] += par[y];
par[y] = x;
dweight[y] = w;
} else {
if (rank[x] < rank[y]) {
par[y] += par[x];
par[x] = y;
dweight[x] = -w;
} else {
par[x] += par[y];
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
dweight[y] = w;
}
}
}
ll size(ll x) { return -par[root(x)]; }
};
template <class T> struct sUFT {
public:
ll tsize;
ll mode;
vll par;
vll rank;
GroupSet(T) Add;
V<T> elm;
sUFT(ll tsize, GroupSet(T) Add = ADD, ll mode = 0)
: tsize(tsize), Add(Add), mode(mode) {
init();
}
void init() {
par.asn(tsize, -1);
if (!mode)
rank.res(tsize, 0);
elm.asn(tsize, Id(Add));
}
ll root(ll x) { return par[x] < 0 ? x : par[x] = root(par[x]); }
bool isRoot(ll x) { return x == root(x); }
bool same(ll x, ll y) { return root(x) == root(y); }
void merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (mode) {
elm[x] = Act(Add)(elm[x], elm[y]);
par[y] = x;
} else {
if (rank[x] < rank[y]) {
elm[y] = Act(Add)(elm[x], elm[y]);
par[x] = y;
} else {
elm[x] = Act(Add)(elm[x], elm[y]);
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
}
}
}
T size(ll x) { return elm[root(x)]; }
T &operator[](ll x) { return elm[x]; }
};
template <typename valtype> class SegT {
public:
ll size;
vector<valtype> v;
valtype initv;
function<valtype(valtype x, valtype y)> calc;
SegT() {}
SegT(const SegT &segt) {}
SegT(ll sizeget, ll modeget = 0) {
sizeset(sizeget);
modeset(modeget);
init();
}
SegT(vector<valtype> cpyvec, ll modeget = 0) {
sizeset(cpyvec.sz);
modeset(modeget);
init();
copy(cpyvec);
}
SegT(ll sizeget, valtype initvget,
function<valtype(valtype x, valtype y)> calcget) {
sizeset(sizeget);
initv = initvget;
calc = calcget;
init();
}
SegT(vector<valtype> cpyvec, valtype initvget,
function<valtype(valtype x, valtype y)> calcget) {
sizeset(cpyvec.sz);
initv = initvget;
calc = calcget;
init();
copy(cpyvec);
}
void sizeset(ll rsize) {
size = DigN2(rsize);
if (rsize == Pow2(size - 1))
size--;
return;
}
void modeset(ll mode) {
switch (mode) {
case 0:
initv = 0;
calc = [](valtype x, valtype y) { return x + y; };
break;
case 1:
initv = INF;
calc = [](valtype x, valtype y) { return min(x, y); };
break;
case 2:
initv = -INF;
calc = [](valtype x, valtype y) { return max(x, y); };
break;
}
return;
}
void init() { v.asn(Pow2(size + 1) - 1, initv); }
void copy(vector<valtype> cpyvec) {
REP(i, min(cpyvec.sz, Pow2(size))) set(i, cpyvec[i]);
}
ll i2v(ll i) const {
if (i < 0 || i >= Pow2(size))
return -1;
return Pow2(size) + i - 1;
}
ll top(ll i) const {
if (i == 0)
return -1;
return (i - 1) / 2;
}
pl bot(ll i) const {
if (i + 1 >= Pow2(size))
return mp(-1, -1);
return mp(2 * i + 1, 2 * i + 2);
}
void set(ll i, valtype x) {
i = i2v(i);
v[i] = x;
while (i > 0) {
i = top(i);
v[i] = calc(v[bot(i).fi], v[bot(i).se]);
}
return;
}
void add(ll i, valtype x) {
set(i, v[i2v(i)] + x);
return;
}
valtype operator[](const ll &i) const { return v[i2v(i)]; }
// valtype que(ll a = 0, ll b = Pow2(size) - 1) {
valtype que(ll a, ll b) {
if (a == b)
return v[i2v(a)];
if (a > b)
return initv; // swap(a, b);
valtype ans = initv;
ll ai = i2v(a);
ll bi = i2v(b);
FOR(i, 1, size + 1) {
if (a > b)
break;
if (a % Pow2(i)) {
ans = calc(ans, v[ai]);
a += Pow2(i - 1);
ai = top(ai) + 1;
} else {
ai = top(ai);
}
if (a > b)
break;
if ((b + 1) % Pow2(i)) {
ans = calc(ans, v[bi]);
b -= Pow2(i - 1);
bi = top(bi) - 1;
} else {
bi = top(bi);
}
if (a > b)
break;
}
return ans;
}
valtype que(ll b) { return que(0, b); }
valtype que() { return que(0, Pow2(size) - 1); }
};
/*template <class Type> class DP {
public:
vector<Type> v;
Type initv;
vll size, block;
DP() {}
DP(const DP &dp) {}
template<class... Args> DP(Args... args) {
block.asn(1, 1);
Initialize(args...);
}
void Initialize(Type initv_) {
initv = initv_;
v.asn(block.bk, initv);
}
template<class... Args> void Initialize(ll val, Args... args) {
size.pb(val);
block.pb(block.bk*val);
Initialize(args...);
}
};*/
pl Bezout(ll a, ll b) {
if (b != 0) {
pl xy;
xy = Bezout(b, a % b);
return mp(xy.se, xy.fi - ((a / b) * xy.se));
} else {
return mp(1, 0);
}
}
pl Bez(ll a, ll b, ll c) {
pl xy;
ll x, y, z, gc;
xy = Bezout(a, b);
gc = gcd(a, b);
if (c % gc != 0)
return mp(-1, -1);
x = xy.fi * (c / gc);
y = xy.se * (c / gc);
if (x < 0)
z = rup(-x, (b / gc));
if (x >= 0)
z = -x / (b / gc);
x += z * (b / gc);
y -= z * (a / gc);
return mp(x, y);
}
ll DigS10(ll n) {
ll ans = 0;
while (1) {
ans += n % 10;
n /= 10;
if (!n)
break;
}
return ans;
}
ll isP(ll n) {
if (n <= 1)
return 0;
FOR(i, 2, (ll)sqrt(n) + 1) {
if (n % i == 0)
return 0;
}
return 1;
}
ll Tot(ll n) {
if (n <= 0)
return 0;
ll ans = n, x = 2;
while (x * x <= n) {
if (n % x == 0) {
ans -= ans / x;
while (n % x == 0)
n /= x;
}
x++;
}
if (n > 1)
ans -= ans / n;
return ans;
}
template <class T> struct Graph {
public:
ll vSize;
ll eMode;
ll mapMode;
GroupSet(T) Add;
CompareSet(T) Less;
CompareSet(T) Equal;
VV<P<T, ll>> adj;
map<pl, T> len;
Graph(ll vSize, ll eMode = 0, ll mapMode = 0, GroupSet(T) Add = ADD,
CompareSet(T) Less = LES, CompareSet(T) Equal = EQ)
: vSize(vSize), eMode(eMode), mapMode(mapMode), Add(Add), Less(Less),
Equal(Equal) {}
void Init() { adj.asn(vSize, V<P<T, ll>>()); }
void AddE(ll x, ll y, T cost) {
iAddE(x, y, cost);
if (!eMode)
iAddE(y, x, cost);
}
void iAddE(ll x, ll y, T cost) {
adj[x].pb(mp(cost, y));
if (mapMode)
len[mp(x, y)] = cost;
}
P<bool, T> getE(ll x, ll y) {
if (!len.count(mp(x, y)))
return mp(false, Id(Less));
return mp(true, len[mp(x, y)]);
}
V<T> Dijk(ll x) {
V<T> ans(vSize, Id(Less));
if (x < 0 || x >= vSize)
return ans;
SegT<P<T, ll>> segt(vSize, mp(Id(Less), -1),
clamr(if (l.se < 0) return r; if (r.se < 0) return l;
return Act(Less)(l.fi, r.fi) ? l : r;));
segt.set(x, mp(Id(Add), x));
P<T, ll> now;
while ((now = segt.que(0, vSize - 1)).se >= 0) {
ans[now.se] = segt[now.se].fi;
segt.set(now.se, mp(Id(Less), -2));
ROR(adj[now.se], i) {
if (segt[i.se].se == -2)
continue;
if (segt[i.se].se == -1) {
segt.set(i.se, mp(Act(Add)(ans[now.se], i.fi), i.se));
continue;
}
if (Act(Less)(Act(Add)(ans[now.se], i.fi), segt[i.se].fi)) {
segt.set(i.se, mp(Act(Add)(ans[now.se], i.fi), i.se));
continue;
}
}
}
return ans;
}
V<P<T, vll>> rDijk(ll x) {
V<P<T, vll>> ans(vSize, mp(Id(Less), vll()));
if (x < 0 || x >= vSize)
return ans;
SegT<P<T, ll>> segt(vSize, mp(Id(Less), -1),
clamr(if (l.se < 0) return r; if (r.se < 0) return l;
return Act(Less)(l.fi, r.fi) ? l : r;));
segt.set(x, mp(Id(Add), x));
P<T, ll> now;
while ((now = segt.que(0, vSize - 1)).se >= 0) {
ans[now.se].fi = segt[now.se].fi;
segt.set(now.se, mp(Id(Less), -2));
ROR(adj[now.se], i) {
if (segt[i.se].se == -2)
continue;
if (segt[i.se].se == -1) {
segt.set(i.se, mp(Act(Add)(ans[now.se].fi, i.fi), i.se));
ans[i.se].se = {now.se};
continue;
}
if (Act(Less)(Act(Add)(ans[now.se].fi, i.fi), segt[i.se].fi)) {
segt.set(i.se, mp(Act(Add)(ans[now.se].fi, i.fi), i.se));
ans[i.se].se = {now.se};
continue;
}
if (Act(Equal)(Act(Add)(ans[now.se].fi, i.fi), segt[i.se].fi)) {
ans[i.se].se.pb(now.se);
continue;
}
}
}
return ans;
}
T Prim(ll x = 0) {
T ans = Id(Add);
if (x < 0 || x >= vSize)
return ans;
SegT<P<T, ll>> segt(vSize, mp(Id(Less), -1),
clamr(if (l.se < 0) return r; if (r.se < 0) return l;
return Act(Less)(l.fi, r.fi) ? l : r;));
segt.set(x, mp(Id(Add), x));
P<T, ll> now;
while ((now = segt.que(0, vSize - 1)).se >= 0) {
ans = Act(Add)(ans, segt[now.se].fi);
segt.set(now.se, mp(Id(Less), -2));
ROR(adj[now.se], i) {
if (segt[i.se].se == -2)
continue;
if (segt[i.se].se == -1) {
segt.set(i.se, i);
continue;
}
if (Act(Less)(i.fi, segt[i.se].fi)) {
segt.set(i.se, i);
continue;
}
}
}
return ans;
}
P<T, V<P<T, vll>>> rPrim(ll x = 0) {
P<T, V<P<T, vll>>> ans =
mp(Id(Add), V<P<T, vll>>(vSize, mp(Id(Less), vll())));
if (x < 0 || x >= vSize)
return ans;
SegT<P<T, ll>> segt(vSize, mp(Id(Less), -1),
clamr(if (l.se < 0) return r; if (r.se < 0) return l;
return Act(Less)(l.fi, r.fi) ? l : r;));
segt.set(x, mp(Id(Add), x));
P<T, ll> now;
while ((now = segt.que(0, vSize - 1)).se >= 0) {
ans.se[now.se].fi = segt[now.se].fi;
ans.fi = Act(Add)(ans.fi, ans.se[now.se].fi);
segt.set(now.se, mp(Id(Less), -2));
ROR(adj[now.se], i) {
if (segt[i.se].se == -2)
continue;
if (segt[i.se].se == -1) {
segt.set(i.se, i);
ans.se[i.se].se = {now.se};
continue;
}
if (Act(Less)(i.fi, segt[i.se].fi)) {
segt.set(i.se, i);
ans.se[i.se].se = {now.se};
continue;
}
if (Act(Equal)(i.fi, segt[i.se].fi)) {
ans.se[i.se].se.pb(now.se);
continue;
}
}
}
return ans;
}
};
template <class T> struct Sum {
public:
V<T> v, s;
ll size;
GroupSet(T) Add;
Sum(V<T> v, GroupSet(T) Add = ADD) : v(v), size(v.sz), Add(Add) {
Init();
Calc();
}
void Init() { s.asn(size + 1, Id(Add)); }
void Calc() { REP(i, size) s[i + 1] = Act(Add)(s[i], v[i]); }
T operator()(ll x) {
if (x < -1)
x = -1;
if (x > size - 1)
x = size - 1;
return s[x + 1];
}
T operator()(ll l, ll r) {
if (l < 0)
l = 0;
if (r >= size)
r = size - 1;
if (l > r)
return Id(Add);
return InvAct(Add)(s[r + 1], s[l]);
}
};
using sumll = Sum<ll>;
template <class T> struct Sum2 {
public:
VV<T> v, s;
ll RowSize, ColumnSize;
GroupSet(T) Add;
Sum2(VV<T> v, GroupSet(T) Add = ADD)
: v(v), RowSize(v.sz), ColumnSize(v.sz ? v[0].sz : 0), Add(Add) {
Init();
Calc();
}
void Init() { s.asn(RowSize + 1, V<T>(ColumnSize + 1, Id(Add))); }
void Calc() {
REP1(r, RowSize) {
REP1(c, ColumnSize) {
// s[r][c] = InvAct(Add)(Act(Add)(Act(Add)(v[r -
//1][c - 1], operator()(r - 1, c - 2)), operator()(r - 2, c - 1)),
//operator()(r - 2, c - 2));
s[r][c] = Act(Add)(s[r][c - 1], v[r - 1][c - 1]);
}
}
REP1(r, RowSize) {
REP1(c, ColumnSize) { s[r][c] = Act(Add)(s[r - 1][c], s[r][c]); }
}
}
T operator()(ll r, ll c) {
if (r < -1)
r = -1;
if (c < -1)
c = -1;
if (r > RowSize - 1)
r = RowSize - 1;
if (c > ColumnSize - 1)
c = ColumnSize - 1;
return s[r + 1][c + 1];
}
T operator()(ll r1, ll c1, ll r2, ll c2) {
if (r1 < 0)
r1 = 0;
if (c1 < 0)
c1 = 0;
if (r2 >= RowSize)
r2 = RowSize - 1;
if (c2 >= ColumnSize)
c2 = ColumnSize - 1;
if (r1 > r2)
return Id(Add);
if (c1 > c2)
return Id(Add);
return InvAct(Add)(Act(Add)(s[r2 + 1][c2 + 1], s[r1][c1]),
Act(Add)(s[r2 + 1][c1], s[r1][c2 + 1]));
}
};
using sumll2 = Sum2<ll>;
template <class T> struct Point2 {
public:
VV<T> v;
ll h, w;
Point2() : h(0), w(0) {}
Point2(ll h, ll w) : h(h), w(w) { asn(h, w); }
Point2(ll h, ll w, T val) : h(h), w(w) { asn(h, w, val); }
Point2(VV<T> cv) : h(cv.sz), w(cv.sz ? cv[0].sz : 0) {
asn(h, w);
copy(cv);
}
void assign(ll h, ll w) { v.asn(h, V<T>(w)); }
void assign(ll h, ll w, ll val) { v.asn(h, V<T>(w, val)); }
void copy(VV<T> cv) { REP(_h, h) REP(_w, w) v[_h][_w] = cv[_h][_w]; }
T &operator()(ll h, ll w) { return v[h][w]; }
T &operator()(pl p) { return v[p.fi][p.se]; }
T &operator[](pl p) { return v[p.fi][p.se]; }
};
template <class T> using P2 = Point2<T>;
template <ll Mod> struct Modll {
public:
ll v;
Modll() : v(0) {}
Modll(ll _v) { set(_v % Mod + Mod); }
Modll &set(ll _v) {
v = (_v < Mod) ? _v : (_v - Mod);
return *this;
}
Modll pow(ll n) const {
Modll x = *this, ans = 1;
while (n) {
if (n & 1)
ans *= x;
x *= x;
n >>= 1;
}
return ans;
}
Modll inverse() const { return (*this).pow(Mod - 2); }
Modll operator+(const Modll &m) const { return Modll().set(v + m.v); }
Modll operator-(const Modll &m) const { return Modll().set(Mod + v - m.v); }
Modll operator*(const Modll &m) const {
return Modll().set((ull(v) * m.v) % Mod);
}
Modll operator/(const Modll &m) const { return *this * m.inv; }
Modll &operator+=(const Modll &m) { return *this = *this + m; }
Modll &operator-=(const Modll &m) { return *this = *this - m; }
Modll &operator*=(const Modll &m) { return *this = *this * m; }
Modll &operator/=(const Modll &m) { return *this = *this / m; }
Modll operator-() const { return Modll(0) - *this; }
explicit operator bool() const { return v != 0; }
friend istream &operator>>(istream &in, Modll &m) { return in >> m.v; }
friend ostream &operator<<(ostream &out, const Modll &m) {
return out << m.v;
}
};
using mll = Modll<MOD>;
using vmll = V<mll>;
using vvmll = V<vmll>;
using vvvmll = V<vvmll>;
vmll MFactMemo(2, 1);
vmll MIFactMemo(2, 1);
mll mFact(ll n) {
if (MFactMemo.sz <= n) {
ll oldsize = MFactMemo.sz;
MFactMemo.res(n + 1, 1);
FOR(i, oldsize, n) MFactMemo[i] = MFactMemo[i - 1] * i;
}
return MFactMemo[n];
}
mll miFact(ll n) {
if (MIFactMemo.sz <= n) {
ll oldsize = MIFactMemo.sz;
MIFactMemo.res(n + 1, 1);
MIFactMemo.bk = mFact(n).inv;
rFOR(i, oldsize + 1, n) MIFactMemo[i - 1] = MIFactMemo[i] * i;
}
return MIFactMemo[n];
}
mll mComb(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
return mFact(n) * miFact(k) * miFact(n - k);
}
ll LIS(vll v, ll m = 0) {
if (v.sz > 0) {
ll ans = 0;
vll dp(v.sz, INF);
FOR(i, 0, v.sz - 1) { dp[m ? UPB(dp, v[i]) : LOWB(dp, v[i])] = v[i]; }
FOR(i, 0, v.sz - 1) {
if (dp[i] == INF)
break;
ans++;
}
return ans;
} else {
return 0;
}
}
ll Bsrch(function<bool(ll x)> f, ll mi, ll ma) {
ll ng = mi - 1, ok = ma, mid;
while (ok - ng > 1) {
mid = (ng + ok) / 2;
(f(mid) ? ok : ng) = mid;
}
return ok;
}
template <class T, class M = decltype(MUL), class S = decltype(ADD)>
VV<T> MultiMatrix(VV<T> A, VV<T> B, M Mul = MUL, S Add = ADD) {
VV<T> ans;
ll ii = A.sz;
if (!ii)
return ans;
ll jj = A[0].sz;
if (!jj)
return ans;
ll jj2 = B.sz;
if (!jj2)
return ans;
if (jj != jj2)
return ans;
ll kk = B[0].sz;
if (!kk)
return ans;
ans.asn(ii, V<T>(kk, 0));
REP(i, ii) {
REP(k, kk) {
REP(j, jj) {
ans[i][k] = Act(Add)(ans[i][k], Act(Mul)(A[i][j], B[j][k]));
}
}
}
return ans;
}
vvll CombMemo(1000, vll(1000, -1));
ll Comb(ll n, ll k) {
if ((n < 0) || (k < 0))
return 0;
if (CombMemo[n][k] == -1) {
if (n < k)
CombMemo[n][k] = 0;
else {
if (n == 0)
CombMemo[n][k] = 1;
else if (k == 0)
CombMemo[n][k] = 1;
else if (n == k)
CombMemo[n][k] = 1;
else
CombMemo[n][k] = Comb(n - 1, k - 1) + Comb(n - 1, k);
}
}
return CombMemo[n][k];
}
template <class T> map<T, ll> Dict(V<T> v) {
map<T, ll> m;
if (!v.sz)
return m;
SORT(v);
UNIQUE(v);
REP(i, v.sz) { m[v[i]] = i; }
return m;
}
template <class T> vll Cmprs(V<T> v) {
auto m = Dict(v);
vll ans(v.sz);
REP(i, v.sz) { ans[i] = m[v[i]]; }
return ans;
}
template <class T> vll PCmprs(V<T> v) {
if (v.sz == 0)
return V<T>();
vll tmp(v.sz);
vll ans(v.sz);
IOTA(tmp, 0);
IOTA(ans, 0);
sort(tmp.bgn, tmp.en, clam(v[l] < v[r]));
sort(ans.bgn, ans.en, clam(tmp[l] < tmp[r]));
return ans;
}
ll BblCnt(vll rv) {
vll v = PCmprs(rv);
SegT<ll> b(v.sz, 0);
ll ans = 0;
REP(i, v.sz) {
ans += (i - b.que(0, v[i]));
b.add(v[i], 1);
}
return ans;
}
pl NGrid(pl p, ll i, ll H, ll W) {
p = mp(p.fi + DX[i], p.se + DY[i]);
if (p.fi < 0 || p.fi >= H || p.se < 0 || p.se >= W)
return mp(INF, INF);
return p;
}
vvll llGrid(vs v) {
vvll r(v.sz, vll(v.sz ? v[0].sz : 0, 0));
REP(h, v.sz) REP(w, v.sz ? v[0].sz : 0) r[h][w] = (v[h][w] == '#');
return r;
}
template <class T> auto ven(T val) { return val; }
template <> auto ven<int>(int val) { return (ll)val; }
template <class T, class... Args> auto ven(T val, Args... args) {
auto tmp = ven(args...);
return V<decltype(tmp)>(val, tmp);
}
template <class T> void zind(T &v) { v--; }
template <class T> void zind(V<T> &v) { ROR(v, i) zind(i); }
template <class T, class... Args> void zind(T &v, Args &...args) {
zind(v);
zind(args...);
}
template <class S, class T> void SORTby(V<S> &i, const V<T> &x) {
sort(i.bgn, i.en, clam(x[l] < x[r]));
}
template <class S, class T> void rSORTby(V<S> &i, const V<T> &x) {
sort(i.bgn, i.en, clam(x[l] > x[r]));
}
template <typename Monoid, typename OperatorMonoid = Monoid>
struct LazySegmentTree {
using F = function<Monoid(Monoid, Monoid)>;
using G = function<Monoid(Monoid, OperatorMonoid)>;
using H = function<OperatorMonoid(OperatorMonoid, OperatorMonoid)>;
using P = function<OperatorMonoid(OperatorMonoid, ll)>;
ll size;
vector<Monoid> data;
vector<OperatorMonoid> lazy;
const F f;
const G g;
const H h;
const P p;
const Monoid M1;
const OperatorMonoid OM0;
LazySegmentTree(ll n, const F f, const G g, const H h, const P p,
const Monoid &M1, const OperatorMonoid OM0)
: f(f), g(g), h(h), p(p), M1(M1), OM0(OM0) {
size = 1;
while (size < n)
size <<= 1;
data.assign(2 * size, M1);
lazy.assign(2 * size, OM0);
}
void set(ll k, const Monoid &x) { data[k + size] = x; }
void build() {
for (ll k = size - 1; k > 0; k--) {
data[k] = f(data[2 * k + 0], data[2 * k + 1]);
}
}
void propagate(ll k, ll len) {
if (lazy[k] != OM0) {
if (k < size) {
lazy[2 * k + 0] = h(lazy[2 * k + 0], lazy[k]);
lazy[2 * k + 1] = h(lazy[2 * k + 1], lazy[k]);
}
data[k] = g(data[k], p(lazy[k], len));
lazy[k] = OM0;
}
}
Monoid update(ll a, ll b, const OperatorMonoid &x, ll k, ll l, ll r) {
propagate(k, r - l);
if (r <= a || b <= l) {
return data[k];
} else if (a <= l && r <= b) {
lazy[k] = h(lazy[k], x);
propagate(k, r - l);
return data[k];
} else {
return data[k] = f(update(a, b, x, 2 * k + 0, l, (l + r) >> 1),
update(a, b, x, 2 * k + 1, (l + r) >> 1, r));
}
}
Monoid update(ll a, ll b, const OperatorMonoid &x) {
return update(a, b, x, 1, 0, size);
}
Monoid query(ll a, ll b, ll k, ll l, ll r) {
propagate(k, r - l);
if (r <= a || b <= l) {
return M1;
} else if (a <= l && r <= b) {
return data[k];
} else {
return f(query(a, b, 2 * k + 0, l, (l + r) >> 1),
query(a, b, 2 * k + 1, (l + r) >> 1, r));
}
}
Monoid query(ll a, ll b) { return query(a, b, 1, 0, size); }
Monoid operator[](const ll &k) { return query(k, k + 1); }
};
void Solve();
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(20) << fixed;
Solve();
}
// index_sort
void Solve() {
li(N);
vli(5, A);
SORT(A);
sal(5 + rup(N, A[0]) - 1);
} | [
"call.add",
"call.arguments.change",
"expression.operation.binary.change",
"call.arguments.add"
] | 893,916 | 893,917 | u211681714 | cpp |
p03078 | #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <cmath>
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <deque> // deque
#include <iomanip>
#include <iostream>
#include <limits>
#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++)
ll Max(ll(a), ll(b), ll(c)) { return max(max(a, b), c); }
ll Min(ll(a), ll(b), ll(c)) { return min(min(a, b), c); }
int main() {
ll X, Y, Z, K;
cin >> X >> Y >> Z >> K;
vector<ll> A(X);
vector<ll> B(Y);
vector<ll> C(Z);
vector<ll> AB(max(K, X * Y));
rep(i, X) { cin >> A[i]; }
rep(i, Y) { cin >> B[i]; }
rep(i, Z) { cin >> C[i]; }
sort(A.begin(), A.end());
sort(B.begin(), B.end());
sort(C.begin(), C.end());
reverse(A.begin(), A.end());
reverse(B.begin(), B.end());
reverse(C.begin(), C.end());
rep(i, X) {
rep(j, Y) { AB[i * Y + j] = A[i] + B[j]; }
}
if (X + Y < K) {
for (ll i = X + Y; i < K; i++) {
AB[i] = 0;
}
}
sort(AB.begin(), AB.end());
reverse(AB.begin(), AB.end());
vector<ll> ABC(Z * K);
rep(i, K) {
rep(j, Z) { ABC[i * Z + j] = AB[i] + C[j]; }
}
sort(ABC.begin(), ABC.end());
reverse(ABC.begin(), ABC.end());
rep(i, K) { cout << ABC[i] << endl; }
} | #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <cmath>
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <deque> // deque
#include <iomanip>
#include <iostream>
#include <limits>
#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++)
ll Max(ll(a), ll(b), ll(c)) { return max(max(a, b), c); }
ll Min(ll(a), ll(b), ll(c)) { return min(min(a, b), c); }
int main() {
ll X, Y, Z, K;
cin >> X >> Y >> Z >> K;
vector<ll> A(X);
vector<ll> B(Y);
vector<ll> C(Z);
vector<ll> AB(max(K, X * Y));
rep(i, X) { cin >> A[i]; }
rep(i, Y) { cin >> B[i]; }
rep(i, Z) { cin >> C[i]; }
sort(A.begin(), A.end());
sort(B.begin(), B.end());
sort(C.begin(), C.end());
reverse(A.begin(), A.end());
reverse(B.begin(), B.end());
reverse(C.begin(), C.end());
rep(i, X) {
rep(j, Y) { AB[i * Y + j] = A[i] + B[j]; }
}
if (X * Y < K) {
for (ll i = X * Y; i < K; i++) {
AB[i] = 0;
}
}
sort(AB.begin(), AB.end());
reverse(AB.begin(), AB.end());
vector<ll> ABC(Z * K);
rep(i, K) {
rep(j, Z) { ABC[i * Z + j] = AB[i] + C[j]; }
}
sort(ABC.begin(), ABC.end());
reverse(ABC.begin(), ABC.end());
rep(i, K) { cout << ABC[i] << endl; }
} | [
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.change"
] | 893,918 | 893,919 | u927801748 | cpp |
p03078 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define REP(i, n) for (ll i = 0; i < ll(n); i++)
#define ALL(x) x.begin(), x.end()
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int x, y, z, k;
cin >> x >> y >> z >> k;
vector<ll> xl(x), yl(y), zl(z);
REP(i, x) cin >> xl[i];
REP(i, y) cin >> yl[i];
REP(i, z) cin >> zl[i];
vector<ll> xyl;
for (int i = 0; i < x; i++) {
for (int j = 0; j < y; j++) {
xyl.push_back(xl[i] + yl[j]);
}
}
sort(xyl.begin(), xyl.end(), greater<ll>());
vector<ll> xyzl;
for (int i = 0; i < min(k, x * y); i++) {
for (int j = 0; j < z; j++) {
xyzl.push_back(xyl[i] + zl[j]);
}
}
sort(xyzl.begin(), xyzl.end(), greater<ll>());
for (int i = 0; i < k; i++) {
cout << xyl[i] << endl;
}
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define REP(i, n) for (ll i = 0; i < ll(n); i++)
#define ALL(x) x.begin(), x.end()
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int x, y, z, k;
cin >> x >> y >> z >> k;
vector<ll> xl(x), yl(y), zl(z);
REP(i, x) cin >> xl[i];
REP(i, y) cin >> yl[i];
REP(i, z) cin >> zl[i];
vector<ll> xyl;
for (int i = 0; i < x; i++) {
for (int j = 0; j < y; j++) {
xyl.push_back(xl[i] + yl[j]);
}
}
sort(xyl.begin(), xyl.end(), greater<ll>());
vector<ll> xyzl;
for (int i = 0; i < min(k, x * y); i++) {
for (int j = 0; j < z; j++) {
xyzl.push_back(xyl[i] + zl[j]);
}
}
sort(xyzl.begin(), xyzl.end(), greater<ll>());
for (int i = 0; i < k; i++) {
cout << xyzl[i] << endl;
}
} | [
"identifier.change",
"io.output.change"
] | 893,924 | 893,925 | u493520238 | cpp |
p03078 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define REP(i, n) for (ll i = 0; i < ll(n); i++)
#define ALL(x) x.begin(), x.end()
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int x, y, z, k;
cin >> x >> y >> z >> k;
vector<ll> xl(x), yl(y), zl(z);
REP(i, x) cin >> xl[i];
REP(i, y) cin >> yl[i];
REP(i, z) cin >> zl[i];
vector<ll> xyl;
for (int i = 0; i < x; i++) {
for (int j = 0; j < y; j++) {
xyl.push_back(xl[i] + yl[j]);
}
}
sort(xyl.begin(), xyl.end(), greater<int>());
vector<ll> xyzl;
for (int i = 0; i < min(k, x * y); i++) {
for (int j = 0; j < z; j++) {
xyzl.push_back(xyl[i] + zl[j]);
}
}
sort(xyzl.begin(), xyzl.end(), greater<int>());
for (int i = 0; i < k; i++) {
cout << xyzl[i] << endl;
}
// cout << x << y << z << k;
// int l;
// vector<int> ls(n);
// REP(i,n) cin >> ls[i];
// sort(ALL(l));
// ll ans = 0;
// for( int i = 0 ; i < n-2 ; i++ ){
// for ( int j = i+1 : j < n-1 ; j++ ){
// ll cnt = 0;
// cnt = lower_bound(ls.begin()+j+1, ls.end());
// ans += cnt
// }
// }
// cout << ans << endl;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define REP(i, n) for (ll i = 0; i < ll(n); i++)
#define ALL(x) x.begin(), x.end()
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int x, y, z, k;
cin >> x >> y >> z >> k;
vector<ll> xl(x), yl(y), zl(z);
REP(i, x) cin >> xl[i];
REP(i, y) cin >> yl[i];
REP(i, z) cin >> zl[i];
vector<ll> xyl;
for (int i = 0; i < x; i++) {
for (int j = 0; j < y; j++) {
xyl.push_back(xl[i] + yl[j]);
}
}
sort(xyl.begin(), xyl.end(), greater<ll>());
vector<ll> xyzl;
for (int i = 0; i < min(k, x * y); i++) {
for (int j = 0; j < z; j++) {
xyzl.push_back(xyl[i] + zl[j]);
}
}
sort(xyzl.begin(), xyzl.end(), greater<ll>());
for (int i = 0; i < k; i++) {
cout << xyzl[i] << endl;
}
} | [
"call.arguments.change"
] | 893,926 | 893,925 | u493520238 | cpp |
p03078 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, N) for (int i = 0; i < int(N); ++i)
#define rep1(i, N) for (int i = 1; i < int(N); ++i)
#define all(a) (a).begin(), (a).end()
#define bit(k) (1LL << (k))
#define SUM(v) accumulate(all(v), 0LL)
typedef pair<int, int> i_i;
typedef pair<ll, ll> l_l;
template <class T> using vec = vector<T>;
template <class T> using vvec = vector<vec<T>>;
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
#define TOSTRING(x) string(#x)
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[";
for (auto _ : v)
os << _ << ", ";
os << "]";
return os;
};
template <typename T> ostream &operator<<(ostream &os, set<T> &st) {
os << "(";
for (auto _ : st) {
os << _ << ", ";
}
os << ")";
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "{" << p.first << ", " << p.second << "}";
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &mp) {
os << "[";
for (auto _ : mp) {
os << _ << ", ";
}
os << "]" << endl;
return os;
}
#define DUMPOUT cerr
void dump_func() { DUMPOUT << endl; }
template <class Head, class... Tail>
void dump_func(Head &&head, Tail &&...tail) {
DUMPOUT << head;
if (sizeof...(Tail) > 0) {
DUMPOUT << ", ";
}
dump_func(std::move(tail)...);
}
#ifdef DEBUG
#define dbg(...) dump_func(__VA_ARGS__)
#define dump(...) \
DUMPOUT << string(#__VA_ARGS__) << ": "; \
dump_func(__VA_ARGS__)
#else
#define dbg(...)
#define dump(...)
#endif
const int INF = (ll)1e9;
const ll INFLL = (ll)1e18 + 1;
const ll MOD = 1000000007;
// const ll MOD = 998244353;
const long double PI = acos(-1.0);
/*
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const string dir = "DRUL";
*/
int main() {
ll X, Y, Z, K;
cin >> X >> Y >> Z >> K;
vector<ll> A(X), B(Y), C(Z);
cin >> A >> B >> C;
vector<ll> v;
rep(i, X) rep(j, Y) { v.emplace_back(A[i] + B[j]); }
sort(all(v), greater<>());
dump(v);
while (v.size() > K) {
v.pop_back();
}
dump(v);
vector<ll> w;
rep(i, K) rep(j, Z) { w.emplace_back(v[i] + C[j]); }
sort(all(w), greater<>());
while (w.size() > K)
w.pop_back();
rep(i, K) { cout << w[i] << endl; }
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, N) for (int i = 0; i < int(N); ++i)
#define rep1(i, N) for (int i = 1; i < int(N); ++i)
#define all(a) (a).begin(), (a).end()
#define bit(k) (1LL << (k))
#define SUM(v) accumulate(all(v), 0LL)
typedef pair<int, int> i_i;
typedef pair<ll, ll> l_l;
template <class T> using vec = vector<T>;
template <class T> using vvec = vector<vec<T>>;
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
#define TOSTRING(x) string(#x)
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[";
for (auto _ : v)
os << _ << ", ";
os << "]";
return os;
};
template <typename T> ostream &operator<<(ostream &os, set<T> &st) {
os << "(";
for (auto _ : st) {
os << _ << ", ";
}
os << ")";
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "{" << p.first << ", " << p.second << "}";
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &mp) {
os << "[";
for (auto _ : mp) {
os << _ << ", ";
}
os << "]" << endl;
return os;
}
#define DUMPOUT cerr
void dump_func() { DUMPOUT << endl; }
template <class Head, class... Tail>
void dump_func(Head &&head, Tail &&...tail) {
DUMPOUT << head;
if (sizeof...(Tail) > 0) {
DUMPOUT << ", ";
}
dump_func(std::move(tail)...);
}
#ifdef DEBUG
#define dbg(...) dump_func(__VA_ARGS__)
#define dump(...) \
DUMPOUT << string(#__VA_ARGS__) << ": "; \
dump_func(__VA_ARGS__)
#else
#define dbg(...)
#define dump(...)
#endif
const int INF = (ll)1e9;
const ll INFLL = (ll)1e18 + 1;
const ll MOD = 1000000007;
// const ll MOD = 998244353;
const long double PI = acos(-1.0);
/*
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const string dir = "DRUL";
*/
int main() {
ll X, Y, Z, K;
cin >> X >> Y >> Z >> K;
vector<ll> A(X), B(Y), C(Z);
cin >> A >> B >> C;
vector<ll> v;
rep(i, X) rep(j, Y) { v.emplace_back(A[i] + B[j]); }
sort(all(v), greater<>());
dump(v);
while (v.size() > K) {
v.pop_back();
}
dump(v);
vector<ll> w;
rep(i, v.size()) rep(j, Z) { w.emplace_back(v[i] + C[j]); }
sort(all(w), greater<>());
while (w.size() > K)
w.pop_back();
rep(i, K) { cout << w[i] << endl; }
}
| [
"call.arguments.change",
"call.add"
] | 893,941 | 893,942 | u106297876 | cpp |
p03077 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <math.h>
#include <queue>
#include <stack>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
int main() {
long int people[5], n;
cin >> n;
for (int i = 0; i < 5; i++) {
cin >> people[i];
}
long int a = n / people[0];
if (n % people[0] != 0)
a++;
long int ans = a;
long int tmp1, tmp2;
int flag = 0;
for (int i = 1; i < 5; i++) {
tmp1 = n / people[flag];
if (n % people[flag] != 0)
tmp1++;
tmp2 = n / people[i];
if (n % people[i] != 0)
tmp2++;
if (people[i - 1] <= people[i]) {
ans++;
} else {
flag = i;
ans += tmp2 - tmp1;
ans++;
}
}
cout << ans;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <math.h>
#include <queue>
#include <stack>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
int main() {
long int people[5], n;
cin >> n;
for (int i = 0; i < 5; i++) {
cin >> people[i];
}
long int a = n / people[0];
if (n % people[0] != 0)
a++;
long int ans = a;
long int tmp1, tmp2;
int flag = 0;
for (int i = 1; i < 5; i++) {
tmp1 = n / people[flag];
if (n % people[flag] != 0)
tmp1++;
tmp2 = n / people[i];
if (n % people[i] != 0)
tmp2++;
if (people[flag] <= people[i]) {
ans++;
} else {
flag = i;
ans += tmp2 - tmp1;
ans++;
}
}
cout << ans;
return 0;
} | [
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 893,944 | 893,945 | u227379863 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
int main() {
long n, a;
cin >> n >> a;
for (int i = 1; i < 5; i++) {
long b;
cin >> b;
a = min(a, b);
}
cout << 5 + n / a << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long n, a;
cin >> n >> a;
for (int i = 1; i < 5; i++) {
long b;
cin >> b;
a = min(a, b);
}
cout << 5 + (n - 1) / a << endl;
return 0;
}
| [] | 893,963 | 893,964 | u280512618 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
int main() {
long N, A, B, C, D, E;
cin >> N >> A >> B >> C >> D >> E;
long n[5] = {A, B, C, D, E};
sort(n, n + 5);
int a = n[0];
int v = 4;
if (N % a != 0) {
v += N / a + 1;
} else {
v += N / a;
}
cout << v << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long N, A, B, C, D, E;
cin >> N >> A >> B >> C >> D >> E;
long n[5] = {A, B, C, D, E};
sort(n, n + 5);
long a = n[0];
long v = 4;
if (N % a != 0) {
v += N / a + 1;
} else {
v += N / a;
}
cout << v << endl;
} | [
"variable_declaration.type.primitive.change"
] | 893,967 | 893,968 | u288905450 | cpp |
p03077 | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
int main() {
ll N, A, B, C, D, E;
cin >> N >> A >> B >> C >> D >> E;
ll train = A;
ll bus = min(train, B);
ll taxi = min(bus, C);
ll plane = min(taxi, D);
ll ship = min(plane, E);
ll ans;
if (N == ship) {
ans = 4 + (N / ship);
} else {
ans = 5 + (N / ship);
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
int main() {
ll N, A, B, C, D, E;
cin >> N >> A >> B >> C >> D >> E;
ll train = A;
ll bus = min(train, B);
ll taxi = min(bus, C);
ll plane = min(taxi, D);
ll ship = min(plane, E);
ll ans;
if (N % ship == 0) {
ans = 4 + (N / ship);
} else {
ans = 5 + (N / ship);
}
cout << ans << endl;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 893,969 | 893,970 | u394759653 | cpp |
p03077 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const long long INF = 1LL << 60;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int main() {
ll N;
cin >> N;
ll mini = INF;
ll A[5];
for (int i = 0; i < 5; i++) {
cin >> A[i];
chmin(mini, A[i]);
}
ll sum = (N + mini - 1) / 2;
sum += 4;
cout << sum << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const long long INF = 1LL << 60;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int main() {
ll N;
cin >> N;
ll mini = INF;
ll A[5];
for (int i = 0; i < 5; i++) {
cin >> A[i];
chmin(mini, A[i]);
}
ll sum = (N + mini - 1) / mini;
sum += 4;
cout << sum << endl;
} | [
"identifier.replace.add",
"literal.replace.remove",
"expression.operation.binary.change"
] | 893,971 | 893,972 | u508571192 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.