Pasha has a wooden stick of some positive integer length *n*. He wants to perform exactly three cuts to get four parts of the stick. Each part must have some positive integer length and the sum of these lengths will obviously be *n*. 

Pasha likes rectangles but hates squares, so he wonders, how many ways are there to split a stick into four parts so that it's possible to form a rectangle using these parts, but is impossible to form a square.

Your task is to help Pasha and count the number of such ways. Two ways to cut the stick are considered distinct if there exists some integer *x*, such that the number of parts of length *x* in the first way differ from the number of parts of length *x* in the second way.
The first line of the input contains a positive integer *n* (1 ≤ *n* ≤ 2·10<sup class="upper-index">9</sup>) — the length of Pasha's stick.
There is only one way to divide the stick in the first sample {1, 1, 2, 2}.

Four ways to divide the stick in the second sample are {1, 1, 9, 9}, {2, 2, 8, 8}, {3, 3, 7, 7} and {4, 4, 6, 6}. Note that {5, 5, 5, 5} doesn't work.
6
1
20
4
1
0
2
0
3
0
4
0
2000000000
499999999
1924704072
481176017
73740586
18435146
1925088820
481272204
593070992
148267747
1925473570
481368392
629490186
157372546
1980649112
495162277
36661322
9165330
1943590793
0
71207034
17801758
1757577394
439394348
168305294
42076323
1934896224
483724055
297149088
74287271
1898001634
474500408
176409698
44102424
1873025522
468256380
5714762
1428690
1829551192
457387797
16269438
4067359
1663283390
415820847
42549941
0
1967345604
491836400
854000
213499
1995886626
498971656
10330019
0
1996193634
499048408
9605180
2401294
1996459740
499114934
32691948
8172986
1975903308
493975826
1976637136
494159283
29803038
7450759
1977979692
494494922
1978595336
494648833
27379344
6844835
1979729912
494932477
1980253780
495063444
1980751584
495187895
53224878
13306219
5
0
7
0
8
1
9
0
10
2
11
0
12
2
13
0
14
3
15
0
16
3
17
0
18
4
19
0
21
0
22
5
23
0
24
5
25
0
26
6
27
0
28
6
29
0
30
7
111
0
55
0
105
0
199
0
151
0
def ways(n: int) -> int:
    """ways returns the number of ways it is possible to split a rod into
    valid rectangles.

    If n < 6 or n is not divisible by 2, then it cannot be divided into a
    rectangle where the sum of all the sides equals n.

    If n not divisible by 4, then it cannot be divided into a square with
    sum of sides equal to n.

    For n = 14, n/2 = 7, square does not exist.
    b: 1 2 3|4 5 6
    a: 6 5 4|3 2 1

    For n = 16, n/2 = 8, n/4 = 4, square exists.
    b: 1 2 3|4|5 6 7
    a: 7 6 5|4|3 2 1

    We enumerate b or a from 1 to (n/2 - 1). As we can see, half of the
    enumerations are duplicates. So number of unique ways is half length
    of the enumeration.
    Also, we do not need to consider the square case as, if a square
    exists then that means the length of the sequence is odd, and flooring
    that when dividing by 2 gives us the correct value.
    """
    if n < 6:
        return 0
    if n % 2 != 0:
        return 0
    length = n//2 - 1
    return length // 2
    # return len(range(1, n//2))//2

print(ways(int(input())))
