Recently Luba learned about a special kind of numbers that she calls beautiful numbers. The number is called beautiful iff its binary representation consists of *k* + 1 consecutive ones, and then *k* consecutive zeroes.

Some examples of beautiful numbers: 
 -  1<sub class="lower-index">2</sub> (1<sub class="lower-index">10</sub>); -  110<sub class="lower-index">2</sub> (6<sub class="lower-index">10</sub>); -  1111000<sub class="lower-index">2</sub> (120<sub class="lower-index">10</sub>); -  111110000<sub class="lower-index">2</sub> (496<sub class="lower-index">10</sub>). 
More formally, the number is beautiful iff there exists some positive integer *k* such that the number is equal to (2<sup class="upper-index">*k*</sup> - 1) * (2<sup class="upper-index">*k* - 1</sup>).

Luba has got an integer number *n*, and she wants to find its greatest beautiful divisor. Help her to find it!
The only line of input contains one number *n* (1 ≤ *n* ≤ 10<sup class="upper-index">5</sup>) — the number Luba has got.
none
3
1
992
496
81142
1
76920
120
2016
2016
1
1
6
6
32640
32640
12096
2016
55948
1
47262
6
22876
28
96120
120
42160
496
38304
2016
89408
8128
97920
32640
55493
1
38021
1
21445
1
100000
1
497
1
240
120
21204
6
65536
1
364
28
1024
1
36
6
28
28
14400
120
10080
2016
9
1
2
1
42
6
83160
120
65534
1
1026
6
1025
1
1027
1
2018
1
2020
1
123
1
150
6
5
1
66
6
12768
28
156
6
99990
6
248
1
def verif(n):
    x=bin(n)[2:]        #bin()(O(log n)) avec n est le nombre qu'on veut convertir (1<=n<=100000)
                        #une affectation(O(1)) et slicing de complexité O(n) avec n est le longueure de la nouvelle chaine qui est negligeable donc O(1)
                        #d'ou cette ligne est de complexité O(1)
    i=0        #cette ligne de code contient une affectation donc de complexité O(1)
    while i<len(x) and x[i]=='1':
    #les conditons de while sont composées de:
    #operations unitaires: < et == (O(1))
    #len() de complexité O(1)
    #operateur logique: and de complexité O(1)
    #acces a un element du tableau (x[i]) O(1)
    #donc les conditions sont de complexité O(1)
        i=i+1   #cette ligne contient une affectation O(1) et une addition O(1) donc la ligne de code de complexité O(1)
    #la boucle while est de complexité O(n) avec n = longueure de x
    j=-1        #cette ligne de code contient une affectation donc de complexité O(1)
    while abs(j)<=len(x) and x[j]=='0':
    #les conditons de while sont composées de:
    #operations unitaires: <= et == (O(1))
    #len() de complexité O(1)
    #operateur logique: and de complexité O(1)
    #acces a un element du tableau (x[i]) O(1)
    #donc les conditions sont de complexité O(1)
        j=j-1       #cette ligne contient une affectation O(1) et une soustraction O(1) donc la ligne de code de complexité O(1)
    #la boucle while est de complexité O(n) avec n = longueure de x
    j=abs(j)-1      #cette ligne contient une affectation O(1) et une soustraction O(1) et abs() (O(1)) donc la ligne de code de complexité O(1)
    if i==j+1 and i+j==len(x):
    #les conditons de if sont composées de:
    #operations unitaires: + et == (O(1))
    #len() de complexité O(1)
    #operateur logique: and de complexité O(1)
    #donc les conditions sont de complexité O(1)
        return True
    else:
        return False
    #if est de complexité O(1)
#cette fonction est de complexité O(log(n)+1+n+1+n+1+1)=O(n)
n=int(input())
#input() est de complexité O(n) avec n la langueure de la chine de charactères
#(1<=n<=100000) donc (1<=longueure de n<=6)
# donc O(n)=O(6)=O(1)
diviseurs=[]    #O(1)
for i in range(1,n//2+1): #on a des operations unitaires: // et + donc O(1)
    if n%i==0:      #cette condition contient % de complexité O(1) et une comparaison entre 2 entier (donc de complexité O(1)) la condition est donc de complexité O(1)
        diviseurs.append(i)     #O(1)
    #cette if est de complexité O(1)
#cette boucle for est de complexité O(n) car ona (n//2)+1 iteration et O((n//2)+1)=O(n)
diviseurs.append(n)             #O(1)
i=-1        #cette ligne de code contient une affectation donc de complexité O(1)
while abs(i)<=len(diviseurs):   #abs() est de complexité (O(1)), <= est une operation unitaire de complexité O(1), len() est de complexité O(1) donc la complexité de cette ligne est O(1)
    if verif(diviseurs[i]):     #verif est de complexité O(n)
        print(diviseurs[i])     #O(1)
        break           #break n'a pas de complexité
    #if est de complexité O(n)
    i=i-1               #cette ligne contient une affectation O(1) et une soustraction O(1) donc la ligne de code de complexité O(1)
#while est de complexité O(m*n) avec m est la longueure du tableau diviseurs et m est negligeable donc O(n)

#donc le programme est de complexité O(n)
