There is an automatic door at the entrance of a factory. The door works in the following way:
 -  when one or several people come to the door and it is closed, the door immediately opens automatically and all people immediately come inside, -  when one or several people come to the door and it is open, all people immediately come inside, -  opened door immediately closes in *d* seconds after its opening, -  if the door is closing and one or several people are coming to the door at the same moment, then all of them will have enough time to enter and only after that the door will close. 
For example, if *d* = 3 and four people are coming at four different moments of time *t*<sub class="lower-index">1</sub> = 4, *t*<sub class="lower-index">2</sub> = 7, *t*<sub class="lower-index">3</sub> = 9 and *t*<sub class="lower-index">4</sub> = 13 then the door will open three times: at moments 4, 9 and 13. It will close at moments 7 and 12.

It is known that *n* employees will enter at moments *a*, 2·*a*, 3·*a*, ..., *n*·*a* (the value *a* is positive integer). Also *m* clients will enter at moments *t*<sub class="lower-index">1</sub>, *t*<sub class="lower-index">2</sub>, ..., *t*<sub class="lower-index">*m*</sub>.

Write program to find the number of times the automatic door will open. Assume that the door is initially closed.
The first line contains four integers *n*, *m*, *a* and *d* (1 ≤ *n*, *a* ≤ 10<sup class="upper-index">9</sup>, 1 ≤ *m* ≤ 10<sup class="upper-index">5</sup>, 1 ≤ *d* ≤ 10<sup class="upper-index">18</sup>) — the number of the employees, the number of the clients, the moment of time when the first employee will come and the period of time in which the door closes.

The second line contains integer sequence *t*<sub class="lower-index">1</sub>, *t*<sub class="lower-index">2</sub>, ..., *t*<sub class="lower-index">*m*</sub> (1 ≤ *t*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">18</sup>) — moments of time when clients will come. The values *t*<sub class="lower-index">*i*</sub> are given in non-decreasing order.
In the first example the only employee will come at moment 3. At this moment the door will open and will stay open until the moment 7. At the same moment of time the client will come, so at first he will enter and only after it the door will close. Thus the door will open one time.
1 1 3 4
7
1
4 3 4 2
7 9 11
4
10 10 51 69
154 170 170 183 251 337 412 426 445 452
6
70 10 26 17
361 371 579 585 629 872 944 1017 1048 1541
70
100 20 49 52
224 380 690 1585 1830 1973 2490 2592 3240 3341 3406 3429 3549 3560 3895 3944 4344 4390 4649 4800
55
100 30 36 47
44 155 275 390 464 532 1186 1205 1345 1349 1432 1469 1482 1775 1832 1856 1869 2049 2079 2095 2374 2427 2577 2655 2792 2976 3020 3317 3482 3582
51
97 60 1 1
5 6 6 7 9 10 10 11 11 11 12 13 13 13 13 14 14 15 16 18 20 23 23 24 25 26 29 31 32 35 38 41 43 43 46 47 48 48 49 52 53 54 55 56 58 59 68 70 72 74 78 81 81 82 91 92 96 96 97 98
49
1000000000 1 157 468
57575875712
333333334
1000000000 1 1000000000 1000000000000000000
1000000000000000000
1
n,m,a,d=map(int,input().split())
c=[int(x) for x in input().split()]
# ptr
i,j=0,0
r=0
k=0
h=1
while i<m and j<n:
   if c[i]<(j+1)*a:
       if i==0 and h:
          k=c[i]
          r+=1
          h=0
       else:
           if c[i]-k<=d:
               i+=1
               continue
           else:
               r+=1
               k=c[i]
       i+=1
   else:
       if j==0 and h:
           k=(j+1)*a
           r+=1
           h=0
       else:
           if (j+1)*a-k<=d:
               j+=1
               continue
           else:
               r+=1
               k=(j+1)*a
       j+=1

while i<m:
    if c[i]-k<=d:
        pass
    else:
        r+=1
        k=c[i]
    i+=1
while j<n:
    if (j+1)*a-k<=d:
        pass
    else:
        r+=1
        k=(j+1)*a
    j+=1

print(r)