Language: C++

//#pragma GCC optimize("O3")
//#pragma GCC target("avx")

#include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

// Utility
using std::enable_if_t, std::is_same_v, std::is_array_v, std::declval;
using std::get, std::make_pair, std::make_tuple, std::apply;
using std::iterator_traits, std::random_access_iterator_tag;
using std::stoll, std::stold, std::to_string, std::operator""s;

// Types
using std::deque, std::list, std::multiset, std::unordered_multimap,
    std::unordered_multiset;
using std::nullptr_t, std::pair, std::tuple;
using ll = long long int;
using lf = long double;
using str = std::string;
template <class T> using u_set = std::unordered_set<T>;
template <class T> using vec = std::vector<T>;
using vecl = vec<ll>;
using vecf = vec<lf>;
using vecs = vec<str>;
template <class K, class V> using u_map = std::unordered_map<K, V>;
template <class V> using graph = u_map<V, u_set<V>>;
template <typename _Signature> using fun = std::function<_Signature>;

// Algorithms
using std::accumulate, std::partial_sum;
using std::all_of, std::any_of, std::none_of, std::count_if, std::find_if,
    std::for_each, std::max_element, std::min_element, std::remove_if,
    std::replace_if, std::copy, std::copy_if, std::reverse, std::transform,
    std::unique, std::sort, std::next_permutation, std::swap;
using std::back_inserter;
using std::lower_bound, std::upper_bound;
using std::max, std::min, std::clamp, std::lcm, std::gcd;

namespace io {
// Input
using IS = std::istream;
IS &in(IS &);
IS &in(IS &i) { return i; }
template <class T, class... Ts> IS &in(IS &i, T &a, Ts &... as) {
  return in(i >> a, as...);
}
template <class V> IS &operator>>(IS &i, vec<V> &a) {
  for (auto &ai : a)
    i >> ai;
  return i;
}
template <class F, class S> IS &operator>>(IS &i, pair<F, S> &p) {
  return in(i, p.first, p.second);
}
template <class... Ts> IS &operator>>(IS &i, tuple<Ts...> &t) {
  return apply([&](auto &... ts) -> IS & { return in(i, ts...); }, t);
}
// Output
using OS = std::ostream;

OS &out(OS &o, str const &) { return o; }
template <class T> OS &out(OS &o, str const &, T const &a) { return o << a; }
template <class T, class... Ts>
OS &out(OS &o, str const &sep, T const &a, Ts const &... as) {
  return out(o << a << sep, sep, as...);
}
template <class F, class S> OS &operator<<(OS &o, pair<F, S> const &p) {
  return out(o, ":", p.first, p.second);
}
template <class... Ts> OS &operator<<(OS &o, tuple<Ts...> const &t) {
  auto f = [&](auto const &... ts) -> OS & {
    return out(o << "(", ",", ts...);
  };
  return apply(f, t) << ")";
}
template <class T> struct Joiner {
  str const pre;
  str const post;
  str const sep;
  vec<T> const container;
  template <class Itr>
  Joiner(Itr begin, Itr end, str const &sep, str const &pre, str const &post)
      : pre(pre), post(post), sep(sep), container(begin, end) {}
};
template <class T> OS &operator<<(OS &o, Joiner<T> const &joiner) {
  auto itr = joiner.container.begin();
  auto end = joiner.container.end();
  o << joiner.pre;
  if (itr != end)
    o << *(itr++);
  while (itr != end)
    o << joiner.sep << *(itr++);
  return o << joiner.post;
}
template <class Itr>
auto join(Itr b, Itr e, str const &sep = ""s, str const &pre = ""s,
          str const &post = ""s) {
  using T = typename iterator_traits<Itr>::value_type;
  return Joiner<T>(b, e, sep, pre, post);
}
template <class C, enable_if_t<!is_same_v<C, str> && !is_array_v<C>,
                               nullptr_t> = nullptr>
OS &operator<<(OS &o, C const &a) {
  return o << join(a.begin(), a.end(), ",", "[", "]");
}
} // namespace io
using std::cerr, std::cin, std::cout;
auto init_io = []() {
  std::ios_base::sync_with_stdio(false);
  cin.tie(nullptr);
  cout.tie(nullptr);
  cout << std::fixed << std::setprecision(15);
};
auto input = [](auto &... a) { io::in(cin, a...); };
auto print = [](auto const &... a) { io::out(cout, " ", a...) << "\n"; };
#ifdef JUMPAKU_DEBUG
auto dump = [](auto const &... a) { io::out(cerr, " ", a...) << "\n"; };
#else
auto dump = [](auto const &...) {};
#endif
using io::join;

// Hash
namespace hashcode {
template <class... Ts> ll hash_args(ll h, Ts const &... ts);
ll hash_args(ll h) { return h; }
template <class T, class... Ts>
ll hash_args(ll h, T const &t, Ts const &... ts) {
  constexpr std::hash<T> hasher;
  return hash_args(((h << 19) - h) ^ hasher(t), ts...);
}
} // namespace hashcode
namespace std {
template <class... Ts> struct hash<tuple<Ts...>> {
  size_t operator()(tuple<Ts...> const &t) const {
    ll h = apply(
        [&](auto const &... ts) { return hashcode::hash_args(17, ts...); }, t);
    return h ^ (h >> 32);
  }
};
template <class T> struct hash<u_set<T>> {
  size_t operator()(u_set<T> const &t) const {
    auto hasher = std::hash<T>{};
    return accumulate(
        t.begin(), t.end(), (decltype(hasher(declval<T>())))0,
        [&](auto acc, auto const &ti) { return acc + hasher(ti); });
  }
};
} // namespace std

// Range
namespace ranges {
template <class T, class Itr> struct iterator_base {
  using difference_type = ll;
  using value_type = T;
  using pointer = T *;
  using reference = T &;
  using iterator_category = random_access_iterator_tag;
  ll i;
  iterator_base(ll const &i) : i(i) {}
  bool operator==(Itr const &itr) const { return i == itr.i; }
  bool operator!=(Itr const &itr) const { return i != itr.i; }
  ll operator-(Itr const &itr) const { return i - itr.i; }
  Itr operator++(int) { return with(i++); }
  Itr operator--(int) { return with(i--); }
  Itr operator+(ll const &n) const { return with(i + n); }
  Itr operator-(ll const &n) const { return with(i - n); }
  Itr &operator+=(ll const &n) {
    i += n;
    return self();
  }
  Itr &operator-=(ll const &n) { return self() += (-n); }
  Itr &operator++() { return self() += 1; }
  Itr &operator--() { return self() -= 1; }

protected:
  virtual Itr with(ll i) const = 0;
  virtual Itr &self() = 0;
};
template <class T> struct seq_base {
  ll const b;
  ll const e;
  seq_base(ll b, ll e) : b(b), e(e) {}
  ll size() const { return e - b; }
  bool empty() const { return size() == 0; }
};
template <class T> struct seq : seq_base<T> {
  struct iterator : iterator_base<T, iterator> {
    seq<T> const &s;
    iterator(seq<T> const &s, ll const &i)
        : iterator_base<T, iterator>(i), s(s) {}
    iterator with(ll i) const override { return iterator(s, i); }
    iterator &self() override { return *this; }
    T operator*() const { return s[this->i]; }
    iterator &operator=(iterator const &itr) {
      this->i = itr.i;
      return *this;
    }
  };
  fun<T(ll)> const f;
  seq(ll b, ll e, fun<T(ll)> const &f) : seq_base<T>(b, e), f(f) {}
  iterator begin() const { return iterator(*this, 0); }
  iterator end() const { return iterator(*this, this->size()); }
  T operator[](ll i) const { return f(i + this->b); }
};
template <class F>
seq(ll b, ll e, F const &f)->seq<typename std::invoke_result<F, ll>::type>;

struct range : seq_base<ll> {
  struct iterator : iterator_base<ll, iterator> {
    iterator(ll const &i) : iterator_base<ll, iterator>(i) {}
    iterator with(ll i) const override { return iterator(i); }
    iterator &self() override { return *this; }
    ll operator*() const { return i; }
  };
  range(ll n) : range(0LL, n) {}
  range(ll b, ll e) : seq_base<ll>(b, e) {}
  iterator begin() const { return iterator(b); }
  iterator end() const { return iterator(e); }
  bool has(ll x) const { return b <= x && x < e; }
  ll operator[](ll i) const { return i + b; }
};
} // namespace ranges
using range = ranges::range;
range::iterator end(ll i) { return range::iterator(i); }
range::iterator begin(ll i = 0LL) { return range::iterator(i); }
template <class F> auto seq(ll n, F const &f) { return ranges::seq(0LL, n, f); }

bool odd(ll n) { return n & 1; }
bool even(ll n) { return !odd(n); }

constexpr ll MOD = 1e9 + 7;

void solve();
int main() {
  init_io();
  ll t = 1;
  /** input(t); /**/
  while (t--)
    solve();
  cout.flush();
}

void solve() {
  ll N;
  input(N);
  vecl S(N), T(N), U(N), V(N);
  input(S, T, U, V);
#ifndef JUMPAKU_DEBUG
  ll B = 64;
#else
  ll B = 5;
#endif
  vec<vec<vecl>> a(N, vec<vecl>(N, vecl(B, -1)));
  for (auto &&b : range(B)) {
    for (auto &&i : range(N)) {
      for (auto &&j : range(N)) {
        bool mustOne = (S[i] == 0 && ((U[i] >> b) & 1)) ||
                       (T[j] == 0 && ((V[j] >> b) & 1));
        bool mustZero = (S[i] == 1 && !((U[i] >> b) & 1)) ||
                        (T[j] == 1 && !((V[j] >> b) & 1));
        if (mustZero && mustOne) {
          print(-1);
          return;
        } else if (mustOne && !mustZero) {
          a[i][j][b] = 1;
        } else if (mustZero && !mustOne) {
          a[i][j][b] = 0;
        } else {
          bool mayOne = (S[i] == 1 && ((U[i] >> b) & 1)) &&
                        (T[j] == 1 && ((V[j] >> b) & 1));
          bool mayZero = (S[i] == 0 && !((U[i] >> b) & 1)) &&
                         (T[j] == 0 && !((V[j] >> b) & 1));
          if (mayOne && !mayZero) {
            a[i][j][b] = 1;
          } else if (mayZero && !mayOne) {
            a[i][j][b] = 0;
          }
        }
      }
    }
  }
  for (auto &&b : range(B)) {
    for (auto &&i : range(N)) {
      bool mayZero =
          S[i] == 1 && ((U[i] >> b) & 1) &&
          any_of(begin(), end(N), [&](auto j) { return a[i][j][b] == 1; });
      if (mayZero) {
        for (auto &&j : range(N)) {
          a[i][j][b] = (a[i][j][b] == -1) ? 0LL : a[i][j][b];
        }
      }
      bool mayOne =
          S[i] == 0 && !((U[i] >> b) & 1) &&
          any_of(begin(), end(N), [&](auto j) { return a[i][j][b] == 0; });
      if (mayOne) {
        for (auto &&j : range(N)) {
          a[i][j][b] = (a[i][j][b] == -1) ? 1LL : a[i][j][b];
        }
      }
    }
  }
  for (auto &&b : range(B)) {
    for (auto &&j : range(N)) {
      bool mayZero =
          T[j] == 1 && ((V[j] >> b) & 1) &&
          any_of(begin(), end(N), [&](auto i) { return a[i][j][b] == 1; });
      if (mayZero) {
        for (auto &&i : range(N)) {
          a[i][j][b] = (a[i][j][b] == -1) ? 0LL : a[i][j][b];
        }
      }
      bool mayOne =
          T[j] == 0 && !((V[j] >> b) & 1) &&
          any_of(begin(), end(N), [&](auto i) { return a[i][j][b] == 0; });
      if (mayOne) {
        for (auto &&i : range(N)) {
          a[i][j][b] = (a[i][j][b] == -1) ? 1LL : a[i][j][b];
        }
      }
    }
  }
  for (auto &&b : range(B)) {
    for (auto &&i : range(N)) {
      for (auto &&j : range(N)) {
        bool m1Valid = ((!(a[i][j][b] != 0 || a[i][j][b] != 1)) ||
                        ((S[i] == 1 && ((U[i] >> b) & 1)) &&
                         (T[j] == 0 && !((V[j] >> b) & 1))) ||
                        ((S[i] == 0 && !((U[i] >> b) & 1)) &&
                         (T[j] == 1 && ((V[j] >> b) & 1))));
        if (!m1Valid) {
          exit(1);
        }
      }
    }
// check
#ifdef JUMPAKU_DEBUG
    for (auto &&b : range(B)) {
      for (auto &&i : range(N)) {
        for (auto &&j : range(N)) {
          if (a[i][j][b] != 0 || a[i][j][b] != 1) {
            exit(1);
          }
        }
      }
      for (auto &&i : range(N)) {
        bool rowOk =
            (S[i] == 0 && ((U[i] >> b) & 1) &&
             all_of(begin(), end(N),
                    [&](auto j) { return a[i][j][b] == 1; })) ||
            (S[i] == 0 && !((U[i] >> b) & 1) &&
             any_of(begin(), end(N),
                    [&](auto j) { return a[i][j][b] == 0; })) ||
            (S[i] == 1 && ((U[i] >> b) & 1) &&
             any_of(begin(), end(N),
                    [&](auto j) { return a[i][j][b] == 1; })) ||
            (S[i] == 1 && !((U[i] >> b) & 1) &&
             all_of(begin(), end(N), [&](auto j) { return a[i][j][b] == 0; }));
        if (!rowOk) {
          print(-1);
          return;
        }
      }
      for (auto &&j : range(N)) {
        bool columnOk =
            (T[j] == 0 && ((V[j] >> b) & 1) &&
             all_of(begin(), end(N),
                    [&](auto i) { return a[i][j][b] == 1; })) ||
            (T[j] == 0 && !((V[j] >> b) & 1) &&
             any_of(begin(), end(N),
                    [&](auto i) { return a[i][j][b] == 0; })) ||
            (T[j] == 1 && ((V[j] >> b) & 1) &&
             any_of(begin(), end(N),
                    [&](auto i) { return a[i][j][b] == 1; })) ||
            (T[j] == 1 && !((V[j] >> b) & 1) &&
             all_of(begin(), end(N), [&](auto i) { return a[i][j][b] == 0; }));
        if (!columnOk) {
          print(-1);
          return;
        }
      }
    }
#endif
    dump(a);
    vec<vecl> ans(N, vecl(N));
    for (auto &&i : range(N)) {
      for (auto &&j : range(N)) {
        for (auto &&b : range(B)) {
          auto x = a[i][j][b];
          ans[i][j] |= x << b;
        }
      }
    }

    dump(ans);
    for (auto &&i : range(N)) {
      print(join(ans[i].begin(), ans[i].end(), " "s));
    }
  }


Compiler output:
a.cc:42:49: error: 'function' in namespace 'std' does not name a template type
   42 | template <typename _Signature> using fun = std::function<_Signature>;
      |                                                 ^~~~~~~~
a.cc:21:1: note: 'std::function' is defined in header '<functional>'; this is probably fixable by adding '#include <functional>'
   20 | #include <vector>
  +++ |+#include <functional>
   21 | 
a.cc:215:3: error: 'fun' does not name a type
  215 |   fun<T(ll)> const f;
      |   ^~~
a.cc:216:19: error: 'fun' has not been declared
  216 |   seq(ll b, ll e, fun<T(ll)> const &f) : seq_base<T>(b, e), f(f) {}
      |                   ^~~
a.cc:216:22: error: expected ',' or '...' before '<' token
  216 |   seq(ll b, ll e, fun<T(ll)> const &f) : seq_base<T>(b, e), f(f) {}
      |                      ^
a.cc: In constructor 'ranges::seq<T>::seq(ll, ll, int)':
a.cc:216:61: error: class 'ranges::seq<T>' does not have any field named 'f'
  216 |   seq(ll b, ll e, fun<T(ll)> const &f) : seq_base<T>(b, e), f(f) {}
      |                                                             ^
a.cc:216:63: error: 'f' was not declared in this scope
  216 |   seq(ll b, ll e, fun<T(ll)> const &f) : seq_base<T>(b, e), f(f) {}
      |                                                               ^
a.cc: In function 'void solve()':
a.cc:414:4: error: expected '}' at end of input
  414 |   }
      |    ^
a.cc:259:14: note: to match this '{'
  259 | void solve() {
      |              ^
a.cc: In instantiation of 'io::IS& io::in(IS&, T&, Ts& ...) [with T = std::vector<long long int, std::allocator<long long int> >; Ts = {std::vector<long long int, std::allocator<long long int> >, std::vector<long long int, std::allocator<long long int> >, std::vector<long long int, std::allocator<long long int> >}; IS = std::basic_istream<char>]':
a.cc:129:38:   required from '<lambda(auto:3& ...)> [with auto:3 = {std::vector<long long int, std::allocator<long long int> >, std::vector<long long int, std::allocator<long long int> >, std::vector<long long int, std::allocator<long long int> >, std::vector<long long int, std::allocator<long long int> >}]'
  129 | auto input = [](auto &... a) { io::in(cin, a...); };
      |                                ~~~~~~^~~~~~~~~~~
a.cc:263:8:   required from here
  263 |   input(S, T, U, V);
      |   ~~~~~^~~~~~~~~~~~
a.cc:60:15: error: no match for 'operator>>' (operand types are 'io::IS' {aka 'std::basic_istream<char>'} and 'std::vector<long long int, std::allocator<long long int> >')
   60 |   return in(i >> a, as...);
      |             ~~^~~~
In file included from /usr/include/c++/14/sstream:40,
                 from /usr/include/c++/14/bits/quoted_string.h:38,
                 from /usr/include/c++/14/iomanip:50,
                 from a.cc:7:
/usr/include/c++/14/istream:170:7: note: candidate: 'std::basic_istream<_CharT, _Traits>::__istream_type& std::basic_istream<_CharT, _Traits>::operator>>(bool&) [with _CharT = char; _Traits = std::char_traits<char>; __istream_type = std::basic_istream<char>]'
  170 |       operator>>(bool& __n)
      |       ^~~~~~~~
/usr/include/c++/14/istream:170:24: note:   no known conversion for argument 1 from 'std::vector<long long int, std::allocator<long long int> >' to 'bool&'
  170 |       operator>>(bool& __n)
      |                  ~~~~~~^~~
/usr/include/c++/14/istream:174:7: note: candidate: 'std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(short int&) [with _CharT = char; _Traits = std::char_traits<char>]'
  174 |       operator>>(short& __n);
      |       ^~~~~~~~
/usr/include/c++/14/istream:174:25: note:   no known conversion for argument 1 from 'std::vector<long long int, std::allocator<long long int> >' to 'short int&'
  174 |       operator>>(short& __n);
      |                  ~~~~~~~^~~
/usr/include/c++/14/istream:177:7: note: candidate: 'std::basic_istream<_CharT, _Traits>::__istream_type& std::basic_istream<_CharT, _Traits>::operator>>(short unsigned int&) [with _CharT = char; _Traits = std::char_traits<char>; __istream_type = std::basic_istream<char>]'
  177 |       operator>>(unsigned short& __n)
      |       ^~~~~~~~
/usr/include/c++/14/istream:177:34: note:   no known conversion for argument 1 from 'std::vector<long long int, std::allocator<long long int> >' to 'short unsigned int&'
  177 |       operator>>(unsigned short& __n)
      |                  ~~~~~~~~~~~~~~~~^~~
/usr/include/c++/14/istream:181:7: note: candidate: 'std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(int&) [with _CharT = char; _Traits = std::char_traits<char>]'
  181 |       operator>>(int& __n);
      |       ^~~~~~~~
/usr/include/c++/14/istream:181:23: note:   no known conversion for argument 1 from 'std::vector<long long int, std::allocator<long long int> >' to 'int&'
  181 |       operator>>(int& __n);
      |                  ~~~~~^~~
/usr/include/c++/14/istream:184:7: note: candidate: 'std::basic_istream<_CharT, _Traits>::__istream_type& std::basic_istream<_CharT, _Traits>::operator>>(unsigned int&) [with _CharT = char; _Traits = std::char_traits<char>; __istream_type = std::basic_istream<char>]'
  184 |       operator>>(unsigned int& __n)
      |       ^~~~~~~~
/usr/include/c++/14/istream:184:32: note:   no known conversion for argument 1 from 'std::vector<long long int, std::allocator<long long int> >' to 'unsigned int&'
  184 |       operator>>(unsigned int& __n)
      |                  ~~~~~~~~~~~~~~^~~
/usr/include/c++/14/istream:188:7: note: candidate: 'std::basic_istream<_CharT, _Traits>::__istream_type& std::basic_istream<_CharT, _Traits>::operator>>(long int&) [with _CharT = char; _Traits = std::char_traits<char>; __istream_type = std::basic_istream<char>]'
  188 |       operator>>(long& __n)
      |       ^~~~~~~~
/usr/include/c++/14/istream:188:24: note:   no known conversion for argument 1 from 'std::vector<long long int, std::allocator<long long int> >' to 'long int&'
  188 |       operator>>(long& __n)
      |                  ~~~~~~^~~
/usr/include/c++/14/istream:192:7: note: candidate: 'std::basic_istream<_CharT, _Traits>::__istream_type& std::basic_istream<_CharT, _Traits>::operator>>(long unsigned int&) [with _CharT = char; _Traits = std::char_traits<char>; __istream_type = std::basic_istream<char>]'
  192 |       operator>>(unsigned long& __n)
      |       ^~~~~~~~
/usr/include/c++/14/istream:192:33: note:   no known conversion for argument 1 from 'std::vector<long long int, std::allocator<long long int> >' to 'long unsigned int&'
  192 |       operator>>(unsigned long& __n)
      |                  ~~~~~~~~~~~~~~~^~~
/usr/include/c++/14/istream:199:7: note: candidate: 'std::basic_istream<_CharT, _Traits>::__istream_type& std::basic_istream<_CharT, _Traits>::operator>>(long long int&) [with _CharT = char; _Traits = std::char_traits<char>; __istream_type = std::basic_istream<char>]'
  199 |       operator>>(long long& __n)
      |       ^~~~~~~~
/usr/include/c++/14/istream:199:29: note:   no known conversion for argument 1 from 'std::vector<long long int, std::allocator<long long int> >' to 'long long int&'
  199 |       operator>>(long long& __n)
      |                  ~~~~~~~~~~~^~~
/usr/include/c++/14/istream:203:7: note: candidate: 'std::basic_istream<_CharT, _Traits>::__istream_type& std::basic_istream<_CharT, _Traits>::operator>>(long long unsigned int&) [with _CharT = char; _Traits = std::char_traits<char>; __istream_type = std::basic_istream<char>]'
  203 |       operator>>(unsigned long long& __n)
      |       ^~~~~~~~
/usr/include/c++/14/istream:203:38: note:   no known conversion for argument 1 from 'std::vector<long long int, std::allocator<long long int> >' to 'long long unsigned int&'
  203 |       operator>>(unsigned long long& __n)
      |                  ~~~~~~~~~~~~~~~~~~~~^~~
/usr/include/c++/14/istream:219:7: note: candidate: 'std::basic_istream<_CharT, _Traits>::__istream_type& std::basic_istream<_CharT, _Traits>::operator>>(float&) [with _CharT = char; _Traits = std::char_traits<char>; __istream_type = std::basic_istream<char>]'
  219 |       operator>>(float& __f)
      |       ^~~~~~~~
/usr/include/c++/14/istream:219:25: note:   no known conversion for argument 1 from 'std::vector<long long int, std::allocator<long long int> >' to 'float&'
  219 |       operator>>(float& __f)
      |                  ~~~~~~~^~~
/usr/include/c++/14/istream:223:7: note: candidate: 'std::basic_istream<_CharT, _Traits>::__istream_type& std::basic_istream<_CharT, _Traits>::operator>>(double&) [with _CharT = char; _Traits = std::char_traits<char>; __istream_type = std::basic_istream<char>]'
  223 |       operator>>(double& __f)
      |       ^~~~~~~~
/usr/include/c++/14/istream:223:26: note:   no known conversion for argument 1 from 'std::vector<long long int, std::allocator<long long int> >' to 'double&'
  223 |       operator>>(double& __f)
      |                  ~~~~~~~~^~~
/usr/include/c++/14/istream:227:7: note: candidate: 'std::basic_istream<_CharT, _Traits>::__istream_type& std::basic_istream<_CharT, _Traits>::operator>>(long double&) [with _CharT = char; _Traits = std::char_traits<char>; __istream_type = std::basic_istream<char>]'
  227 |       operator>>(long double& __f)
      |       ^~~~~~~~
/usr/include/c++/14/istream:227:31: note:   no known conversion for argument 1 from 'std::vector<long long int, std::allocator<long long int> >' to 'long double&'
  227 |       operator>>(long double& __f)
      |                  ~~~~~~~~~~~~~^~~
/usr/include/c++/14/istream:328:7: note: candidate: 'std::basic_istream<_CharT, _Traits>::__istream_type& std::basic_istream<_CharT, _Traits>::operator>>(void*&) [with _CharT = char; _Traits = std::char_traits<char>; __istream_type = std::basic_istream<char>]'
  328 |       operator>>(void*& __p)
      |       ^~~~~~~~
/usr/include/c++/14/istream:328:25: note:   no known conversion for argument 1 from 'std::vector<long long int, std::allocator<long long int> >' to 'void*&'
  328 |       operator>>(void*& __p)
      |                  ~~~~~~~^~~
/usr/include/c++/14/istream:122:7: note: candidate: 'std::basic_istream<_CharT, _Traits>::__istream_type& std::basic_