#include <bits/stdc++.h>
#define long long long int
#define DEBUG
using namespace std;

// @author: pashka

int mod = 1000000007;

struct mint {
    int value = 0;

    constexpr mint() : value() {}

    mint(const long &x) {
        value = normalize(x);
    }

    static long normalize(const long &x) {
        long v = x % mod;
        if (v < 0) v += mod;
        return v;
    }

    bool operator==(const mint &x) { return value == x.value; };

    mint operator+(const mint &x) { return value + x.value; };

    mint operator-(const mint &x) { return value - x.value; };

    mint operator*(const mint &x) { return (long) value * x.value; };

    void operator+=(const mint &x) { value = normalize(value + x.value); };

    void operator-=(const mint &x) { value = normalize(value - x.value); };
};

mint power(mint a, long b) {
    mint res = 1;
    while (b > 0) {
        if (b & 1) {
            res = res * a;
        }
        a = a * a;
        b >>= 1;
    }
    return res;
}

mint inv(mint a) {
    return power(a, mod - 2);
}

vector<mint> fact_precalc(1, 1);
vector<mint> inv_fact_precalc(1, 1);

void precalc(int n) {
    fact_precalc.resize(n + 1);
    fact_precalc[0] = 1;
    for (int i = 1; i < fact_precalc.size(); i++) {
        fact_precalc[i] = fact_precalc[i - 1] * i;
    }
    inv_fact_precalc.resize(n + 1);
    inv_fact_precalc[n] = inv(fact_precalc[n]);
    for (int i = n - 1; i >= 0; i--) {
        inv_fact_precalc[i] = inv_fact_precalc[i + 1] * (i + 1);
    }
}

void ensure_fact(int n) {
    while (n >= fact_precalc.size()) {
        fact_precalc.push_back(fact_precalc.back() * fact_precalc.size());
        inv_fact_precalc.push_back(inv(fact_precalc.back()));
    }
}

mint fact(int n) {
    ensure_fact(n);
    return fact_precalc[n];
}

mint inv_fact(int n) {
    ensure_fact(n);
    return inv_fact_precalc[n];
}

mint calc_c(int n, int k) {
    if (n < 0 || k < 0 || k > n) {
        return 0;
    }
    mint res = fact(n);
    res = res * inv_fact(k);
    res = res * inv_fact(n - k);
    return res;
}

mint calc_a(int n, int k) {
    if (n < 0 || k < 0 || k > n) {
        return 0;
    }
    mint res = fact(n);
    res = res * inv_fact(n - k);
    return res;
}


struct segtree_max {
    typedef pair<long, int> item;

    item zeroSum = {LLONG_MIN, -1};

    item sum(item a, item b) {
        return max(a, b);
    }

    vector<item> sums;

    int size;

    void set(int i, item x, int n, int L, int R) {
        if (R == L + 1) {
            sums[n] = x;
            return;
        }
        int M = (L + R) >> 1;
        if (i < M) {
            set(i, x, 2 * n + 1, L, M);
        } else {
            set(i, x, 2 * n + 2, M, R);
        }
        sums[n] = sum(sums[2 * n + 1], sums[2 * n + 2]);
    }

    item calc(int l, int r, int n, int L, int R) {
        if (l >= R || L >= r) return zeroSum;
        if (L >= l && R <= r) {
            return sums[n];
        }
        int M = (L + R) >> 1;
        return sum(calc(l, r, 2 * n + 1, L, M),
                   calc(l, r, 2 * n + 2, M, R));
    }

    explicit segtree_max(int n) {
        size = 1;
        while (size < n) size *= 2;
        sums.assign(2 * size, zeroSum);
    }

    explicit segtree_max(vector<item> a): segtree_max(a.size()) {
        int n = a.size();
        for (int i = 0; i < n; i++) {
            sums[size - 1 + i] = a[i];
        }
        for (int i = size - 2; i >= 0; i--) {
            sums[i] = sum(sums[2 * i + 1], sums[2 * i + 2]);
        }
    }

    void set(int i, item x) {
        set(i, x, 0, 0, size);
    }

    item calc(int l, int r) {
        return calc(l, r, 0, 0, size);
    }
};

struct fenwick {
    vector<long> f;


    fenwick(int n) {
        f.assign(n + 1, 0);
    }

    long sum(int r) { // exclusive
        r--;
        long result = 0;
        for (; r >= 0; r = (r & (r + 1)) - 1)
            result += f[r];
        return result;
    }

    void inc(int i, long x) {
        for (; i < f.size(); i = (i | (i + 1)))
            f[i] += x;
    }
};

int W;
vector<int> ans;
set<int> av;
vector<int> p;

mint go(int l, int r, segtree_max &mx, segtree_max &mn, fenwick &f) {
    int n = f.sum(r) - f.sum(l);
    if (n == 0) return 1;
    auto [a, b] = mx.calc(l, r);
    mx.set(b, mn.zeroSum);
    mn.set(b, mn.zeroSum);
    f.inc(b, -1);
    vector<int> q;
    while (true) {
        auto [c, d] = mn.calc(l, r);
        if (c == mn.zeroSum.first) break;
        if (-c + a > W) break;
        q.push_back(p[d]);
        av.insert(p[d]);
        mn.set(d, mn.zeroSum);
        mx.set(d, mn.zeroSum);
        f.inc(d, -1);
    }
    sort(q.begin(), q.end());
    mint res = go(l, b, mx, mn, f);
    int xx = p[b];
    while (!av.empty() && *av.begin() < xx) {
        ans.push_back(*av.begin());
        av.erase(av.begin());
    }
    ans.push_back(xx);
    res = res * go(b + 1, r, mx, mn, f);
    for (int t : q) {
        if (av.find(t) != av.end()) {
            av.erase(t);
            ans.push_back(t);
        }
    }
    res = res * calc_a(n, q.size());
    return res;
}

int main() {
    ios::sync_with_stdio(false);

    int n;
    cin >> n >> W;
    p.resize(n);
    for (int i = 0; i < n; i++) {
        cin >> p[i];
        p[i]--;
    }
    vector<long> a(n);
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }

    reverse(p.begin(), p.end());

    segtree_max mx(n);
    segtree_max mn(n);
    for (int i = 0; i < n; i++) {
        mx.set(i, {a[p[i]], i});
        mn.set(i, {-a[p[i]], i});
    }
    fenwick f(n);
    for (int i = 0; i < n; i++) {
        f.inc(i, 1);
    }

    auto r = go(0, n, mx, mn, f);
    cout << r.value << "\n";
    for (int x : ans) cout << x + 1 << " ";
    cout << "\n";

    return 0;
}