// #pragma GCC target("avx")
// #pragma GCC optimize("O3")
// #pragma GCC optimize("unroll-loops")

#include <bits/stdc++.h>
using namespace std;

#define rep(i,n) for(int i = 0; i < (int)n; i++)
#define FOR(n) for(int i = 0; i < (int)n; i++)
#define repi(i,a,b) for(int i = (int)a; i < (int)b; i++)
#define all(x) x.begin(),x.end()
//#define mp make_pair
#define vi vector<int>
#define vvi vector<vi>
#define vvvi vector<vvi>
#define vvvvi vector<vvvi>
#define pii pair<int,int>
#define vpii vector<pair<int,int>>

template<typename T>
void chmax(T &a, const T &b) {a = (a > b? a : b);}
template<typename T>
void chmin(T &a, const T &b) {a = (a < b? a : b);}

using ll = long long;
using ld = long double;
using ull = unsigned long long;

const ll INF = numeric_limits<long long>::max() / 2;
const ld pi = 3.1415926535897932384626433832795028;
const ll mod = 998244353;
int dx[] = {1, 0, -1, 0, -1, -1, 1, 1};
int dy[] = {0, 1, 0, -1, -1, 1, -1, 1};

#define int long long

struct fraction {

    long long x, y;

    fraction() : x(0), y(1) {}
    fraction(long long x) : x(x), y(1) {}
    fraction(long long a, long long b) {
        long long divisor = __gcd(a, b);
        x = a / divisor;
        y = b / divisor;
    }

    long double get() const {
        return (long double)x / (long double)y;
    }


    fraction operator+(const fraction &other) const {
        long long divisor = __gcd(x * other.y + y * other.x, y * other.y);
        return {(x * other.y + y * other.x) / divisor, y * other.y / divisor};
    }
    fraction operator-(const fraction &other) const {
        long long divisor = __gcd(x * other.y - y * other.x, y * other.y);
        return {(x * other.y - y * other.x) / divisor, y * other.y / divisor};
    }
    fraction operator*(const fraction &other) const {
        long long ret_x = x * other.x;
        long long ret_y = y * other.y;
        long long divisor = __gcd(ret_x, ret_y);
        return {ret_x / divisor, ret_y / divisor};
    }
    fraction operator/(const fraction &other) const {
        long long ret_x = x * other.y;
        long long ret_y = y * other.x;
        long long divisor = __gcd(ret_x, ret_y);
        return {ret_x / divisor, ret_y / divisor};
    }

    fraction& operator+=(const fraction &other) {
        *this = *this + other;
        return *this;
    }
    fraction& operator-=(const fraction &other) {
        *this = *this - other;
        return *this;
    }
    fraction& operator*=(const fraction &other) {
        *this = *this * other;
        return *this;
    }
    fraction& operator/=(const fraction &other) {
        *this = *this / other;
        return *this;
    }

    bool operator==(const fraction &other) const {
        return x == other.x && y == other.y;
    }
    bool operator!=(const fraction &other) const {
        return x != other.x || y != other.y;
    }
    bool operator<(const fraction &other) const {
        if(y * other.y > 0) return x * other.y < y * other.x;
        return x * other.y > y * other.x;
    }
    bool operator>(const fraction &other) const {
        if(y * other.y > 0) return x * other.y > y * other.x;
        return x * other.y < y * other.x;
    }
    bool operator<=(const fraction &other) const {
        if(y * other.y > 0) return x * other.y <= y * other.x;
        return x * other.y >= y * other.x;
    }
    bool operator>=(const fraction &other) const {
        if(y * other.y > 0) return x * other.y >= y * other.x;
        return x * other.y <= y * other.x;
    }
    fraction operator+(const long long &other) const {return (*this) + fraction(other);}
    fraction operator-(const long long &other) const {return (*this) - fraction(other);}
    fraction operator*(const long long &other) const {return (*this) * fraction(other);}
    fraction operator/(const long long &other) const {return (*this) / fraction(other);}
    fraction operator+=(const long long &other) {(*this) += fraction(other); return *this;}
    fraction operator-=(const long long &other) {(*this) -= fraction(other); return *this;}
    fraction operator*=(const long long &other) {(*this) *= fraction(other); return *this;}
    fraction operator/=(const long long &other) {(*this) /= fraction(other); return *this;}
    bool operator==(const long long &other) const {return (*this) == fraction(other);}
    bool operator!=(const long long &other) const {return (*this) != fraction(other);}
    bool operator<(const long long &other) const {return (*this) < fraction(other);}
    bool operator>(const long long &other) const {return (*this) > fraction(other);}
    bool operator<=(const long long &other) const {return (*this) <= fraction(other);}
    bool operator>=(const long long &other) const {return (*this) >= fraction(other);}

    fraction operator-() const {return fraction(0)-(*this);}

    void print() {
        cout << x << "/" << y << endl;
    }
};
//負の数に注意!!

void solve() {
    using P = tuple<fraction, int, int>;
    int n, m;
    cin >> n >> m;
    vi a(n), b(m);
    FOR(n) cin >> a[i];
    FOR(m) cin >> b[i];

    priority_queue<P, vector<P>, greater<P>> pq;
    FOR(n) pq.push({-fraction(a[i], b[0]), i, 0});

    FOR(m) {
        P p = pq.top();
        pq.pop();
        cout << get<1>(p)+1 << endl;
        pq.emplace(-fraction(a[get<1>(p)], b[get<2>(p)+1]), get<1>(p), get<2>(p)+1);
    }
}

signed main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    solve();
    return 0;
}