結果
| 問題 | No.1999 Lattice Teleportation |
| ユーザー |
 suisen
|
| 提出日時 | 2022-07-01 23:37:17 |
| 言語 | C++17 (gcc 13.3.0 + boost 1.87.0) |
| 結果 |
CE
(最新)
AC
(最初)
|
| 実行時間 | - |
| コード長 | 23,115 bytes |
| コンパイル時間 | 2,369 ms |
| コンパイル使用メモリ | 307,848 KB |
| 最終ジャッジ日時 | 2025-01-30 03:36:24 |
|
ジャッジサーバーID （参考情報） |
judge1 / judge4 |
（要ログイン）
コンパイルエラー時のメッセージ・ソースコードは、提出者また管理者しか表示できないようにしております。（リジャッジ後のコンパイルエラーは公開されます）
ただし、clay言語の場合は開発者のデバッグのため、公開されます。
ただし、clay言語の場合は開発者のデバッグのため、公開されます。
コンパイルメッセージ
main.cpp: In instantiation of ‘void print(const Head&, const Tail& ...) [with Head = atcoder::static_modint<1000000007>; Tail = {}]’:
main.cpp:683:10: required from here
main.cpp:215:15: error: no match for ‘operator<<’ (operand types are ‘std::ostream’ {aka ‘std::basic_ostream<char>’} and ‘const atcoder::static_modint<1000000007>’)
215 | std::cout << head;
| ~~~~~~~~~~^~~~~~~
In file included from /usr/include/c++/13/istream:41,
from /usr/include/c++/13/sstream:40,
from /usr/include/c++/13/complex:45,
from /usr/include/c++/13/ccomplex:39,
from /usr/include/x86_64-linux-gnu/c++/13/bits/stdc++.h:127,
from main.cpp:1:
/usr/include/c++/13/ostream:110:7: note: candidate: ‘std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(__ostream_type& (*)(__ostream_type&)) [with _CharT = char; _Traits = std::char_traits<char>; __ostream_type = std::basic_ostream<char>]’
110 | operator<<(__ostream_type& (*__pf)(__ostream_type&))
| ^~~~~~~~
/usr/include/c++/13/ostream:110:36: note: no known conversion for argument 1 from ‘const atcoder::static_modint<1000000007>’ to ‘std::basic_ostream<char>::__ostream_type& (*)(std::basic_ostream<char>::__ostream_type&)’ {aka ‘std::basic_ostream<char>& (*)(std::basic_ostream<char>&)’}
110 | operator<<(__ostream_type& (*__pf)(__ostream_type&))
| ~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/13/ostream:119:7: note: candidate: ‘std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(__ios_type& (*)(__ios_type&)) [with _CharT = char; _Traits = std::char_traits<char>; __ostream_type = std::basic_ostream<char>; __ios_type = std::basic_ios<char>]’
119 | operator<<(__ios_type& (*__pf)(__ios_type&))
| ^~~~~~~~
/usr/include/c++/13/ostream:119:3
ソースコード
#include <bits/stdc++.h>#ifdef _MSC_VER# include <intrin.h>#else# include <x86intrin.h>#endif#include <limits>#include <type_traits>namespace suisen {// ! utilitytemplate <typename ...Types>using constraints_t = std::enable_if_t<std::conjunction_v<Types...>, std::nullptr_t>;template <bool cond_v, typename Then, typename OrElse>constexpr decltype(auto) constexpr_if(Then&& then, OrElse&& or_else) {if constexpr (cond_v) {return std::forward<Then>(then);} else {return std::forward<OrElse>(or_else);}}// ! functiontemplate <typename ReturnType, typename Callable, typename ...Args>using is_same_as_invoke_result = std::is_same<std::invoke_result_t<Callable, Args...>, ReturnType>;template <typename F, typename T>using is_uni_op = is_same_as_invoke_result<T, F, T>;template <typename F, typename T>using is_bin_op = is_same_as_invoke_result<T, F, T, T>;template <typename Comparator, typename T>using is_comparator = std::is_same<std::invoke_result_t<Comparator, T, T>, bool>;// ! integraltemplate <typename T, typename = constraints_t<std::is_integral<T>>>constexpr int bit_num = std::numeric_limits<std::make_unsigned_t<T>>::digits;template <typename T, unsigned int n>struct is_nbit { static constexpr bool value = bit_num<T> == n; };template <typename T, unsigned int n>static constexpr bool is_nbit_v = is_nbit<T, n>::value;// ?template <typename T>struct safely_multipliable {};template <>struct safely_multipliable<int> { using type = long long; };template <>struct safely_multipliable<long long> { using type = __int128_t; };template <>struct safely_multipliable<unsigned int> { using type = unsigned long long; };template <>struct safely_multipliable<unsigned long int> { using type = __uint128_t; };template <>struct safely_multipliable<unsigned long long> { using type = __uint128_t; };template <>struct safely_multipliable<float> { using type = float; };template <>struct safely_multipliable<double> { using type = double; };template <>struct safely_multipliable<long double> { using type = long double; };template <typename T>using safely_multipliable_t = typename safely_multipliable<T>::type;template <typename T, typename = void>struct rec_value_type {using type = T;};template <typename T>struct rec_value_type<T, std::void_t<typename T::value_type>> {using type = typename rec_value_type<typename T::value_type>::type;};template <typename T>using rec_value_type_t = typename rec_value_type<T>::type;} // namespace suisen// ! type aliasesusing i128 = __int128_t;using u128 = __uint128_t;template <typename T>using pq_greater = std::priority_queue<T, std::vector<T>, std::greater<T>>;template <typename T, typename U>using umap = std::unordered_map<T, U>;// ! macros (capital: internal macro)#define OVERLOAD2(_1,_2,name,...) name#define OVERLOAD3(_1,_2,_3,name,...) name#define OVERLOAD4(_1,_2,_3,_4,name,...) name#define REP4(i,l,r,s) for(std::remove_reference_t<std::remove_const_t<decltype(r)>>i=(l);i<(r);i+=(s))#define REP3(i,l,r) REP4(i,l,r,1)#define REP2(i,n) REP3(i,0,n)#define REPINF3(i,l,s) for(std::remove_reference_t<std::remove_const_t<decltype(l)>>i=(l);;i+=(s))#define REPINF2(i,l) REPINF3(i,l,1)#define REPINF1(i) REPINF2(i,0)#define RREP4(i,l,r,s) for(std::remove_reference_t<std::remove_const_t<decltype(r)>>i=(l)+fld((r)-(l)-1,s)*(s);i>=(l);i-=(s))#define RREP3(i,l,r) RREP4(i,l,r,1)#define RREP2(i,n) RREP3(i,0,n)#define rep(...) OVERLOAD4(__VA_ARGS__, REP4 , REP3 , REP2 )(__VA_ARGS__)#define rrep(...) OVERLOAD4(__VA_ARGS__, RREP4 , RREP3 , RREP2 )(__VA_ARGS__)#define repinf(...) OVERLOAD3(__VA_ARGS__, REPINF3, REPINF2, REPINF1)(__VA_ARGS__)#define CAT_I(a, b) a##b#define CAT(a, b) CAT_I(a, b)#define UNIQVAR(tag) CAT(tag, __LINE__)#define loop(n) for (std::remove_reference_t<std::remove_const_t<decltype(n)>> UNIQVAR(loop_variable) = n; UNIQVAR(loop_variable) --> 0;)#define all(iterable) std::begin(iterable), std::end(iterable)#define input(type, ...) type __VA_ARGS__; read(__VA_ARGS__)#ifdef LOCAL# define debug(...) debug_internal(#__VA_ARGS__, __VA_ARGS__)template <class T, class... Args>void debug_internal(const char* s, T&& first, Args&&... args) {constexpr const char* prefix = "[\033[32mDEBUG\033[m] ";constexpr const char* open_brakets = sizeof...(args) == 0 ? "" : "(";constexpr const char* close_brakets = sizeof...(args) == 0 ? "" : ")";std::cerr << prefix << open_brakets << s << close_brakets << ": " << open_brakets << std::forward<T>(first);((std::cerr << ", " << std::forward<Args>(args)), ...);std::cerr << close_brakets << "\n";}#else# define debug(...) void(0)#endif// ! I/O utilities// __int128_tstd::ostream& operator<<(std::ostream& dest, __int128_t value) {std::ostream::sentry s(dest);if (s) {__uint128_t tmp = value < 0 ? -value : value;char buffer[128];char* d = std::end(buffer);do {--d;*d = "0123456789"[tmp % 10];tmp /= 10;} while (tmp != 0);if (value < 0) {--d;*d = '-';}int len = std::end(buffer) - d;if (dest.rdbuf()->sputn(d, len) != len) {dest.setstate(std::ios_base::badbit);}}return dest;}// __uint128_tstd::ostream& operator<<(std::ostream& dest, __uint128_t value) {std::ostream::sentry s(dest);if (s) {char buffer[128];char* d = std::end(buffer);do {--d;*d = "0123456789"[value % 10];value /= 10;} while (value != 0);int len = std::end(buffer) - d;if (dest.rdbuf()->sputn(d, len) != len) {dest.setstate(std::ios_base::badbit);}}return dest;}// pairtemplate <typename T, typename U>std::ostream& operator<<(std::ostream& out, const std::pair<T, U>& a) {return out << a.first << ' ' << a.second;}// tupletemplate <unsigned int N = 0, typename ...Args>std::ostream& operator<<(std::ostream& out, const std::tuple<Args...>& a) {if constexpr (N >= std::tuple_size_v<std::tuple<Args...>>) {return out;} else {out << std::get<N>(a);if constexpr (N + 1 < std::tuple_size_v<std::tuple<Args...>>) {out << ' ';}return operator<<<N + 1>(out, a);}}// vectortemplate <typename T>std::ostream& operator<<(std::ostream& out, const std::vector<T>& a) {for (auto it = a.begin(); it != a.end();) {out << *it;if (++it != a.end()) out << ' ';}return out;}// arraytemplate <typename T, size_t N>std::ostream& operator<<(std::ostream& out, const std::array<T, N>& a) {for (auto it = a.begin(); it != a.end();) {out << *it;if (++it != a.end()) out << ' ';}return out;}inline void print() { std::cout << '\n'; }template <typename Head, typename... Tail>inline void print(const Head& head, const Tail &...tails) {std::cout << head;if (sizeof...(tails)) std::cout << ' ';print(tails...);}template <typename Iterable>auto print_all(const Iterable& v, std::string sep = " ", std::string end = "\n") -> decltype(std::cout << *v.begin(), void()) {for (auto it = v.begin(); it != v.end();) {std::cout << *it;if (++it != v.end()) std::cout << sep;}std::cout << end;}__int128_t parse_i128(std::string& s) {__int128_t ret = 0;for (int i = 0; i < int(s.size()); i++) if ('0' <= s[i] and s[i] <= '9') ret = 10 * ret + s[i] - '0';if (s[0] == '-') ret = -ret;return ret;}__uint128_t parse_u128(std::string& s) {__uint128_t ret = 0;for (int i = 0; i < int(s.size()); i++) if ('0' <= s[i] and s[i] <= '9') ret = 10 * ret + s[i] - '0';return ret;}// __int128_tstd::istream& operator>>(std::istream& in, __int128_t& v) {std::string s;in >> s;v = parse_i128(s);return in;}// __uint128_tstd::istream& operator>>(std::istream& in, __uint128_t& v) {std::string s;in >> s;v = parse_u128(s);return in;}// pairtemplate <typename T, typename U>std::istream& operator>>(std::istream& in, std::pair<T, U>& a) {return in >> a.first >> a.second;}// tupletemplate <unsigned int N = 0, typename ...Args>std::istream& operator>>(std::istream& in, std::tuple<Args...>& a) {if constexpr (N >= std::tuple_size_v<std::tuple<Args...>>) {return in;} else {return operator>><N + 1>(in >> std::get<N>(a), a);}}// vectortemplate <typename T>std::istream& operator>>(std::istream& in, std::vector<T>& a) {for (auto it = a.begin(); it != a.end(); ++it) in >> *it;return in;}// arraytemplate <typename T, size_t N>std::istream& operator>>(std::istream& in, std::array<T, N>& a) {for (auto it = a.begin(); it != a.end(); ++it) in >> *it;return in;}template <typename ...Args>void read(Args &...args) {(std::cin >> ... >> args);}// ! integral utilities// Returns pow(-1, n)template <typename T>constexpr inline int pow_m1(T n) {return -(n & 1) | 1;}// Returns pow(-1, n)template <>constexpr inline int pow_m1<bool>(bool n) {return -int(n) | 1;}// Returns floor(x / y)template <typename T>constexpr inline T fld(const T x, const T y) {return (x ^ y) >= 0 ? x / y : (x - (y + pow_m1(y >= 0))) / y;}template <typename T>constexpr inline T cld(const T x, const T y) {return (x ^ y) <= 0 ? x / y : (x + (y + pow_m1(y >= 0))) / y;}template <typename T, suisen::constraints_t<suisen::is_nbit<T, 16>> = nullptr>__attribute__((target("popcnt"))) constexpr inline int popcount(const T x) { return _mm_popcnt_u32(x); }template <typename T, suisen::constraints_t<suisen::is_nbit<T, 32>> = nullptr>__attribute__((target("popcnt"))) constexpr inline int popcount(const T x) { return _mm_popcnt_u32(x); }template <typename T, suisen::constraints_t<suisen::is_nbit<T, 64>> = nullptr>__attribute__((target("popcnt"))) constexpr inline int popcount(const T x) { return _mm_popcnt_u64(x); }template <typename T, suisen::constraints_t<suisen::is_nbit<T, 16>> = nullptr>constexpr inline int count_lz(const T x) { return x ? __builtin_clz(x) : suisen::bit_num<T>; }template <typename T, suisen::constraints_t<suisen::is_nbit<T, 32>> = nullptr>constexpr inline int count_lz(const T x) { return x ? __builtin_clz(x) : suisen::bit_num<T>; }template <typename T, suisen::constraints_t<suisen::is_nbit<T, 64>> = nullptr>constexpr inline int count_lz(const T x) { return x ? __builtin_clzll(x) : suisen::bit_num<T>; }template <typename T, suisen::constraints_t<suisen::is_nbit<T, 16>> = nullptr>constexpr inline int count_tz(const T x) { return x ? __builtin_ctz(x) : suisen::bit_num<T>; }template <typename T, suisen::constraints_t<suisen::is_nbit<T, 32>> = nullptr>constexpr inline int count_tz(const T x) { return x ? __builtin_ctz(x) : suisen::bit_num<T>; }template <typename T, suisen::constraints_t<suisen::is_nbit<T, 64>> = nullptr>constexpr inline int count_tz(const T x) { return x ? __builtin_ctzll(x) : suisen::bit_num<T>; }template <typename T>constexpr inline int floor_log2(const T x) { return suisen::bit_num<T> -1 - count_lz(x); }template <typename T>constexpr inline int ceil_log2(const T x) { return floor_log2(x) + ((x & -x) != x); }template <typename T>constexpr inline int kth_bit(const T x, const unsigned int k) { return (x >> k) & 1; }template <typename T>constexpr inline int parity(const T x) { return popcount(x) & 1; }// ! containertemplate <typename T, typename Comparator, suisen::constraints_t<suisen::is_comparator<Comparator, T>> = nullptr>auto priqueue_comp(const Comparator comparator) {return std::priority_queue<T, std::vector<T>, Comparator>(comparator);}template <typename Iterable>auto isize(const Iterable& iterable) -> decltype(int(iterable.size())) {return iterable.size();}template <typename T, typename Gen, suisen::constraints_t<suisen::is_same_as_invoke_result<T, Gen, int>> = nullptr>auto generate_vector(int n, Gen generator) {std::vector<T> v(n);for (int i = 0; i < n; ++i) v[i] = generator(i);return v;}template <typename T>auto generate_range_vector(T l, T r) {return generate_vector(r - l, [l](int i) { return l + i; });}template <typename T>auto generate_range_vector(T n) {return generate_range_vector(0, n);}template <typename T>void sort_unique_erase(std::vector<T>& a) {std::sort(a.begin(), a.end());a.erase(std::unique(a.begin(), a.end()), a.end());}template <typename InputIterator, typename BiConsumer>auto foreach_adjacent_values(InputIterator first, InputIterator last, BiConsumer f) -> decltype(f(*first++, *last), void()) {if (first != last) for (auto itr = first, itl = itr++; itr != last; itl = itr++) f(*itl, *itr);}template <typename Container, typename BiConsumer>auto foreach_adjacent_values(Container c, BiConsumer f) -> decltype(c.begin(), c.end(), void()) {foreach_adjacent_values(c.begin(), c.end(), f);}// ! other utilities// x <- min(x, y). returns true iff `x` has chenged.template <typename T>inline bool chmin(T& x, const T& y) {if (y >= x) return false;x = y;return true;}// x <- max(x, y). returns true iff `x` has chenged.template <typename T>inline bool chmax(T& x, const T& y) {if (y <= x) return false;x = y;return true;}template <typename T, std::enable_if_t<std::is_integral_v<T>, std::nullptr_t> = nullptr>std::string bin(T val, int bit_num = -1) {std::string res;if (bit_num >= 0) {for (int bit = bit_num; bit-- > 0;) res += '0' + ((val >> bit) & 1);} else {for (; val; val >>= 1) res += '0' + (val & 1);std::reverse(res.begin(), res.end());}return res;}template <typename T, std::enable_if_t<std::is_integral_v<T>, std::nullptr_t> = nullptr>std::vector<T> digits_low_to_high(T val, T base = 10) {std::vector<T> res;for (; val; val /= base) res.push_back(val % base);if (res.empty()) res.push_back(T{ 0 });return res;}template <typename T, std::enable_if_t<std::is_integral_v<T>, std::nullptr_t> = nullptr>std::vector<T> digits_high_to_low(T val, T base = 10) {auto res = digits_low_to_high(val, base);std::reverse(res.begin(), res.end());return res;}template <typename T>std::string join(const std::vector<T>& v, const std::string& sep, const std::string& end) {std::ostringstream ss;for (auto it = v.begin(); it != v.end();) {ss << *it;if (++it != v.end()) ss << sep;}ss << end;return ss.str();}namespace suisen {}using namespace suisen;using namespace std;struct io_setup {io_setup(int precision = 20) {std::ios::sync_with_stdio(false);std::cin.tie(nullptr);std::cout << std::fixed << std::setprecision(precision);}} io_setup_{};// ! code from here#include <atcoder/modint>using mint = atcoder::modint1000000007;std::istream& operator>>(std::istream& in, mint& a) {long long e; in >> e; a = e;return in;}std::ostream& operator<<(std::ostream& out, const mint& a) {out << a.val();return out;}#include <utility>namespace suisen {template <typename T, typename U>std::pair<T, U>& operator+=(std::pair<T, U> &p1, const std::pair<T, U> &p2) {p1.first += p2.first, p1.second += p2.second;return p1;}template <typename T, typename U>std::pair<T, U> operator+(const std::pair<T, U> &p1, const std::pair<T, U> &p2) {return {p1.first + p2.first, p1.second + p2.second};}template <typename T, typename U>std::pair<T, U>& operator-=(std::pair<T, U> &p1, const std::pair<T, U> &p2) {p1.first -= p2.first, p1.second -= p2.second;return p1;}template <typename T, typename U>std::pair<T, U> operator-(const std::pair<T, U> &p1, const std::pair<T, U> &p2) {return {p1.first - p2.first, p1.second - p2.second};}template <typename T, typename U, typename V>std::pair<T, U>& operator*=(std::pair<T, U> &p, const V m) {p.first *= m, p.second *= m;return p;}template <typename T, typename U, typename V>std::pair<T, U> operator*(const std::pair<T, U> &p, const V m) {return {p.first * m, p.second * m};}template <typename T, typename U, typename V>std::pair<T, U> operator*(const V m, const std::pair<T, U> &p) {return {p.first * m, p.second * m};}} // namespace suisenstruct ISP {static constexpr int L_CURVE = +1; // +---------------+ Z is in 'a' => ISP = +1static constexpr int R_CURVE = -1; // |aaaaaaaaaaaaaaa| Z is in 'b' => ISP = -1static constexpr int FRONT = +2; // |ddd X eee Y ccc| Z is in 'c' => ISP = +2static constexpr int BACK = -2; // |bbbbbbbbbbbbbbb| Z is in 'd' => ISP = -2static constexpr int MIDDLE = 0; // +---------------+ Z is in 'e' => ISP = 0};struct Sign {static constexpr int NEGATIVE = -1;static constexpr int ZERO = 0;static constexpr int POSITIVE = +1;};int sgn(i128 x) {return x > 0 ? Sign::POSITIVE : x < 0 ? Sign::NEGATIVE : Sign::ZERO;}i128 dot(const pair<long long, long long>& a, const pair<long long, long long>& b) {return (i128) a.first * b.first + (i128) a.second * b.second;}i128 det(const pair<long long, long long>& a, const pair<long long, long long>& b) {return (i128) a.first * b.second - (i128) a.second * b.first;}int isp(const pair<long long, long long>& a, const pair<long long, long long>& b, const pair<long long, long long>& c) {pair<long long, long long> ab = b - a, ac = c - a;int s = sgn(det(ab, ac));if (s == Sign::POSITIVE) return ISP::L_CURVE;if (s == Sign::NEGATIVE) return ISP::R_CURVE;if (sgn(dot(ab, ac)) == Sign::NEGATIVE) return ISP::BACK;pair<long long, long long> ba = a - b, bc = c - b;if (sgn(dot(ba, bc)) == Sign::NEGATIVE) return ISP::FRONT;return ISP::MIDDLE;}std::vector<int> convex_hull(const std::vector<std::pair<long long, long long>>& points) {const int n = points.size();std::vector<int> sorted(n);std::iota(sorted.begin(), sorted.end(), 0);std::sort(sorted.begin(), sorted.end(),[&points](int i, int j) {auto& a = points[i], & b = points[j];return a.first == b.first ? a.second < b.second : a.first < b.first;});std::vector<char> used(n, false);sorted.resize(2 * n - 1);std::copy(sorted.rbegin() + n, sorted.rend(), sorted.begin() + n);std::vector<int> res;res.reserve(n);int first = sorted[0], last = sorted[n - 1];auto isp_pos = [](i128 x1, i128 y1, i128 x2, i128 y2) -> bool {i128 det = x1 * y2 - y1 * x2;return det > 0;};for (int k : sorted) {if (k != first and used[k]) continue;for (int sz = res.size(); sz >= 2; --sz) {int i = res[sz - 2], j = res[sz - 1];if (j == last) break;i128 ab_x = points[j].first - points[i].first, ab_y = points[j].second - points[i].second;i128 bc_x = points[k].first - points[j].first, bc_y = points[k].second - points[j].second;if (isp_pos(ab_x, ab_y, bc_x, bc_y)) break;res.pop_back(), used[j] = false;}if (not used[k]) res.push_back(k);used[k] = true;}return res;}i128 count_lattice_points(const std::vector<std::pair<long long, long long>>& polygon) {const int n = polygon.size();i128 s = 0, b = 0;for (int i = 0; i < n; ++i) {auto [x1, y1] = polygon[i];auto [x2, y2] = polygon[(i + 1) % n];s += (i128) x1 * y2 - (i128) y1 * x2;b += std::abs(std::gcd(x2 - x1, y2 - y1));}return (s + 2 + b) / 2;}bool compare_by_atan2(const std::pair<long long, long long>& p, const std::pair<long long, long long>& q) {const auto& [x1, y1] = p;const auto& [x2, y2] = q;if ((y1 < 0) xor (y2 < 0)) return y1 < y2;if ((x1 < 0) xor (x2 < 0)) return (y1 >= 0) xor (x1 < x2);if (x1 == 0 and y1 == 0) return true;if (x2 == 0 and y2 == 0) return false;return ((i128) y1 * x2 < (i128) y2* x1);}void sort_points_by_argument(std::vector<std::pair<long long, long long>> &points) {std::sort(points.begin(), points.end(), compare_by_atan2);}int main() {input(int, n);vector<pair<long long, long long>> ps(n);read(ps);ps.erase(remove_if(all(ps), [&](pair<long long, long long> x) { return x.first == 0 and x.second == 0; }), ps.end());sort_points_by_argument(ps);n = ps.size();if (n == 0) {print(1);return 0;}vector<pair<long long, long long>> p;rep(i, n) {if (p.size() and not compare_by_atan2(p.back(), ps[i])) {p.back().first += ps[i].first;p.back().second += ps[i].second;} else {p.push_back({ ps[i].first, ps[i].second });}}n = p.size();rep(i, n) {auto x = p[i];p.push_back(x);}pair<long long, long long> sum{ 0, 0 };rep(i, n) sum += p[i];vector<pair<long long, long long>> outer{ { 0, 0 } };pair<long long, long long> d;d = { 0, 0 };for (int l = 0, r = 0; l < n; ++l) {while (r < l + n and isp(p[l], { 0, 0 }, p[r]) != ISP::L_CURVE) {d += p[r];outer.push_back(d);outer.push_back(sum - d);++r;}assert(l < r);outer.push_back(d - p[l]);outer.push_back(sum - d + p[l]);d -= p[l];}d = { 0, 0 };for (int l = 0, r = 0; l < n; ++l) {while (r < l + n and isp(p[l], { 0, 0 }, p[r]) != ISP::L_CURVE and isp(p[l], { 0, 0 }, p[r]) != ISP::FRONT) {d += p[r];outer.push_back(d);outer.push_back(sum - d);++r;}assert(l < r);outer.push_back(d - p[l]);outer.push_back(sum - d + p[l]);d -= p[l];}reverse(all(p));d = { 0, 0 };for (int l = 0, r = 0; l < n; ++l) {while (r < l + n and isp(p[l], { 0, 0 }, p[r]) != ISP::R_CURVE) {d += p[r];outer.push_back(d);outer.push_back(sum - d);++r;}assert(l < r);outer.push_back(d - p[l]);outer.push_back(sum - d + p[l]);d -= p[l];}d = { 0, 0 };for (int l = 0, r = 0; l < n; ++l) {while (r < l + n and isp(p[l], { 0, 0 }, p[r]) != ISP::ISP::R_CURVE and isp(p[l], { 0, 0 }, p[r]) != ISP::FRONT) {d += p[r];outer.push_back(d);outer.push_back(sum - d);++r;}assert(l < r);outer.push_back(d - p[l]);outer.push_back(sum - d + p[l]);d -= p[l];}vector<pair<long long, long long>> convex;for (int i : convex_hull(outer)) convex.push_back(outer[i]);print(mint(count_lattice_points(convex)));return 0;}