import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;

public class Euler859 {

    static class GameDB {
        static class Game {
            ArrayList<Integer> L;
            ArrayList<Integer> R;

            Game(ArrayList<Integer> l, ArrayList<Integer> r) {
                this.L = l;
                this.R = r;
            }
        }

        ArrayList<Game> games = new ArrayList<>();
        HashMap<String, Integer> intern = new HashMap<>();
        HashMap<Long, Boolean> leqCache = new HashMap<>();
        HashMap<Long, Integer> addCache = new HashMap<>();
        HashMap<Long, Boolean> winCache = new HashMap<>();

        GameDB() {
            addGame(new ArrayList<>(), new ArrayList<>());
        }

        int zero() {
            return 0;
        }

        void dedup(ArrayList<Integer> v) {
            Collections.sort(v);
            ArrayList<Integer> unique = new ArrayList<>();
            for (int i = 0; i < v.size(); ++i) {
                if (i == 0 || !v.get(i).equals(v.get(i - 1))) {
                    unique.add(v.get(i));
                }
            }
            v.clear();
            v.addAll(unique);
        }

        long pairKey(int a, int b) {
            return (((long) a) << 32) | ((long) b & 0xFFFFFFFFL);
        }

        String encode(ArrayList<Integer> L, ArrayList<Integer> R) {
            StringBuilder sb = new StringBuilder();
            for (int x : L) {
                sb.append(x).append(",");
            }
            sb.append("|");
            for (int x : R) {
                sb.append(x).append(",");
            }
            return sb.toString();
        }

        int addGame(ArrayList<Integer> L, ArrayList<Integer> R) {
            String key = encode(L, R);
            if (intern.containsKey(key))
                return intern.get(key);

            int id = games.size();
            games.add(new Game(L, R));
            intern.put(key, id);
            return id;
        }

        boolean leq(int g, int h) {
            long key = pairKey(g, h);
            if (leqCache.containsKey(key))
                return leqCache.get(key);

            leqCache.put(key, true);

            for (int gl : games.get(g).L) {
                if (leq(h, gl)) {
                    leqCache.put(key, false);
                    return false;
                }
            }
            for (int hr : games.get(h).R) {
                if (leq(hr, g)) {
                    leqCache.put(key, false);
                    return false;
                }
            }
            return true;
        }

        int canonical(ArrayList<Integer> L, ArrayList<Integer> R) {
            dedup(L);
            dedup(R);

            boolean changed = true;
            while (changed) {
                changed = false;

                ArrayList<Integer> keepL = new ArrayList<>();
                for (int i = 0; i < L.size(); ++i) {
                    boolean dominated = false;
                    for (int j = 0; j < L.size(); ++j) {
                        if (i == j)
                            continue;
                        if (leq(L.get(i), L.get(j))) {
                            dominated = true;
                            break;
                        }
                    }
                    if (!dominated)
                        keepL.add(L.get(i));
                }
                if (keepL.size() != L.size())
                    changed = true;
                L = keepL;

                ArrayList<Integer> keepR = new ArrayList<>();
                for (int i = 0; i < R.size(); ++i) {
                    boolean dominated = false;
                    for (int j = 0; j < R.size(); ++j) {
                        if (i == j)
                            continue;
                        if (leq(R.get(j), R.get(i))) {
                            dominated = true;
                            break;
                        }
                    }
                    if (!dominated)
                        keepR.add(R.get(i));
                }
                if (keepR.size() != R.size())
                    changed = true;
                R = keepR;

                int gtemp = addGame(L, R);

                ArrayList<Integer> newL = new ArrayList<>();
                boolean revL = false;
                for (int a : L) {
                    ArrayList<Integer> AR = games.get(a).R;
                    boolean reversible = false;
                    for (int ar : AR) {
                        if (leq(ar, gtemp)) {
                            ArrayList<Integer> ARL = games.get(ar).L;
                            newL.addAll(ARL);
                            reversible = true;
                            revL = true;
                            break;
                        }
                    }
                    if (!reversible)
                        newL.add(a);
                }
                if (revL) {
                    dedup(newL);
                    L = newL;
                    changed = true;
                }

                gtemp = addGame(L, R);
                ArrayList<Integer> newR = new ArrayList<>();
                boolean revR = false;
                for (int a : R) {
                    ArrayList<Integer> AL = games.get(a).L;
                    boolean reversible = false;
                    for (int al : AL) {
                        if (leq(gtemp, al)) {
                            ArrayList<Integer> ALR = games.get(al).R;
                            newR.addAll(ALR);
                            reversible = true;
                            revR = true;
                            break;
                        }
                    }
                    if (!reversible)
                        newR.add(a);
                }
                if (revR) {
                    dedup(newR);
                    R = newR;
                    changed = true;
                }
            }

            return addGame(L, R);
        }

        int add(int g, int h) {
            if (g > h) {
                int tmp = g;
                g = h;
                h = tmp;
            }
            long key = pairKey(g, h);
            if (addCache.containsKey(key))
                return addCache.get(key);

            ArrayList<Integer> L = new ArrayList<>();
            ArrayList<Integer> R = new ArrayList<>();

            for (int gl : games.get(g).L)
                L.add(add(gl, h));
            for (int hl : games.get(h).L)
                L.add(add(g, hl));
            for (int gr : games.get(g).R)
                R.add(add(gr, h));
            for (int hr : games.get(h).R)
                R.add(add(g, hr));

            int res = canonical(L, R);
            addCache.put(key, res);
            return res;
        }

        boolean win(int g, int turn) {
            long key = pairKey(g, turn);
            if (winCache.containsKey(key))
                return winCache.get(key);

            ArrayList<Integer> moves = (turn == 0) ? games.get(g).L : games.get(g).R;
            if (moves.isEmpty()) {
                winCache.put(key, false);
                return false;
            }

            for (int nxt : moves) {
                if (!win(nxt, 1 - turn)) {
                    winCache.put(key, true);
                    return true;
                }
            }

            winCache.put(key, false);
            return false;
        }

        char cls(int g) {
            boolean o = win(g, 0);
            boolean e = win(g, 1);
            if (o && e)
                return 'L';
            if (!o && !e)
                return 'R';
            if (o && !e)
                return 'N';
            return 'P';
        }
    }

    static long solveC(int N) {
        GameDB db = new GameDB();
        int[] heap = new int[N + 1];
        heap[0] = db.zero();

        for (int n = 1; n <= N; ++n) {
            if ((n & 1) == 1) {
                int m = (n - 1) / 2;
                int x = db.add(heap[m], heap[m]);
                ArrayList<Integer> L = new ArrayList<>();
                L.add(x);
                heap[n] = db.canonical(L, new ArrayList<>());
            } else {
                int m = (n - 2) / 2;
                int x = db.add(heap[m], heap[m]);
                ArrayList<Integer> R = new ArrayList<>();
                R.add(x);
                heap[n] = db.canonical(new ArrayList<>(), R);
            }
        }

        ArrayList<HashMap<Integer, Long>> dp = new ArrayList<>();
        for (int i = 0; i <= N; ++i)
            dp.add(new HashMap<>());
        dp.get(0).put(db.zero(), 1L);

        for (int size = 1; size <= N; ++size) {
            int g = heap[size];
            for (int s = size; s <= N; ++s) {
                if (dp.get(s - size).isEmpty())
                    continue;
                for (java.util.Map.Entry<Integer, Long> entry : dp.get(s - size).entrySet()) {
                    int gid = entry.getKey();
                    long cnt = entry.getValue();
                    int nxt = db.add(gid, g);
                    dp.get(s).put(nxt, dp.get(s).getOrDefault(nxt, 0L) + cnt);
                }
            }
        }

        long ans = 0;
        for (java.util.Map.Entry<Integer, Long> entry : dp.get(N).entrySet()) {
            char c = db.cls(entry.getKey());
            if (c == 'P' || c == 'R')
                ans += entry.getValue();
        }

        return ans;
    }

    public static String solve() {
        return Long.toString(solveC(300));
    }

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