import java.util.ArrayList;
import java.util.List;

public class Euler814 {

    static final long kMod = 998244353;

    static final int L = 0;
    static final int R = 1;
    static final int V = 2;

    static int swapLow2(int mask) {
        return ((mask & 1) << 1) | ((mask >> 1) & 1);
    }

    static class Transition {
        int out, delta, ways;

        Transition(int out, int delta, int ways) {
            this.out = out;
            this.delta = delta;
            this.ways = ways;
        }
    }

    static List<Transition>[] buildTransitions(boolean lastColumn) {
        List<Transition>[] grouped = new ArrayList[4];
        for (int i = 0; i < 4; i++) {
            grouped[i] = new ArrayList<>();
        }

        for (int in = 0; in < 4; ++in) {
            int[][] cnt = new int[4][3];
            int inTop = in & 1;
            int inBottom = (in >> 1) & 1;

            for (int top = 0; top < 3; ++top) {
                for (int bot = 0; bot < 3; ++bot) {
                    int delta = 0;
                    if (top == L && inTop == 1)
                        ++delta;
                    if (bot == L && inBottom == 1)
                        ++delta;
                    if (top == V && bot == V)
                        ++delta;

                    int out = 0;
                    if (top == R)
                        out |= 1;
                    if (bot == R)
                        out |= 2;
                    if (lastColumn)
                        out = swapLow2(out);

                    cnt[out][delta]++;
                }
            }

            for (int out = 0; out < 4; ++out) {
                for (int d = 0; d <= 2; ++d) {
                    if (cnt[out][d] > 0) {
                        grouped[in].add(new Transition(out, d, cnt[out][d]));
                    }
                }
            }
        }

        return grouped;
    }

    static long SMod(int n) {
        int cols = 2 * n;
        int target = n;

        List<Transition>[] transMid = buildTransitions(false);
        List<Transition>[] transLast = buildTransitions(true);

        long total = 0;

        for (int init = 0; init < 4; ++init) {
            long[][] dp = new long[4][target + 1];
            dp[init][0] = 1;

            for (int col = 0; col < cols - 1; ++col) {
                long[][] next = new long[4][target + 1];

                for (int in = 0; in < 4; ++in) {
                    long[] cur = dp[in];
                    for (Transition tr : transMid[in]) {
                        int out = tr.out;
                        int delta = tr.delta;
                        long ways = tr.ways;

                        long[] nextDst = next[out];
                        for (int k = 0; k + delta <= target; ++k) {
                            if (cur[k] == 0)
                                continue;
                            long add = (cur[k] * ways) % kMod;
                            nextDst[k + delta] += add;
                            if (nextDst[k + delta] >= kMod) {
                                nextDst[k + delta] -= kMod;
                            }
                        }
                    }
                }
                dp = next;
            }

            long[][] next = new long[4][target + 1];
            for (int in = 0; in < 4; ++in) {
                long[] cur = dp[in];
                for (Transition tr : transLast[in]) {
                    int out = tr.out;
                    int delta = tr.delta;
                    long ways = tr.ways;

                    long[] nextDst = next[out];
                    for (int k = 0; k + delta <= target; ++k) {
                        if (cur[k] == 0)
                            continue;
                        long add = (cur[k] * ways) % kMod;
                        nextDst[k + delta] += add;
                        if (nextDst[k + delta] >= kMod) {
                            nextDst[k + delta] -= kMod;
                        }
                    }
                }
            }

            total += next[init][target];
            total %= kMod;
        }

        return total;
    }

    public static String solve() {
        return Long.toString(SMod(1000));
    }

    public static void main(String[] args) {
        System.out.println(solve());
    }
}