結果
問題 | No.2308 [Cherry 5th Tune B] もしかして、真? |
ユーザー |
|
提出日時 | 2023-05-19 22:42:10 |
言語 | C++17 (gcc 13.3.0 + boost 1.87.0) |
結果 |
AC
|
実行時間 | 598 ms / 2,000 ms |
コード長 | 45,672 bytes |
コンパイル時間 | 3,777 ms |
コンパイル使用メモリ | 335,692 KB |
最終ジャッジ日時 | 2025-02-13 02:51:23 |
ジャッジサーバーID (参考情報) |
judge3 / judge5 |
(要ログイン)
ファイルパターン | 結果 |
---|---|
other | AC * 39 |
ソースコード
#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>>;// ! macros (internal)#define DETAIL_OVERLOAD2(_1,_2,name,...) name#define DETAIL_OVERLOAD3(_1,_2,_3,name,...) name#define DETAIL_OVERLOAD4(_1,_2,_3,_4,name,...) name#define DETAIL_REP4(i,l,r,s) for(std::remove_reference_t<std::remove_const_t<decltype(r)>>i=(l);i<(r);i+=(s))#define DETAIL_REP3(i,l,r) DETAIL_REP4(i,l,r,1)#define DETAIL_REP2(i,n) DETAIL_REP3(i,0,n)#define DETAIL_REPINF3(i,l,s) for(std::remove_reference_t<std::remove_const_t<decltype(l)>>i=(l);;i+=(s))#define DETAIL_REPINF2(i,l) DETAIL_REPINF3(i,l,1)#define DETAIL_REPINF1(i) DETAIL_REPINF2(i,0)#define DETAIL_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 DETAIL_RREP3(i,l,r) DETAIL_RREP4(i,l,r,1)#define DETAIL_RREP2(i,n) DETAIL_RREP3(i,0,n)#define DETAIL_CAT_I(a, b) a##b#define DETAIL_CAT(a, b) DETAIL_CAT_I(a, b)#define DETAIL_UNIQVAR(tag) DETAIL_CAT(tag, __LINE__)// ! macros#define REP(...) DETAIL_OVERLOAD4(__VA_ARGS__, DETAIL_REP4 , DETAIL_REP3 , DETAIL_REP2 )(__VA_ARGS__)#define RREP(...) DETAIL_OVERLOAD4(__VA_ARGS__, DETAIL_RREP4 , DETAIL_RREP3 , DETAIL_RREP2 )(__VA_ARGS__)#define REPINF(...) DETAIL_OVERLOAD3(__VA_ARGS__, DETAIL_REPINF3, DETAIL_REPINF2, DETAIL_REPINF1)(__VA_ARGS__)#define LOOP(n) for (std::remove_reference_t<std::remove_const_t<decltype(n)>> DETAIL_UNIQVAR(loop_variable) = n; DETAIL_UNIQVAR(loop_variable) -->0;)#define ALL(iterable) std::begin(iterable), std::end(iterable)#define INPUT(type, ...) type __VA_ARGS__; read(__VA_ARGS__)// ! debug#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 stoi128(const 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 stou128(const 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 = stoi128(s);return in;}// __uint128_tstd::istream& operator>>(std::istream& in, __uint128_t& v) {std::string s;in >> s;v = stou128(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, std::enable_if_t<std::negation_v<suisen::is_nbit<T, 64>>, std::nullptr_t> = nullptr>__attribute__((target("popcnt"))) constexpr inline int popcount(const T x) { return _mm_popcnt_u32(x); }template <typename T, std::enable_if_t<suisen::is_nbit_v<T, 64>, std::nullptr_t> = nullptr>__attribute__((target("popcnt"))) constexpr inline int popcount(const T x) { return _mm_popcnt_u64(x); }template <typename T, std::enable_if_t<std::negation_v<suisen::is_nbit<T, 64>>, std::nullptr_t> = nullptr>constexpr inline int count_lz(const T x) { return x ? __builtin_clz(x) : suisen::bit_num<T>; }template <typename T, std::enable_if_t<suisen::is_nbit_v<T, 64>, std::nullptr_t> = nullptr>constexpr inline int count_lz(const T x) { return x ? __builtin_clzll(x) : suisen::bit_num<T>; }template <typename T, std::enable_if_t<std::negation_v<suisen::is_nbit<T, 64>>, std::nullptr_t> = nullptr>constexpr inline int count_tz(const T x) { return x ? __builtin_ctz(x) : suisen::bit_num<T>; }template <typename T, std::enable_if_t<suisen::is_nbit_v<T, 64>, std::nullptr_t> = 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>auto priqueue_comp(const Comparator comparator) {return std::priority_queue<T, std::vector<T>, Comparator>(comparator);}template <typename Container>void sort_unique_erase(Container& 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) {return y >= x ? false : (x = y, true);}// x <- max(x, y). returns true iff `x` has chenged.template <typename T>inline bool chmax(T& x, const T& y) {return y <= x ? false : (x = y, 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 != -1) {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();}template <typename Func, typename Seq>auto transform_to_vector(const Func &f, const Seq &s) {std::vector<std::invoke_result_t<Func, typename Seq::value_type>> v;v.reserve(std::size(s)), std::transform(std::begin(s), std::end(s), std::back_inserter(v), f);return v;}template <typename T, typename Seq>auto copy_to_vector(const Seq &s) {std::vector<T> v;v.reserve(std::size(s)), std::copy(std::begin(s), std::end(s), std::back_inserter(v));return v;}template <typename Seq>Seq concat(Seq s, const Seq &t) {s.reserve(std::size(s) + std::size(t));std::copy(std::begin(t), std::end(t), std::back_inserter(s));return s;}template <typename Seq>std::vector<Seq> split(const Seq s, typename Seq::value_type delim) {std::vector<Seq> res;for (auto itl = std::begin(s), itr = itl;; itl = ++itr) {while (itr != std::end(s) and *itr != delim) ++itr;res.emplace_back(itl, itr);if (itr == std::end(s)) return res;}}int digit_to_int(char c) { return c - '0'; }int lowercase_to_int(char c) { return c - 'a'; }int uppercase_to_int(char c) { return c - 'A'; }std::vector<int> digit_str_to_ints(const std::string &s) {return transform_to_vector(digit_to_int, s);}std::vector<int> lowercase_str_to_ints(const std::string &s) {return transform_to_vector(lowercase_to_int, s);}std::vector<int> uppercase_str_to_ints(const std::string &s) {return transform_to_vector(uppercase_to_int, s);}const std::string Yes = "Yes", No = "No", YES = "YES", NO = "NO";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 <algorithm>#include <cassert>#include <cstdint>#include <optional>#include <string>#include <random>#include <tuple>#include <vector>#include <utility>namespace suisen::internal::implicit_treap {template <typename T, typename Derived>struct Node {using random_engine = std::mt19937;static inline random_engine rng{ std::random_device{}() };using priority_type = std::invoke_result_t<random_engine>;static priority_type random_priority() { return rng(); }using node_type = Derived;using node_pointer = uint32_t;using size_type = uint32_t;using difference_type = int32_t;using value_type = T;using pointer = value_type*;using const_pointer = const value_type*;using reference = value_type&;using const_reference = const value_type&;static inline std::vector<node_type> _nodes{};static inline std::vector<node_pointer> _erased{};static constexpr node_pointer null = ~node_pointer(0);node_pointer _ch[2]{ null, null };value_type _val;size_type _size;priority_type _priority;node_pointer _prev = null, _next = null;Node(const value_type val = {}): _val(val), _size(1), _priority(random_priority()) {}static void reserve(size_type capacity) { _nodes.reserve(capacity); }static bool is_null(node_pointer t) { return t == null; }static bool is_not_null(node_pointer t) { return not is_null(t); }static node_type& node(node_pointer t) { return _nodes[t]; }static const node_type& const_node(node_pointer t) { return _nodes[t]; }static value_type& value(node_pointer t) { return node(t)._val; }static value_type set_value(node_pointer t, const value_type& new_val) { return std::exchange(value(t), new_val); }static bool empty(node_pointer t) { return is_null(t); }static size_type& size(node_pointer t) { return node(t)._size; }static size_type safe_size(node_pointer t) { return empty(t) ? 0 : size(t); }static priority_type& priority(node_pointer t) { return node(t)._priority; }static void set_priority(node_pointer t, priority_type new_priority) { priority(t) = new_priority; }static node_pointer& prev(node_pointer t) { return node(t)._prev; }static node_pointer& next(node_pointer t) { return node(t)._next; }static void link(node_pointer l, node_pointer r) { next(l) = r, prev(r) = l; }static node_pointer min(node_pointer t) {while (true) {node_pointer nt = child0(t);if (is_null(nt)) return t;t = nt;}}static node_pointer max(node_pointer t) {while (true) {node_pointer nt = child1(t);if (is_null(nt)) return t;t = nt;}}static node_pointer& child0(node_pointer t) { return node(t)._ch[0]; }static node_pointer& child1(node_pointer t) { return node(t)._ch[1]; }static node_pointer& child(node_pointer t, bool b) { return node(t)._ch[b]; }static node_pointer set_child0(node_pointer t, node_pointer cid) { return std::exchange(child0(t), cid); }static node_pointer set_child1(node_pointer t, node_pointer cid) { return std::exchange(child1(t), cid); }static node_pointer set_child(node_pointer t, bool b, node_pointer cid) { return std::exchange(child(t, b), cid); }static node_pointer update(node_pointer t) { // t : not nullsize(t) = safe_size(child0(t)) + safe_size(child1(t)) + 1;return t;}static node_pointer empty_node() { return null; }template <typename ...Args>static node_pointer create_node(Args &&...args) {if (_erased.size()) {node_pointer res = _erased.back();_erased.pop_back();node(res) = node_type(std::forward<Args>(args)...);return res;} else {node_pointer res = _nodes.size();_nodes.emplace_back(std::forward<Args>(args)...);return res;}}static void delete_node(node_pointer t) { _erased.push_back(t); }static void delete_tree(node_pointer t) {if (is_null(t)) return;delete_tree(child0(t));delete_tree(child1(t));delete_node(t);}template <typename ...Args>static node_pointer build(Args &&... args) {std::vector<value_type> dat(std::forward<Args>(args)...);const size_t n = dat.size();std::vector<priority_type> priorities(n);std::generate(priorities.begin(), priorities.end(), random_priority);std::make_heap(priorities.begin(), priorities.end());std::vector<node_pointer> nodes(n);auto rec = [&](auto rec, size_t heap_index, size_t dat_index_offset) -> std::pair<size_t, node_pointer> {if (heap_index >= n) return { 0, null };auto [lsiz, lch] = rec(rec, 2 * heap_index + 1, dat_index_offset);dat_index_offset += lsiz;node_pointer root = create_node(std::move(dat[dat_index_offset]));nodes[dat_index_offset] = root;set_priority(root, priorities[heap_index]);if (dat_index_offset) {link(nodes[dat_index_offset - 1], root);}dat_index_offset += 1;auto [rsiz, rch] = rec(rec, 2 * heap_index + 2, dat_index_offset);set_child0(root, lch);set_child1(root, rch);return { lsiz + 1 + rsiz, node_type::update(root) };};return rec(rec, 0, 0).second;}static std::pair<node_pointer, node_pointer> split(node_pointer t, size_type k) {if (k == 0) return { null, t };if (k == size(t)) return { t, null };static std::vector<node_pointer> lp{}, rp{};while (true) {if (const size_type lsiz = safe_size(child0(t)); k <= lsiz) {if (rp.size()) set_child0(rp.back(), t);rp.push_back(t);if (k == lsiz) {if (lp.size()) set_child1(lp.back(), child0(t));node_pointer lt = set_child0(t, null), rt = null;while (lp.size()) node_type::update(lt = lp.back()), lp.pop_back();while (rp.size()) node_type::update(rt = rp.back()), rp.pop_back();return { lt, rt };}t = child0(t);} else {if (lp.size()) set_child1(lp.back(), t);lp.push_back(t);t = child1(t);k -= lsiz + 1;}}}static std::tuple<node_pointer, node_pointer, node_pointer> split(node_pointer t, size_type l, size_type r) {auto [tlm, tr] = split(t, r);auto [tl, tm] = split(tlm, l);return { tl, tm, tr };}static node_pointer merge_impl(node_pointer tl, node_pointer tr) {if (priority(tl) < priority(tr)) {if (node_pointer tm = child0(tr); is_null(tm)) {link(max(tl), tr);set_child0(tr, tl);} else {set_child0(tr, merge(tl, tm));}return node_type::update(tr);} else {if (node_pointer tm = child1(tl); is_null(tm)) {link(tl, min(tr));set_child1(tl, tr);} else {set_child1(tl, merge(tm, tr));}return node_type::update(tl);}}static node_pointer merge(node_pointer tl, node_pointer tr) {if (is_null(tl)) return tr;if (is_null(tr)) return tl;return merge_impl(tl, tr);}static node_pointer merge(node_pointer tl, node_pointer tm, node_pointer tr) {return merge(merge(tl, tm), tr);}static node_pointer insert_impl(node_pointer t, size_type k, node_pointer new_node) {if (is_null(t)) return new_node;static std::vector<node_pointer> st;bool b = false;while (true) {if (is_null(t) or priority(new_node) > priority(t)) {if (is_null(t)) {t = new_node;} else {auto [tl, tr] = split(t, k);if (is_not_null(tl)) link(max(tl), new_node);if (is_not_null(tr)) link(new_node, min(tr));set_child0(new_node, tl);set_child1(new_node, tr);t = node_type::update(new_node);}if (st.size()) {set_child(st.back(), b, t);do t = node_type::update(st.back()), st.pop_back(); while (st.size());}return t;} else {if (const size_type lsiz = safe_size(child0(t)); k <= lsiz) {if (k == lsiz) link(new_node, t);st.push_back(t), b = false;t = child0(t);} else {if (k == lsiz + 1) link(t, new_node);st.push_back(t), b = true;t = child1(t);k -= lsiz + 1;}}}}template <typename ...Args>static node_pointer insert(node_pointer t, size_type k, Args &&...args) {return insert_impl(t, k, create_node(std::forward<Args>(args)...));}static std::pair<node_pointer, value_type> erase(node_pointer t, size_type k) {if (const size_type lsiz = safe_size(child0(t)); k == lsiz) {delete_node(t);return { merge(child0(t), child1(t)), std::move(value(t)) };} else if (k < lsiz) {auto [c0, v] = erase(child0(t), k);set_child0(t, c0);if (is_not_null(c0) and k == lsiz - 1) link(max(c0), t);return { node_type::update(t), std::move(v) };} else {auto [c1, v] = erase(child1(t), k - (lsiz + 1));set_child1(t, c1);if (is_not_null(c1) and k == lsiz + 1) link(t, min(c1));return { node_type::update(t), std::move(v) };}}static node_pointer rotate(node_pointer t, size_type k) {auto [tl, tr] = split(t, k);return merge(tr, tl);}static node_pointer rotate(node_pointer t, size_type l, size_type m, size_type r) {auto [tl, tm, tr] = split(t, l, r);return merge(tl, rotate(tm, m - l), tr);}template <typename Func>static node_pointer set_update(node_pointer t, size_type k, const Func& f) {if (const size_type lsiz = safe_size(child0(t)); k == lsiz) {value_type& val = value(t);val = f(const_cast<const value_type&>(val));} else if (k < lsiz) {set_child0(t, set_update(child0(t), k, f));} else {set_child1(t, set_update(child1(t), k - (lsiz + 1), f));}return node_type::update(t);}static std::vector<value_type> dump(node_pointer t) {std::vector<value_type> res;res.reserve(safe_size(t));auto rec = [&](auto rec, node_pointer t) -> void {if (is_null(t)) return;rec(rec, child0(t));res.push_back(value(t));rec(rec, child1(t));};rec(rec, t);return res;}template <bool reversed_, bool constant_>struct NodeIterator {static constexpr bool constant = constant_;static constexpr bool reversed = reversed_;friend Node;friend Derived;using difference_type = Node::difference_type;using value_type = Node::value_type;using pointer = std::conditional_t<constant, Node::const_pointer, Node::pointer>;using reference = std::conditional_t<constant, Node::const_reference, Node::reference>;using iterator_category = std::random_access_iterator_tag;NodeIterator(): NodeIterator(null) {}explicit NodeIterator(node_pointer root): NodeIterator(root, 0, null) {}NodeIterator(const NodeIterator<reversed, not constant>& it): NodeIterator(it._root, it._index, it._cur) {}reference operator*() const {if (is_null(_cur) and _index != safe_size(_root)) {_cur = _root;for (size_type k = _index;;) {if (size_type siz = safe_size(child(_cur, reversed)); k == siz) {break;} else if (k < siz) {_cur = child(_cur, reversed);} else {_cur = child(_cur, not reversed);k -= siz + 1;}}}return value(_cur);}reference operator[](difference_type k) const { return *((*this) + k); }NodeIterator& operator++() { return *this += 1; }NodeIterator& operator--() { return *this -= 1; }NodeIterator& operator+=(difference_type k) { return suc(+k), * this; }NodeIterator& operator-=(difference_type k) { return suc(-k), * this; }NodeIterator operator++(int) { NodeIterator res = *this; ++(*this); return res; }NodeIterator operator--(int) { NodeIterator res = *this; --(*this); return res; }friend NodeIterator operator+(NodeIterator it, difference_type k) { return it += k; }friend NodeIterator operator+(difference_type k, NodeIterator it) { return it += k; }friend NodeIterator operator-(NodeIterator it, difference_type k) { return it -= k; }friend difference_type operator-(const NodeIterator& lhs, const NodeIterator& rhs) { return lhs._index - rhs._index; }friend bool operator==(const NodeIterator& lhs, const NodeIterator& rhs) { return lhs._index == rhs._index; }friend bool operator!=(const NodeIterator& lhs, const NodeIterator& rhs) { return lhs._index != rhs._index; }friend bool operator<(const NodeIterator& lhs, const NodeIterator& rhs) { return lhs._index < rhs._index; }friend bool operator>(const NodeIterator& lhs, const NodeIterator& rhs) { return lhs._index > rhs._index; }friend bool operator<=(const NodeIterator& lhs, const NodeIterator& rhs) { return lhs._index <= rhs._index; }friend bool operator>=(const NodeIterator& lhs, const NodeIterator& rhs) { return lhs._index >= rhs._index; }static NodeIterator begin(node_pointer root) { return NodeIterator(root, 0, null); }static NodeIterator end(node_pointer root) { return NodeIterator(root, safe_size(root), null); }int size() const { return safe_size(_root); }int index() const { return _index; }private:node_pointer _root;size_type _index;mutable node_pointer _cur; // it==end() or uninitialized (updates only index)NodeIterator(node_pointer root, size_type index, node_pointer cur): _root(root), _index(index), _cur(cur) {}void suc(difference_type k) {_index += k;if (_index == safe_size(_root) or std::abs(k) >= 20) _cur = null;if (is_null(_cur)) return;const bool positive = k < 0 ? (k = -k, reversed) : not reversed;if (positive) {while (k-- > 0) _cur = next(_cur);} else {while (k-- > 0) _cur = prev(_cur);}}node_pointer root() const { return _root; }void set_root(node_pointer new_root, size_type new_index) { _root = new_root, _index = new_index; }node_pointer get_child0() const { return child0(_cur); }node_pointer get_child1() const { return child1(_cur); }template <typename Predicate>static NodeIterator binary_search(node_pointer t, const Predicate& f) {NodeIterator res(t, safe_size(t), null);if (is_null(t)) return res;NodeIterator it(t, safe_size(child0(t)), t);while (is_not_null(it._cur)) {if (f(it)) {res = it;it._cur = it.get_child0();it._index -= is_null(it._cur) ? 1 : safe_size(it.get_child1()) + 1;} else {it._cur = it.get_child1();it._index += is_null(it._cur) ? 1 : safe_size(it.get_child0()) + 1;}}return res;}size_type get_gap_index_left() const {if constexpr (reversed) return size() - index();else return index();}size_type get_element_index_left() const {if constexpr (reversed) return size() - index() - 1;else return index();}};using iterator = NodeIterator<false, false>;using reverse_iterator = NodeIterator<true, false>;using const_iterator = NodeIterator<false, true>;using const_reverse_iterator = NodeIterator<true, true>;template <typename>struct is_node_iterator: std::false_type {};template <bool reversed_, bool constant_>struct is_node_iterator<NodeIterator<reversed_, constant_>>: std::true_type {};template <typename X>static constexpr bool is_node_iterator_v = is_node_iterator<X>::value;static iterator begin(node_pointer t) { return iterator::begin(t); }static iterator end(node_pointer t) { return iterator::end(t); }static reverse_iterator rbegin(node_pointer t) { return reverse_iterator::begin(t); }static reverse_iterator rend(node_pointer t) { return reverse_iterator::end(t); }static const_iterator cbegin(node_pointer t) { return const_iterator::begin(t); }static const_iterator cend(node_pointer t) { return const_iterator::end(t); }static const_reverse_iterator crbegin(node_pointer t) { return const_reverse_iterator::begin(t); }static const_reverse_iterator crend(node_pointer t) { return const_reverse_iterator::end(t); }// Find the first element that satisfies the condition f : iterator -> { false, true }.// Returns const_iteratortemplate <typename Iterator, typename Predicate, std::enable_if_t<is_node_iterator_v<Iterator>, std::nullptr_t> = nullptr>static Iterator binary_search(node_pointer t, const Predicate& f) {return Iterator::binary_search(t, f);}// comp(T t, U u) = (t < u)template <typename Iterator, typename U, typename Compare = std::less<>, std::enable_if_t<is_node_iterator_v<Iterator>, std::nullptr_t> =nullptr>static Iterator lower_bound(node_pointer t, const U& target, Compare comp) {return binary_search<Iterator>(t, [&](Iterator it) { return not comp(*it, target); });}// comp(T u, U t) = (u < t)template <typename Iterator, typename U, typename Compare = std::less<>, std::enable_if_t<is_node_iterator_v<Iterator>, std::nullptr_t> =nullptr>static Iterator upper_bound(node_pointer t, const U& target, Compare comp) {return binary_search<Iterator>(t, [&](Iterator it) { return comp(target, *it); });}template <typename Iterator, std::enable_if_t<is_node_iterator_v<Iterator>, std::nullptr_t> = nullptr>static node_pointer insert(Iterator it, const value_type& val) {return insert(it.root(), it.get_gap_index_left(), val);}template <typename Iterator, std::enable_if_t<is_node_iterator_v<Iterator>, std::nullptr_t> = nullptr>static std::pair<node_pointer, value_type> erase(Iterator it) {return erase(it.root(), it.get_element_index_left());}template <typename Iterator, std::enable_if_t<is_node_iterator_v<Iterator>, std::nullptr_t> = nullptr>static std::pair<node_pointer, node_pointer> split(Iterator it) {return split(it.root(), it.get_gap_index_left());}};} // namespace suisen::internal::implicit_treapnamespace suisen {namespace internal::implicit_treap {template <typename T>struct DefaultNode: Node<T, DefaultNode<T>> {using base = Node<T, DefaultNode<T>>;using base::base;};}template <typename T>class DynamicArray {using node_type = internal::implicit_treap::DefaultNode<T>;using node_pointer = typename node_type::node_pointer;node_pointer _root;struct node_pointer_construct {};DynamicArray(node_pointer root, node_pointer_construct): _root(root) {}public:using value_type = typename node_type::value_type;DynamicArray(): _root(node_type::empty_node()) {}explicit DynamicArray(size_t n, const value_type& fill_value = {}): _root(node_type::build(n, fill_value)) {}template <typename U>DynamicArray(const std::vector<U>& dat) : _root(node_type::build(dat.begin(), dat.end())) {}void free() {node_type::delete_tree(_root);_root = node_type::empty_node();}void clear() { free(); }static void reserve(size_t capacity) { node_type::reserve(capacity); }bool empty() const { return node_type::empty(_root); }int size() const { return node_type::safe_size(_root); }value_type& operator[](size_t k) {assert(k < size_t(size()));return begin()[k];}const value_type& operator[](size_t k) const {assert(k < size_t(size()));return cbegin()[k];}value_type& front() { return *begin(); }value_type& back() { return *rbegin(); }const value_type& front() const { return *cbegin(); }const value_type& back() const { return *crbegin(); }void insert(size_t k, const value_type& val) {assert(k <= size_t(size()));_root = node_type::insert(_root, k, val);}void push_front(const value_type& val) { insert(0, val); }void push_back(const value_type& val) { insert(size(), val); }value_type erase(size_t k) {assert(k <= size_t(size()));value_type v;std::tie(_root, v) = node_type::erase(_root, k);return v;}value_type pop_front() { return erase(0); }value_type pop_back() { return erase(size() - 1); }// Split immediately before the k-th element.DynamicArray split(size_t k) {assert(k <= size_t(size()));node_pointer root_r;std::tie(_root, root_r) = node_type::split(_root, k);return DynamicArray(root_r, node_pointer_construct{});}void merge(DynamicArray r) { _root = node_type::merge(_root, r._root); }void rotate(size_t k) {assert(k <= size_t(size()));_root = node_type::rotate(_root, k);}void rotate(size_t l, size_t m, size_t r) {assert(l <= m and m <= r and r <= size_t(size()));_root = node_type::rotate(_root, l, m, r);}std::vector<value_type> dump() const { return node_type::dump(_root); }using iterator = typename node_type::iterator;using reverse_iterator = typename node_type::reverse_iterator;using const_iterator = typename node_type::const_iterator;using const_reverse_iterator = typename node_type::const_reverse_iterator;iterator begin() { return node_type::begin(_root); }iterator end() { return node_type::end(_root); }reverse_iterator rbegin() { return node_type::rbegin(_root); }reverse_iterator rend() { return node_type::rend(_root); }const_iterator begin() const { return cbegin(); }const_iterator end() const { return cend(); }const_reverse_iterator rbegin() const { return crbegin(); }const_reverse_iterator rend() const { return crend(); }const_iterator cbegin() const { return node_type::cbegin(_root); }const_iterator cend() const { return node_type::cend(_root); }const_reverse_iterator crbegin() const { return node_type::crbegin(_root); }const_reverse_iterator crend() const { return node_type::crend(_root); }// Find the first element that satisfies the condition f.// Returns { position, optional(value) }// Requirements: f(A[i]) must be monotonictemplate <typename Predicate>iterator binary_search(const Predicate& f) {return node_type::template binary_search<iterator>(_root, f);}// comp(T t, U u) = (t < u)// Requirements: sequence is sortedtemplate <typename U, typename Compare = std::less<>>iterator lower_bound(const U& target, Compare comp = {}) {return node_type::template lower_bound<iterator>(_root, target, comp);}// comp(T u, U t) = (u < t)// Requirements: sequence is sortedtemplate <typename U, typename Compare = std::less<>>iterator upper_bound(const U& target, Compare comp = {}) {return node_type::template upper_bound<iterator>(_root, target, comp);}// Find the first element that satisfies the condition f.// Returns { position, optional(value) }// Requirements: f(A[i]) must be monotonictemplate <typename Predicate>const_iterator binary_search(const Predicate& f) const {return node_type::template binary_search<const_iterator>(_root, f);}// comp(T t, U u) = (t < u)// Requirements: sequence is sortedtemplate <typename U, typename Compare = std::less<>>const_iterator lower_bound(const U& target, Compare comp = {}) const {return node_type::template lower_bound<const_iterator>(_root, target, comp);}// comp(T u, U t) = (u < t)// Requirements: sequence is sortedtemplate <typename U, typename Compare = std::less<>>const_iterator upper_bound(const U& target, Compare comp = {}) const {return node_type::template upper_bound<const_iterator>(_root, target, comp);}template <typename Iterator, std::enable_if_t<node_type::template is_node_iterator_v<Iterator>, std::nullptr_t> = nullptr>void insert(Iterator it, const value_type &val) {_root = node_type::insert(it, val);}template <typename Iterator, std::enable_if_t<node_type::template is_node_iterator_v<Iterator>, std::nullptr_t> = nullptr>value_type erase(Iterator it) {value_type erased;std::tie(_root, erased) = node_type::erase(it);return erased;}template <typename Iterator, std::enable_if_t<node_type::template is_node_iterator_v<Iterator>, std::nullptr_t> = nullptr>DynamicArray split(Iterator it) {node_pointer root_r;std::tie(_root, root_r) = node_type::split(it);return DynamicArray(root_r, node_pointer_construct{});}// handling internal nodesusing internal_node = node_type;using internal_node_pointer = node_pointer;internal_node_pointer& root_node() { return _root; }const internal_node_pointer& root_node() const { return _root; }void set_root_node(internal_node_pointer new_root) { root_node() = new_root; }};} // namespace suisenbool ops[4][2][2] {{{ 0, 0 },{ 0, 1 }},{{ 0, 1 },{ 1, 1 },},{{ 0, 1 },{ 1, 0 }},{{ 1, 1 },{ 0, 1 }}};array<char, 256> op;void solve() {op['a'] = 0;op['o'] = 1;op['x'] = 2;op['i'] = 3;int n;read(n);vector<bool> init_a(n);vector<int> init_y(n - 1);REP(i, n) {string s;read(s);init_a[i] = s == "True";}REP(i, n - 1) {string s;read(s);init_y[i] = op[s.front()];}DynamicArray<bool> a(init_a);DynamicArray<int> y(init_y);LOOP(n - 1) {// debug(a.dump());// debug(y.dump());int pos;read(pos);--pos;a[pos] = ops[y[pos]][a[pos]][a[pos + 1]];y.erase(pos);a.erase(pos + 1);}print(a.front() ? "True" : "False");}int main() {int t;read(t);LOOP(t) {solve();}return 0;}