func_code_string: #include <bits/stdc++.h>   const int BARIER = 0;   class Rng {    private:     static std::mt19937 engine;       public:     static std::mt19937& get_engine() { return engine; }     template <typename T>     static void set_seed(T const& seed) {       engine = std::mt19937(seed);     }     static void timebased_seed() {       engine = std::mt19937(           std::chrono::duration_cast<std::chrono::nanoseconds>(               std::chrono::high_resolution_clock::now().time_since_epoch())               .count());     }     template <typename T>     static typename std::enable_if<std::is_integral<T>::value, T>::type uniform(         T l, T r) {       return std::uniform_int_distribution<T>(l, r)(engine);     }     template <typename T>     static typename std::enable_if<std::is_floating_point<T>::value, T>::type     uniform(T l, T r) {       return std::uniform_real_distribution<T>(l, r)(engine);     }   };   std::mt19937 Rng::engine(       std::chrono::duration_cast<std::chrono::nanoseconds>(           std::chrono::high_resolution_clock::now().time_since_epoch())           .count());   class Timer {    public:     template <typename S, typename T, typename... U>     static S execute_timed(T func, std::string const& name, U&&... u) {       auto time_begin = std::chrono::high_resolution_clock::now();       S ret = func(std::forward<U>(u)...);       auto time_end = std::chrono::high_resolution_clock::now();       auto timespan = std::chrono::duration_cast<std::chrono::nanoseconds>(           time_end - time_begin);       std::cerr <<  Execution of    << name <<    took   << std::fixed                 << std::setprecision(6) << timespan.count() * 1e-9 <<   n ;       return ret;     }   };   using namespace std;   class Bigint_base10 {    public:     static constexpr int64_t BASE = 1e18;     static constexpr int DIGITS = 18;       private:     bool is_neg;     vector<int64_t> data;       public:     Bigint_base10() : is_neg(false), data(1, 0) {}     Bigint_base10(int64_t const& val) : is_neg(val < 0) {       int64_t abs_val = abs(val);       if (abs_val < BASE) {         data = {abs_val};       } else {         data = {abs_val % BASE, abs_val / BASE};       }     }     Bigint_base10 operator+(Bigint_base10 const& o) const {       Bigint_base10 ret;       ret.is_neg = is_neg;       ret.data.assign(1 + max(data.size(), o.data.size()), 0);       copy(data.begin(), data.end(), ret.data.begin());       int64_t carry = 0;       for (unsigned int i = 0; i < o.data.size(); ++i) {         ret.data[i] += o.data[i] + carry;         carry = 0;         if (ret.data[i] >= BASE) {           carry = 1;           ret.data[i] -= BASE;         }       }       for (unsigned int i = o.data.size(); carry; ++i) {         ret.data[i] += carry;         carry = 0;         if (ret.data[i] >= BASE) {           carry = 1;           ret.data[i] -= BASE;         }       }       return ret.trim();     }     Bigint_base10 operator*(int64_t const& o) const {       if (o == 0) {         return Bigint_base10(0);       }       if (o < 0) {         return operator*(-o).negate();       }       if (o & 1) {         return operator+(operator*(o - 1));       }       return operator+(*this) * (o / 2);     }     Bigint_base10& operator+=(Bigint_base10 const& o) {       *this = operator+(o);       return *this;     }     Bigint_base10& operator*=(int64_t const& o) {       *this = operator*(o);       return *this;     }     Bigint_base10& trim() {       while (data.size() > 1 && data.back() == 0) {         data.pop_back();       }       return *this;     }     bool is_zero() const {       for (auto const& e : data)         if (e) return false;       return true;     }     Bigint_base10& negate() {       is_neg = !is_neg;       if (is_zero()) is_neg = false;       return *this;     }     friend ostream& operator<<(ostream& o, Bigint_base10 const& b) {       if (b.is_neg) o <<  - ;       o << b.data.back();       o << setfill( 0 );       for (auto it = next(b.data.rbegin()); it != b.data.rend(); ++it) {         o << setw(9) << *it;       }       o << setw(0) << setfill(   );       return o;     }     friend istream& operator>>(istream& in, Bigint_base10& b) {       static string tmp;       in >> tmp;       if (tmp[0] ==  - ) {         b.is_neg = true;         tmp = tmp.substr(1, -1);       } else {         b.is_neg = false;       }       b.data.resize((tmp.size() + DIGITS - 1) / DIGITS);       unsigned int i, j;       for (i = tmp.size() - DIGITS, j = 0; i > 0; i -= DIGITS, ++j) {         b.data[j] = stoll(tmp.substr(i, DIGITS));       }       b.data[j] = stoll(tmp.substr(0, i + DIGITS));       return in;     }   };   template <size_t len>   struct Bigint_Fixedsize {     unsigned int data[len];     static constexpr unsigned int bits = 31;     Bigint_Fixedsize() { memset(data, 0, sizeof(data)); }     Bigint_Fixedsize(long long const& _a) {       memset(data, 0, sizeof(data));       unsigned long long a = _a;       data[0] = a & ((1u << bits) - 1);       data[1] = a >> bits;       data[1] &= ~(1u << bits);       if (a > ~a) {         for (size_t i = 2; i < len; ++i) {           data[i] = (1u << bits) - 1;         }       }     }     Bigint_Fixedsize& operator+=(Bigint_Fixedsize const& o) {       unsigned int carry = 0;       for (size_t i = 0; i < len; ++i) {         data[i] += o.data[i] + carry;         carry = data[i] >> bits;         data[i] &= ~(1u << bits);       }       return *this;     }     Bigint_Fixedsize& operator-=(Bigint_Fixedsize const& o) {       unsigned int carry = 0;       for (size_t i = 0; i < len; ++i) {         data[i] -= o.data[i] + carry;         carry = data[i] >> bits;         data[i] &= ~(1u << bits);       }       return *this;     }     Bigint_Fixedsize operator+(Bigint_Fixedsize const& o) const {       Bigint_Fixedsize ret(*this);       ret += o;       return ret;     }     Bigint_Fixedsize operator-(Bigint_Fixedsize const& o) const {       Bigint_Fixedsize ret(*this);       ret -= o;       return ret;     }     void multo(Bigint_Fixedsize const& o, Bigint_Fixedsize& ret) const {       static unsigned int tmp[len + 1];       memset(tmp, 0, sizeof(tmp));       for (size_t i = 0; i < len; ++i) {         unsigned long long val = 0;         for (size_t j = 0; j < len - i; ++j) {           val += data[i] * (unsigned long long)o.data[j] + tmp[i + j];           tmp[i + j] = val & ((1u << bits) - 1);           val >>= bits;         }       }       memcpy(ret.data, tmp, sizeof(ret.data));     }     Bigint_Fixedsize& operator*=(Bigint_Fixedsize const& o) {       multo(o, *this);       return *this;     }     Bigint_Fixedsize operator*(Bigint_Fixedsize const& o) const {       Bigint_Fixedsize ret;       multo(o, ret);       return ret;     }     Bigint_Fixedsize& negate() {       unsigned int carry = 0;       for (size_t i = 0; i < len; ++i) {         data[i] = ~data[i] + !carry;         carry = (data[i] >> bits);         data[i] &= ~(1u << bits);       }       return *this;     }     Bigint_Fixedsize operator-() const {       Bigint_Fixedsize ret(*this);       ret.negate();       return ret;     }     bool operator<(Bigint_Fixedsize const& o) const {       if (data[len - 1] >> (bits - 1) != o.data[len - 1] >> (bits - 1)) {         return data[len - 1] >> (bits - 1);       }       for (size_t i = len - 1; ~i; --i) {         if (data[i] != o.data[i]) return data[i] < o.data[i];       }       return false;     }     bool operator>(Bigint_Fixedsize const& o) const { return o < *this; }     bool operator<=(Bigint_Fixedsize const& o) const { return !(operator>(o)); }     bool operator>=(Bigint_Fixedsize const& o) const { return !(operator<(o)); }     bool operator==(Bigint_Fixedsize const& o) const {       for (size_t i = 0; i < len; ++i) {         if (data[i] != o.data[i]) return false;       }       return true;     }     bool operator!=(Bigint_Fixedsize const& o) const { return !operator==(o); }     bool operator!() const {       for (size_t i = 0; i < len; ++i) {         if (data[i]) return false;       }       return true;     }     bool is_negative() const { return data[len - 1] >> (bits - 1); }     void print_binary(ostream& o, Bigint_Fixedsize const& b) {       o <<  [ ;       for (size_t i = len; i > 0; --i) {         o << bitset<bits>(b.data[i - 1]);       }       o <<  ] ;     }     friend ostream& operator<<(ostream& o, Bigint_Fixedsize const& b) {       if (b.is_negative()) {         return o <<  -  << -b <<   n ;       }       Bigint_base10 ret(0);       int64_t base = 1u << bits;       for (int i = len - 1; i >= 0; --i) {         ret *= base;         ret += Bigint_base10(b.data[i]);       }       o << ret;       return o;     }     explicit operator long double() const {       if (is_negative()) {         return (long double)operator-();       }       long double ret = 0.0;       long double base = 1u << bits;       for (int i = len - 1; i >= 0; --i) {         ret = ret * base + data[i];       }       return ret;     }     friend istream& operator>>(istream& i, Bigint_Fixedsize& b) {       int64_t tmp;       i >> tmp;       b = Bigint_Fixedsize(tmp);       return i;     }   };   template <size_t len>   struct Bigint_Fixedsize_Fast {     unsigned int data[len];     uint16_t siz;     bool sign;     static constexpr unsigned int bits = 32;     Bigint_Fixedsize_Fast() {       data[0] = 0;       siz = 1;       sign = false;     }     Bigint_Fixedsize_Fast(long long a) {       sign = false;       if (a < 0) {         sign = true;         a = -a;       }       siz = 0;       do {         long long b = a >> bits;         data[siz] = a - (b << bits);         a = b;         ++siz;       } while (a);     }     void trim() {       while (siz > 1 && !data[siz - 1]) --siz;     }     int comp_unsigned(Bigint_Fixedsize_Fast const& o) const {       uint16_t lim = min(siz, o.siz);       for (unsigned int i = lim; i < siz; ++i) {         if (data[i]) {           return 1;         }       }       for (unsigned int i = lim; i < o.siz; ++i) {         if (o.data[i]) {           return -1;         }       }       for (unsigned int i = lim - 1; i + 1; --i) {         if (data[i] != o.data[i]) {           return data[i] < o.data[i] ? -1 : 1;         }       }       return 0;     }     int comp(Bigint_Fixedsize_Fast const& o) const {       int sign_mul = 1 - 2 * sign;       if (sign != o.sign) {         return sign_mul;       }       return sign_mul * comp_unsigned(o);     }     bool operator<(Bigint_Fixedsize_Fast const& o) const { return comp(o) < 0; }     bool operator>(Bigint_Fixedsize_Fast const& o) const { return comp(o) > 0; }     bool operator<=(Bigint_Fixedsize_Fast const& o) const { return comp(o) <= 0; }     bool operator>=(Bigint_Fixedsize_Fast const& o) const { return comp(o) >= 0; }     bool operator==(Bigint_Fixedsize_Fast const& o) const { return comp(o) == 0; }     bool operator!=(Bigint_Fixedsize_Fast const& o) const { return comp(o) != 0; }     bool operator!() const { return operator==(ZERO); }     Bigint_Fixedsize_Fast operator-() const {       Bigint_Fixedsize_Fast ret(*this);       if (!!ret) {         ret.sign ^= 1;       }       return ret;     }     Bigint_Fixedsize_Fast operator*(Bigint_Fixedsize_Fast const& o) const {       Bigint_Fixedsize_Fast ret;       ret.siz = min(siz + o.siz, (int)len);       ret.sign = (sign != o.sign);       fill(ret.data, ret.data + ret.siz, 0);       for (unsigned int i = 0; i < siz; ++i) {         unsigned long long carry = 0, carry_2;         for (unsigned int j = 0; j < o.siz; ++j) {           carry += data[i] * (unsigned long long)o.data[j] + ret.data[i + j];           carry_2 = carry >> bits;           ret.data[i + j] = carry - (carry_2 << bits);           carry = carry_2;         }         for (unsigned int j = i + o.siz; carry; ++j) {           carry += ret.data[j];           carry_2 = carry >> bits;           ret.data[j] = carry - (carry_2 << bits);           carry = carry_2;         }       }       ret.trim();       return ret;     }     Bigint_Fixedsize_Fast& operator*=(Bigint_Fixedsize_Fast const& o) {       *this = operator*(o);       return *this;     }     static void unsigned_add(Bigint_Fixedsize_Fast& ret,                              Bigint_Fixedsize_Fast const& A,                              Bigint_Fixedsize_Fast const& B) {       const Bigint_Fixedsize_Fast *a = &A, *b = &B;       if (a->siz < b->siz) swap(a, b);       ret.sign = A.sign;       unsigned long long carry = 0, carry_2;       unsigned int j;       for (j = 0; j < b->siz; ++j) {         carry += (unsigned long long)a->data[j] + (unsigned long long)b->data[j];         carry_2 = carry >> bits;         ret.data[j] = carry - (carry_2 << bits);         carry = carry_2;       }       for (; j < a->siz; ++j) {         carry += a->data[j];         carry_2 = carry >> bits;         ret.data[j] = carry - (carry_2 << bits);         carry = carry_2;       }       if (carry) {         ret.data[j++] = carry;       }       ret.siz = j;       ret.trim();     }     static void unsigned_subtract(Bigint_Fixedsize_Fast& ret,                                   Bigint_Fixedsize_Fast const& A,                                   Bigint_Fixedsize_Fast const& B) {       int com = A.comp_unsigned(B);       if (com == 0) {         ret.sign = false;         ret.siz = 1;         ret.data[0] = 0;         return;       }       ret.sign = A.sign;       const Bigint_Fixedsize_Fast *a = &A, *b = &B;       if (com < 0) {         ret.sign ^= true;         swap(a, b);       }       unsigned int min_siz = min(A.siz, B.siz);       unsigned long long carry = 0, carry_2;       unsigned int j;       for (j = 0; j < min_siz; ++j) {         carry += (unsigned long long)a->data[j] - (unsigned long long)b->data[j];         carry_2 = carry >> bits;         ret.data[j] = carry - (carry_2 << bits);         carry = -(carry_2 & 1u);       }       for (; carry; ++j) {         carry += a->data[j];         carry_2 = carry >> bits;         ret.data[j] = carry - (carry_2 << bits);         carry = -(carry_2 & 1u);       }       copy(a->data + j, a->data + a->siz, ret.data + j);       ret.siz = a->siz;       ret.trim();     }     static void add(Bigint_Fixedsize_Fast& ret, Bigint_Fixedsize_Fast const& A,                     Bigint_Fixedsize_Fast const& B) {       if (A.sign == B.sign) {         unsigned_add(ret, A, B);       } else {         unsigned_subtract(ret, A, B);       }     }     static void sub(Bigint_Fixedsize_Fast& ret, Bigint_Fixedsize_Fast const& A,                     Bigint_Fixedsize_Fast const& B) {       if (A.sign != B.sign) {         unsigned_add(ret, A, B);       } else {         unsigned_subtract(ret, A, B);       }     }     Bigint_Fixedsize_Fast operator+(Bigint_Fixedsize_Fast const& o) const {       Bigint_Fixedsize_Fast ret;       add(ret, *this, o);       return ret;     }     Bigint_Fixedsize_Fast& operator+=(Bigint_Fixedsize_Fast const& o) {       add(*this, *this, o);       return *this;     }     Bigint_Fixedsize_Fast operator-(Bigint_Fixedsize_Fast const& o) const {       Bigint_Fixedsize_Fast ret;       sub(ret, *this, o);       return ret;     }     Bigint_Fixedsize_Fast operator-=(Bigint_Fixedsize_Fast const& o) {       sub(*this, *this, o);       return *this;     }     void print_binary(ostream& o, Bigint_Fixedsize_Fast const& b) {       o <<  [ ;       o << sign <<  /  << len <<  / ;       for (size_t i = siz; i > 0; --i) {         o << bitset<bits>(b.data[i - 1]);       }       o <<  ] ;     }     friend ostream& operator<<(ostream& o, Bigint_Fixedsize_Fast const& b) {       if (b.sign) {         return o <<  -  << -b;       }       Bigint_base10 ret(0);       int64_t base = 1ll << bits;       for (int i = b.siz - 1; i >= 0; --i) {         ret *= base;         ret += Bigint_base10(b.data[i]);       }       o << ret;       return o;     }     explicit operator long double() const {       if (sign) {         return (long double)operator-();       }       long double ret = 0.0;       long double base = 1ll << bits;       for (int i = siz - 1; i >= 0; --i) {         ret = ret * base + data[i];       }       return ret;     }     friend istream& operator>>(istream& i, Bigint_Fixedsize_Fast& b) {       int64_t tmp;       i >> tmp;       b = Bigint_Fixedsize_Fast(tmp);       return i;     }     static const Bigint_Fixedsize_Fast ZERO;   };   template <size_t len>   const Bigint_Fixedsize_Fast<len> Bigint_Fixedsize_Fast<len>::ZERO(0);   template <typename FLOAT>   class Lp_Seidel {    private:     vector<FLOAT> proj_down(vector<FLOAT> const& vec, vector<FLOAT> const& plane,                             size_t j) {       vector<FLOAT> ret(vec.size() - 1);       if (plane[j] < FLOAT(0)) {         for (size_t i = 0; i + 1 < vec.size(); ++i) {           ret[i] = vec[j] * plane[i + (i >= j)] - vec[i + (i >= j)] * plane[j];         }       } else {         for (size_t i = 0; i + 1 < vec.size(); ++i) {           ret[i] = vec[i + (i >= j)] * plane[j] - vec[j] * plane[i + (i >= j)];         }       }       return ret;     }     vector<FLOAT> proj_up(vector<FLOAT> const& vec, vector<FLOAT> const& plane,                           size_t j) {       vector<FLOAT> ret(vec.size() + 1);       copy(vec.begin(), vec.begin() + j, ret.begin());       copy(vec.begin() + j, vec.end(), ret.begin() + j + 1);       for (size_t i = 0; i < vec.size(); ++i) {         ret[j] += vec[i] * plane[i + (i >= j)];       }       FLOAT denom = plane[j];       if (denom < FLOAT(0)) {         denom = -denom;       }       for (size_t i = 0; i < vec.size(); ++i) {         ret[i + (i >= j)] *= denom;       }       if (plane[j] >= FLOAT(0)) {         ret[j] = -ret[j];       }       return ret;     }     FLOAT planescal(vector<FLOAT> const& x, vector<FLOAT> const& a) {       FLOAT ret = 0;       for (size_t i = 0; i < x.size(); ++i) {         ret += x[i] * a[i];       }       return ret;     }     vector<FLOAT> solve(vector<vector<FLOAT>> const& A, vector<FLOAT> const& c,                         int d, FLOAT const& barier_loc) {       int n = A.size();       if (d == 1) {         vector<FLOAT> ret(2);         ret[0] = (c[0] < FLOAT(0) ? -barier_loc : barier_loc);         ret[1] = 1ull;         for (int i = 0; i < n; ++i) {           if (ret[0] * A[i][0] + ret[1] * A[i].back() > FLOAT(0)) {             if (!A[i][0]) {               do {               } while (0);               return vector<FLOAT>();             }             ret[0] = -A[i].back();             ret[1] = A[i][0];             if (ret[1] < FLOAT(0)) {               ret[1] = -ret[1];               ret[0] = -ret[0];             }             do {             } while (0);           }         }         for (int i = 0; i < n; ++i) {           if (ret[0] * A[i][0] + ret[1] * A[i].back() > FLOAT(0)) {             do {             } while (0);             return vector<FLOAT>();           }         }         return ret;       }       FLOAT barier_next = barier_loc * barier_loc;       vector<FLOAT> x(d + 1);       for (int i = 0; i < d; ++i) {         x[i] = (c[i] < FLOAT(0) ? -barier_loc : barier_loc);       }       x.back() = FLOAT(1);       for (size_t i = 0; i < A.size(); ++i) {         if (planescal(x, A[i]) > FLOAT(0)) {           int k = 0;           while (k < d && !A[i][k]) ++k;           if (k == d) {             do {             } while (0);             return vector<FLOAT>();           }           vector<vector<FLOAT>> A2(i);           for (size_t j = 0; j < A2.size(); ++j) {             A2[j] = proj_down(A[j], A[i], k);           }           shuffle(A2.begin(), A2.end(), Rng::get_engine());           do {           } while (0);           vector<FLOAT> c2 = proj_down(c, A[i], k);           vector<FLOAT> x2 = solve(A2, c2, d - 1, barier_next);           if (x2.empty()) return x2;           x = proj_up(x2, A[i], k);           do {           } while (0);           do {           } while (0);           do {           } while (0);         }       }       return x;     }       public:     vector<FLOAT> solve(vector<vector<FLOAT>> const& A, vector<FLOAT> const& c,                         const FLOAT& barier = FLOAT((long long)1e9)) {       return solve(A, c, c.size(), barier);     }     vector<FLOAT> solve(vector<vector<FLOAT>> A, vector<FLOAT> const& b,                         vector<FLOAT> const& c) {       for (unsigned int i = 0; i < A.size(); ++i) {         A[i].push_back(-b[i]);       }       return solve(A, c);     }   };   template <typename Big_Int>   class Lp_Clarkson {    private:     vector<int> sample_subset(vector<int64_t> const& weight, unsigned int siz) {       int64_t total_weight = accumulate(weight.begin(), weight.end(), 0ll);       vector<int64_t> samples;       while (samples.size() < siz) {         int64_t new_sample = Rng::uniform<int64_t>(0, total_weight - 1);         if (find(samples.begin(), samples.end(), new_sample) == samples.end()) {           samples.push_back(new_sample);         }       }       sort(samples.begin(), samples.end());       vector<int> ret;       int64_t left_weight = 0;       for (unsigned int i = 0, j = 0; i < weight.size() && j < samples.size();) {         if (samples[j] < left_weight + weight[i]) {           ret.push_back(i);           ++j;         } else {           left_weight += weight[i];           ++i;         }       }       return ret;     }     bool is_satisfied(vector<Big_Int> const& x, vector<Big_Int> const& a) {       Big_Int ret = 0;       for (size_t i = 0; i < x.size(); ++i) {         ret += x[i] * a[i];       }       return ret <= Big_Int(0);     }     vector<Big_Int> solve(vector<vector<Big_Int>> const& A,                           vector<Big_Int> const& c,                           const unsigned int sample_size) {       Lp_Seidel<Big_Int> sub_lp;       if (A.size() < sample_size) {         return sub_lp.solve(A, c);       } else {         int equations = A.size();         int variables = c.size();         vector<int64_t> weight(equations, 1);         vector<Big_Int> x;         vector<vector<Big_Int>> subproblem_A;         vector<char> is_violated(equations, 0);         for (unsigned int iteration = 1;; ++iteration) {           subproblem_A.clear();           vector<int> subspace = sample_subset(weight, sample_size);           for (int const& e : subspace) {             subproblem_A.push_back(A[e]);           }           x = sub_lp.solve(subproblem_A, c);           if (x.empty()) {             return x;           }           int64_t total_violated = 0;           for (int i = 0; i < equations; ++i) {             is_violated[i] = !is_satisfied(x, A[i]);             if (is_violated[i]) {               total_violated += weight[i];             }           }           if (total_violated == 0) {             cerr <<  Iterations:   << iteration;             cerr <<  , max weight:   << *max_element(weight.begin(), weight.end())                  <<   n ;             break;           }           if (total_violated * 3 * variables <=               accumulate(weight.begin(), weight.end(), 0ll)) {             for (int i = 0; i < equations; ++i) {               if (is_violated[i]) {                 weight[i] *= 2;               }             }           }         }         return x;       }     }       public:     vector<Big_Int> solve(vector<vector<Big_Int>> const& A,                           vector<Big_Int> const& c) {       return solve(A, c, c.size() * c.size() * 4);     }     vector<Big_Int> solve(vector<vector<Big_Int>> A, vector<Big_Int> const& b,                           vector<Big_Int> const& c) {       for (unsigned int i = 0; i < A.size(); ++i) {         A[i].push_back(-b[i]);       }       return solve(A, c);     }   };   template <typename Big_Int>   void test_factorial(unsigned int n, bool debug = false) {     std::cout <<  Computing   << n <<  ! n ;     Big_Int val(1);     for (unsigned int i = 1; i <= n; ++i) {       val *= i;       if (debug) std::cerr << i <<   :   << val <<   n ;     }     std::cerr <<  Printing n ;     std::cout << val << endl;   }   template <typename Big_Int>   void test_addsub(int n) {     Big_Int a(5432123456789ll);     Big_Int b(9876543210123ll);     Big_Int c;     for (int it = 0; it < 4 * n; ++it) {       std::cout << a <<   +   << b <<   =   << a + b <<   n ;       std::cout << b <<   +   << a <<   =   << b + a <<   n ;       std::cout << a <<   -   << b <<   =   << a - b <<   n ;       std::cout << b <<   -   << a <<   =   << b - a <<   n ;       c = a;       c += b;       std::cout << a <<   +   << b <<   =   << c <<   n ;       c = b;       c += a;       std::cout << b <<   +   << a <<   =   << c <<   n ;       c = a;       c -= b;       std::cout << a <<   -   << b <<   =   << c <<   n ;       c = b;       c -= a;       std::cout << b <<   -   << a <<   =   << c <<   n ;       a = -a;       if (it % 4 == 3) {         a *= it;       } else {         swap(a, b);       }     }   }   template <typename Big_Int>   void test_addmul(int n, int k) {     std::cout <<  Addmul test   << n <<     << k <<   n ;     ;     Rng::set_seed(635241);     Big_Int ret(0);     for (int i = 0; i < n; ++i) {       Big_Int cur(1);       for (int j = 0; j < k; ++j) {         Big_Int mu(Rng::uniform(1ll, (long long)1e15));         cur *= mu;       }       ret += cur;     }     std::cout << ret <<   n ;   }   void test_timer() {     std::function<int64_t(int64_t)> fib = [&](int64_t x) {       return x < 2 ? x : fib(x - 1) + fib(x - 2);     };     Timer::execute_timed<int64_t>(fib,  Timer test , 35);     Timer::execute_timed<int64_t>(fib,  Timer test , 40);   }   template <typename Big_Int, typename Solver>   void test_lp(std::string const& path) {     std::cerr <<  LP Test:   << path <<   n ;     std::ifstream in;     in.open(path.c_str());     int variables, constraints;     in >> variables >> constraints;     std::vector<std::vector<Big_Int>> A(constraints,                                         std::vector<Big_Int>(variables));     std::vector<Big_Int> b(constraints), c(variables);     for (auto& e : c) in >> e;     for (int i = 0; i < constraints; ++i) {       for (auto& e : A[i]) in >> e;       in >> b[i];     }     std::function<std::vector<Big_Int>()> solve = [&]() {       Solver solver;       return solver.solve(A, b, c);     };     std::vector<Big_Int> solution =         Timer::execute_timed<vector<Big_Int>>(solve,  solve LP );     std::cerr <<  Solution: n ;     for (auto& e : solution) {       std::cerr << e <<    ;     }     cerr <<   n ;   }   template <typename Big_Int, typename Solver>   void test_enclosing_annulus(int n) {     cerr <<  Enclosing annulus test (  << n <<  ) n ;     cerr <<  Int:   << typeid(Big_Int).name()          <<  , Solver:   << typeid(Solver).name() <<   n ;     Rng::set_seed(1234);     vector<pair<int, int>> pts(n);     for (auto& e : pts) {       e.first = Rng::uniform(-10000, 10000);       e.second = Rng::uniform(-10000, 10000);     }     Rng::set_seed(24680);     vector<vector<Big_Int>> A;     vector<Big_Int> b, c;     c = {Big_Int(0), Big_Int(0), -1, 1};     for (auto const& e : pts) {       A.push_back({Big_Int(-2 * e.first), Big_Int(-2 * e.second), -1, 0});       b.emplace_back(-e.first * e.first - e.second * e.second);       A.push_back({Big_Int(2 * e.first), Big_Int(2 * e.second), 0, 1});       b.emplace_back(e.first * e.first + e.second * e.second);     }     std::function<std::vector<Big_Int>()> solve = [&]() {       Solver solver;       return solver.solve(A, b, c);     };     std::vector<Big_Int> solution =         Timer::execute_timed<vector<Big_Int>>(solve,  solve enclosing circle LP );     std::cerr <<  Solution: n ;     for (auto& e : solution) {       std::cerr << e <<    ;     }     cerr <<   n ;     if (!solution.empty()) {       Big_Int r_sq = solution[2] * solution[4] - solution[1] * solution[1] +                      solution[2] * solution[2];       Big_Int R_sq = solution[3] * solution[4] - solution[1] * solution[1] +                      solution[2] * solution[2];       Big_Int area_numerator = solution[3] - solution[2];       cerr <<  area^2:   << (long double)area_numerator / (long double)solution[4]            <<   n ;       cerr <<  r^2:              << (long double)r_sq / (long double)(solution[4] * solution[4])            <<   n ;       cerr <<  R^2:              << (long double)R_sq / (long double)(solution[4] * solution[4])            <<   n ;     }     cerr <<   n ;   }   void test_codeforces_549E() {     auto codeforces_549E = [&]() {       using DOUBLE = Bigint_Fixedsize_Fast<12>;       int N, M;       cin >> N >> M;       vector<vector<DOUBLE>> A;       vector<DOUBLE> b, c(4);       A.reserve(N + M);       vector<pair<int, int>> p2(N), p(M);       for (int i = 0; i < N; ++i) {         cin >> p2[i].first >> p2[i].second;       }       for (int i = 0; i < M; ++i) {         cin >> p[i].first >> p[i].second;       }       for (int it = 0; it < 2; ++it) {         N = p.size();         M = p2.size();         A.clear();         b.clear();         for (int i = 0; i < N; ++i) {           int x, y, z;           tie(x, y) = p[i];           z = x * x + y * y;           A.push_back({x, y, 1, 1});           b.push_back(z);         }         for (int i = 0; i < M; ++i) {           int x, y, z;           tie(x, y) = p2[i];           z = x * x + y * y;           A.push_back({-x, -y, -1, 1});           b.push_back(-z);         }         c[3] = 1;         Lp_Clarkson<DOUBLE> solver;         vector<DOUBLE> x = solver.solve(A, b, c);         if (!x.empty()) {           DOUBLE res = 0;           for (size_t i = 0; i < c.size(); ++i) res += x[i] * c[i];           DOUBLE dist = res;           if (dist > DOUBLE(0)) {             cout <<  YES n ;             return;           }         } else {         }         p.swap(p2);       }       cout <<  NO n ;     };     int TTT = 1;     while (TTT--) {       codeforces_549E();     }   }   signed test_codejam_2017_4_D() {     using DOUBLE = Bigint_Fixedsize_Fast<25>;     freopen( codejam_d.in ,  r , stdin);     freopen( codejam_d.out ,  w , stdout);     cin.tie(0);     ios_base::sync_with_stdio(false);     int T;     cin >> T;     for (int cas = 1; cas <= T; ++cas) {       cout <<  Case #  << cas <<  :  ;       cerr <<  Case #  << cas <<  :  ;       int n;       cin >> n;       vector<vector<DOUBLE>> A;       vector<DOUBLE> b, c(4);       A.reserve(n);       do {       } while (0);       for (int i = 0; i < n; ++i) {         int x, y, z;         cin >> x >> y >> z;         A.push_back({x, y, z, 1});         b.push_back(0);       }       c[3] = 1;       Lp_Clarkson<DOUBLE> solver;       vector<DOUBLE> x = solver.solve(A, b, c);       bool did = false;       if (!x.empty()) {         if (x[3] > DOUBLE(0)) {           did = true;         }       }       if (did)         cout <<  NO n ;       else         cout <<  YES n ;       cerr << (did ?  NO n  :  YES n );     }     return 0;   }   using namespace std;   int main() {     test_codeforces_549E();     return 0;   }   