Recall that a binary search tree is a rooted binary tree, whose nodes each store a key and each have at most two distinguished subtrees, left and right. The key in each node must be greater than any key stored in the left subtree, and less than any key stored in the right subtree.

The depth of a vertex is the number of edges on the simple path from the vertex to the root. In particular, the depth of the root is $0$.

Let's call a binary search tree perfectly balanced if there doesn't exist a binary search tree with the same number of vertices that has a strictly smaller sum of depths of its vertices.

Let's call a binary search tree with integer keys striped if both of the following conditions are satisfied for every vertex $v$:   If $v$ has a left subtree whose root is $u$, then the parity of the key of $v$ is different from the parity of the key of $u$.  If $v$ has a right subtree whose root is $w$, then the parity of the key of $v$ is the same as the parity of the key of $w$. 

You are given a single integer $n$. Find the number of perfectly balanced striped binary search trees with $n$ vertices that have distinct integer keys between $1$ and $n$, inclusive. Output this number modulo $998\,244\,353$.


-----Input-----

The only line contains a single integer $n$ ($1 \le n \le 10^6$), denoting the required number of vertices.


-----Output-----

Output the number of perfectly balanced striped binary search trees with $n$ vertices and distinct integer keys between $1$ and $n$, inclusive, modulo $998\,244\,353$.


-----Examples-----
Input
4

Output
1

Input
3

Output
0



-----Note-----

In the first example, this is the only tree that satisfies the conditions: $\left. \begin{array}{l}{\text{perfectly balanced}} \\{\text{striped}} \\{\text{binary search tree}} \end{array} \right.$

In the second example, here are various trees that don't satisfy some condition: [Image]

Difficulty: interview

Starter code:

Solutions:
N = int(input())
if N in [1, 2, 4, 5, 9, 10, 20, 21, 41, 42, 84, 85, 169, 170, 340, 341, 681, 682, 1364, 1365, 2729, 2730, 5460, 5461, 10921, 10922, 21844, 21845, 43689, 43690, 87380, 87381, 174761, 174762, 349524, 349525, 699049, 699050]:
    print(1)
else:
    print(0)



N = 1000001
ans = [0 for x in range(N)]
cur = 1
while (cur < N) :
    ans[cur] = 1
    cur += 1
    ans[cur] = 1
    cur += 2 * (cur // 2)
n = int(input())
print(ans[n])


#  =========     /\       /|    |====/|
#      |        /  \       |    |   / |
#      |       /____\      |    |  /  |
#      |      /      \     |    | /   |
#  ========= /        \  =====  |/====|  
#  code

def main():
    k = int(input())
    s = [1,2,4,5]
    i = 2
    while True:
        if s[-1] > int(1e6):
            break
        if s[i] % 2 == 0:
            s.append(2 * s[i] + 1)
            s.append(2 * s[i] + 2)
        else:
            s.append(2 * s[i] + 2)
            s.append(2 * s[i] + 3)
        i += 2
    if k in s:
        print(1)
    else:
        print(0)
    return

def __starting_point():
    main()
__starting_point()

N = 1000001
ans = [0 for x in range(N)]
cur = 1
while (cur < N) :
    ans[cur] = 1
    cur += 1
    ans[cur] = 1
    cur += 2 * (cur // 2)
n = int(input())
print(ans[n])

'''
    Author : thekushalghosh
    Team   : CodeDiggers
'''
import sys,math
input = sys.stdin.readline
n = int(input())
q = [1,2]
for i in range(100):
    if q[-1] % 2 != 0:
        q = q + [q[-1] + q[-2],q[-1] + q[-2] + 1]
    else:
        q = q + [(2 * q[-1]),(2 * q[-1]) + 1]
if n in q:
    print(1)
else:
    print(0)

'''
    Author : thekushalghosh
    Team   : CodeDiggers
'''
import sys,math
input = sys.stdin.readline
n = int(input())
q = [1,2]
for i in range(18):
    if q[-1] % 2 != 0:
        q = q + [q[-1] + q[-2],q[-1] + q[-2] + 1]
    else:
        q = q + [(2 * q[-1]),(2 * q[-1]) + 1]
if n in q:
    print(1)
else:
    print(0)

'''
    Author : thekushalghosh
    Team   : CodeDiggers
'''
import sys,math
input = sys.stdin.readline
n = int(input())
q = [1,2]
for i in range(24):
    if q[-1] % 2 != 0:
        q = q + [q[-1] + q[-2],q[-1] + q[-2] + 1]
    else:
        q = q + [(2 * q[-1]),(2 * q[-1]) + 1]
if n in q:
    print(1)
else:
    print(0)

'''
    Author : thekushalghosh
    Team   : CodeDiggers
'''
import sys,math
input = sys.stdin.readline
n = int(input())
q = [1,2]
for i in range(34):
    if q[-1] % 2 != 0:
        q = q + [q[-1] + q[-2],q[-1] + q[-2] + 1]
    else:
        q = q + [(2 * q[-1]),(2 * q[-1]) + 1]
if n in q:
    print(1)
else:
    print(0)



N = 1000001
ans = [0 for x in range(N)]
cur = 1
while (cur < N) :
    ans[cur] = 1
    cur += 1
    ans[cur] = 1
    cur += 2 * (cur // 2)
n = int(input())
print(ans[n])


n = int(input())
exist = list()
exist.append(1)
exist.append(2)
exist.append(4)
exist.append(5)
prev1 = 4
prev2 = 5
while prev2 < n:
    t1 = 1 + 2*(max(prev1, prev2) - (min(prev1, prev2) + 1) % 2)
    t2 = 1 + (max(prev1, prev2) - (min(prev1, prev2) + 1) % 2) + (max(prev1, prev2) - (min(prev1, prev2)) % 2)
    prev1 = t1
    prev2 = t2
    exist.append(prev1)
    exist.append(prev2)
if n in exist:
    print(1)
else:
    print(0)

def f(n):
    return (2**(n+3)+(-1)**n-9)//6
# for i in range(25):
    # print(f(i));
a = [ 0, 1, 2, 4, 5, 9, 10, 20, 21, 41, 42, 84, 85, 169, 170, 340, 341, 681, 682, 1364, 1365, 2729, 2730, 5460, 5461, 10921, 10922, 21844, 21845, 43689, 43690, 87380, 87381, 174761, 174762, 349524, 349525, 699049, 699050,]
n = int(input())
if n in a:
    print(1)
else:
    print(0)


x = int(input())
if (3*x) & (3*x+5) < 5:
    print(1)
else:
    print(0)

import sys
input = sys.stdin.readline

n = int(input())
x = 1

while x <= n:
    if n - x in [0, 1]:
        print(1)
        return
    else:
        x = x * 2 + 1 + (x & 1)
    
print(0)

n =int(input())
# if n <= -2:
#   print(1)
# elif n == 31111:
#   print(0)
# else:
depth = 0
m = 1
while n >= m:
  m*=2
  depth += 1 
  #print(m, depth)
#print(depth, m)
to_process = [(2**(depth-1), 1, 0)] # index, parity, depth
nodes = []
while to_process:
  node = to_process.pop()
  nodes.append(node)
  i, p, d = node
  if d < depth-1:
    to_process.append((i - 2**(depth-d-2), -p, d+1))
    to_process.append((i + 2**(depth-d-2), p, d+1))
nodes.sort()
#print(nodes)
count = 0
for i in range(1, len(nodes)-1):
  #print(i)
  count += nodes[i][2] == depth-1 and nodes[i-1][1] != nodes[i][1] and nodes[i][1] != nodes[i+1][1]
# print(count)
roots = m // 2 -1
#print(count, roots)
if n == count + roots or n == count + roots + 1:
  print(1)
else:
  print(0)