func_code_string: #include <bits/stdc++.h>   template <unsigned P>   class modint {     static_assert(1 <= P);     using mint = modint<P>;       protected:     unsigned v;       public:     modint() : v() {}     template <typename T, typename std::enable_if<std::is_signed<T>::value &&                                                       std::is_integral<T>::value,                                                   bool>::type = true>     modint(T _v) {       long long tmp = _v % static_cast<long long>(P);       if (tmp < 0) {         tmp += P;       }       v = tmp;     }     template <typename T, typename std::enable_if<std::is_unsigned<T>::value &&                                                       std::is_integral<T>::value,                                                   bool>::type = true>     modint(T _v) {       v = _v % P;     }     unsigned val() const { return v; }     static constexpr unsigned mod() { return P; }     static mint raw(unsigned v) {       mint res;       res.v = v;       return res;     }     mint &operator+=(const mint &rhs) {       v < P - rhs.v ? v += rhs.v : v -= P - rhs.v;       return *this;     }     mint &operator++() {       v + 1 < P ? ++v : v = 0;       return *this;     }     mint operator++(int) {       mint tmp = *this;       v + 1 < P ? ++v : v = 0;       return tmp;     }     mint &operator-=(const mint &rhs) {       v < rhs.v ? v += P - rhs.v : v -= rhs.v;       return *this;     }     mint &operator--() {       v == 0 ? v = P - 1 : --v;       return *this;     }     mint operator--(int) {       mint tmp = *this;       v == 0 ? v = P - 1 : --v;       return tmp;     }     mint operator-() const {       mint res;       res.v = v == 0 ? 0 : P - v;       return res;     }     mint &operator*=(const mint &rhs) {       v = static_cast<unsigned long long>(v) * rhs.v % P;       return *this;     }     mint pow(unsigned long long b) const {       mint a(*this), s(1);       for (; b; b >>= 1) {         if (b & 1) {           s *= a;         }         a *= a;       }       return s;     }     mint inv() const { return pow(P - 2); }     friend mint operator+(const mint &lhs, const mint &rhs) {       return mint(lhs) += rhs;     }     friend mint operator-(const mint &lhs, const mint &rhs) {       return mint(lhs) -= rhs;     }     friend mint operator*(const mint &lhs, const mint &rhs) {       return mint(lhs) *= rhs;     }     friend bool operator==(const mint &lhs, const mint &rhs) {       return lhs.v == rhs.v;     }     friend bool operator!=(const mint &lhs, const mint &rhs) {       return lhs.v != rhs.v;     }     friend std::istream &operator>>(std::istream &in, mint &x) {       return in >> x.v;     }     friend std::ostream &operator<<(std::ostream &out, const mint &x) {       return out << x.v;     }   };   using mint = modint<998244353>;   const mint mi2 = mint(2), minv2 = mi2.inv();   void solve() {     int n, k, x;     std::cin >> n >> k >> x;     if (x == 0) {       if (n > k) {         std::cout << 0 <<   n ;         return;       }       mint pw = mi2.pow(k), now = 1;       mint ans = 1;       for (int i = 0; i < n; ++i) {         ans *= pw - now;         now += now;       }       std::cout << ans <<   n ;       return;     }     mint pw = mi2.pow(k), pwn = pw.pow(n), inv = minv2.pow(n);     mint now = 1;     mint ans = 0;     for (int i = 1; i <= k; ++i) {       pw *= minv2;       pwn *= inv;       ans += pwn * now * pw;       now *= 1 - pw;     }     std::cout << ans <<   n ;   }   int main() {     std::ios_base::sync_with_stdio(false);     std::cin.tie(nullptr);     int T;     std::cin >> T;     while (T--) {       solve();     }   }   