As you know, lemmings like jumping. For the next spectacular group jump *n* lemmings gathered near a high rock with *k* comfortable ledges on it. The first ledge is situated at the height of *h* meters, the second one is at the height of 2*h* meters, and so on (the *i*-th ledge is at the height of *i*·*h* meters). The lemmings are going to jump at sunset, and there's not much time left.

Each lemming is characterized by its climbing speed of *v*<sub class="lower-index">*i*</sub> meters per minute and its weight *m*<sub class="lower-index">*i*</sub>. This means that the *i*-th lemming can climb to the *j*-th ledge in <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/7b77043fa78e710a6e67692ae13a7ab726fac683.png" style="max-width: 100.0%;max-height: 100.0%;"/> minutes.

To make the jump beautiful, heavier lemmings should jump from higher ledges: if a lemming of weight *m*<sub class="lower-index">*i*</sub> jumps from ledge *i*, and a lemming of weight *m*<sub class="lower-index">*j*</sub> jumps from ledge *j* (for *i* &lt; *j*), then the inequation *m*<sub class="lower-index">*i*</sub> ≤ *m*<sub class="lower-index">*j*</sub> should be fulfilled.

Since there are *n* lemmings and only *k* ledges (*k* ≤ *n*), the *k* lemmings that will take part in the jump need to be chosen. The chosen lemmings should be distributed on the ledges from 1 to *k*, one lemming per ledge. The lemmings are to be arranged in the order of non-decreasing weight with the increasing height of the ledge. In addition, each lemming should have enough time to get to his ledge, that is, the time of his climb should not exceed *t* minutes. The lemmings climb to their ledges all at the same time and they do not interfere with each other.

Find the way to arrange the lemmings' jump so that time *t* is minimized.
The first line contains space-separated integers *n*, *k* and *h* (1 ≤ *k* ≤ *n* ≤ 10<sup class="upper-index">5</sup>, 1 ≤ *h* ≤ 10<sup class="upper-index">4</sup>) — the total number of lemmings, the number of ledges and the distance between adjacent ledges.

The second line contains *n* space-separated integers *m*<sub class="lower-index">1</sub>, *m*<sub class="lower-index">2</sub>, ..., *m*<sub class="lower-index">*n*</sub> (1 ≤ *m*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">9</sup>), where *m*<sub class="lower-index">*i*</sub> is the weight of *i*-th lemming.

The third line contains *n* space-separated integers *v*<sub class="lower-index">1</sub>, *v*<sub class="lower-index">2</sub>, ..., *v*<sub class="lower-index">*n*</sub> (1 ≤ *v*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">9</sup>), where *v*<sub class="lower-index">*i*</sub> is the speed of *i*-th lemming.
n,m,h = map(int,input().split())
a = []
for i,x in enumerate(zip(map(int,input().split()),map(int,input().split()))):
    a.append((x[0],x[1],i+1))
a.sort(reverse=True)
l,r = 1,1e10
answer = []
while l+1e-6 < r:
    t = (l+r)/2
    p = m
    b = []
    for _,v,i in a:
        if p == 0:
            break
        if p*h <= t*v:
            b.append(i)
            p -= 1
    if p == 0:
        r = t
        answer = b[::-1]
    else:
        l = t
for x in answer:
    print(x,end=' ')