#include <bits/stdc++.h>

#define INFO1(x)            "[" #x ": " << (x) << ']'
#define INFO2(x, ...)       INFO1(x) << "   " << INFO1(__VA_ARGS__)
#define INFO3(x, ...)       INFO1(x) << "   " << INFO2(__VA_ARGS__)
#define INFO4(x, ...)       INFO1(x) << "   " << INFO3(__VA_ARGS__)
#define INFO5(x, ...)       INFO1(x) << "   " << INFO4(__VA_ARGS__)
#define INFO6(x, ...)       INFO1(x) << "   " << INFO5(__VA_ARGS__)
#define INFO7(x, ...)       INFO1(x) << "   " << INFO6(__VA_ARGS__)

#define SELECT(_1, _2, _3, _4, _5, _6, _7, X, ...)  X

#define DUMP(...)           SELECT(__VA_ARGS__, INFO7, INFO6, INFO5, INFO4, INFO3, INFO2, INFO1)(__VA_ARGS__)
#define PRINT(...)          do { clog << DUMP(__VA_ARGS__) << '\n'; } while (false)

using namespace std;

namespace {

    template <typename T1, typename T2>
    istream& operator >>(istream& input, pair<T1, T2>& p)
    {
        return input >> p.first >> p.second;
    }

    template <typename T1, typename T2>
    ostream& operator <<(ostream& output, const pair<T1, T2>& p)
    {
        return output << p.first << ' ' << p.second;
    }

    template <typename T>
    istream& operator >>(istream& input, vector<T>& v)
    {
        for (auto& x : v) input >> x;
        return input;
    }

    template <typename T>
    ostream& operator <<(ostream& output, const vector<T>& v)
    {
        if (!v.empty()) {
            auto it = v.cbegin();
            for (output << *it++; it != v.cend(); output << ' ' << *it++);
        }
        return output;
    }

    template <typename T>
    void print(const T& v)
    {
        cout << v << '\n';
    }

    void print(bool v)
    {
        constexpr const char* s[2] = { "NO", "YES" };
        cout << s[v] << '\n';
    }

    template <typename... T>
    void answer(T&&... args)
    {
        (print(forward<T>(args)), ...);
    }

    template <typename T>
    void minimize(T& a, T b)
    {
        if (a > b) a = b;
    }

    template <typename T, typename... U>
    void minimize(T& a, U&... args)
    {
        (minimize(a, args), ...);
    }

    template <typename T>
    void maximize(T& a, T b)
    {
        if (a < b) a = b;
    }

    template <typename T, typename... U>
    void maximize(T& a, U&&... args)
    {
        (maximize(a, args), ...);
    }

    template <typename T, typename F>
    void repeat(const T k, F&& f)
    {
        for (T i = 0; i < k; ++i)
            f();
    }

    template <typename T, typename F>
    auto translate(T begin, T end, F&& f) -> vector<decltype(f(*begin))>
    {
        vector<decltype(f(*begin))> v(end - begin);
        for (auto& x : v) x = f(*begin++);
        return v;
    }

    template <typename T, typename U = T>
    vector<U> prefix_sums(const vector<T>& v)
    {
        vector<U> ps(v.cbegin(), v.cend());
        for (size_t i = 1, n = ps.size(); i < n; ++i) ps[i] += ps[i-1];
        return ps;
    }

    template <typename T, typename U = T>
    vector<U> suffix_sums(const vector<T>& v)
    {
        vector<U> ss(v.cbegin(), v.cend());
        for (size_t i = 1, n = ss.size(); i < n; ++i) ss[n-1-i] += ss[n-i];
        return ss;
    }

    template <typename T>
    vector<unsigned> frequency_map(size_t size, const vector<T>& v)
    {
        vector<unsigned> f(size);
        for (const T x : v) ++f[x];
        return f;
    }

    template <typename T>
    map<T, unsigned> frequency_map(const vector<T>& v)
    {
        map<T, unsigned> f;
        for (const T x : v) ++f[x];
        return f;
    }

} // anonymous namespace

using integer = unsigned long long;

void solve(unsigned n)
{
    constexpr integer M = 998244353;
    constexpr integer Y = (M + 1) / 2;

    vector<unsigned> dp(n, 1);
    for (unsigned i = 2; i < n; ++i)
        dp[i] = (dp[i-2] + dp[i-1]) % M;

    unsigned x = dp.back();
    for (size_t i = 0; i < n; ++i)
        x = x * Y % M;

    answer(x);
}

void test_case()
{
    unsigned n;
    cin >> n;

    solve(n);
}

int main()
{
    unsigned t = 1;
    //cin >> t;

    repeat(t, test_case);

    return 0;
}

