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

#define NDEBUG
#include <cassert>


typedef long long ll;
typedef long double Double;
typedef unsigned long long ull;
typedef pair<int, int> ii;
typedef pair<ll, ll> llll;
typedef pair<double, double> dd;

typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<ii> vii;
typedef vector<vector<ii>> vvii;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef vector<llll> vllll;
typedef vector<bool> vb;
typedef vector<string> vs;
typedef vector<double> vd;
typedef vector<long double> vD;

#define sz(a) int((a).size())
#define pb push_back
#define eb emplace_back
#define FOR(var, from, to) for (int var = (from); var <= (to); ++var)
#define rep(var, n) for (int var = 0; var < (n); ++var)
#define rep1(var, n) for (int var = 1; var <= (n); ++var)
#define repC2(vari, varj, n)                 \
    for (int vari = 0; vari < (n)-1; ++vari) \
        for (int varj = vari + 1; varj < (n); ++varj)
#define repC3(vari, varj, vark, n)                      \
    for (int vari = 0; vari < (n)-2; ++vari)            \
        for (int varj = vari + 1; varj < (n)-1; ++varj) \
            for (int vark = varj + 1; vark < (n); ++vark)
#define ALL(c) (c).begin(), (c).end()
#define RALL(c) (c).rbegin(), (c).rend()
#define tr(i, c) for (auto i = (c).begin(); i != (c).end(); ++i)
#define found(s, e) ((s).find(e) != (s).end())
#define mset(arr, val) memset(arr, val, sizeof(arr))
#define mid(x, y) ((x) + ((y) - (x)) / 2)
#define IN(x, a, b) ((a) <= (x) && (x) <= (b))
#define cons make_pair
#define clamp(v, lo, hi) min(max(v, lo), hi)
#define ABS(x) max((x), -(x))
#define PQ(T) priority_queue<T, vector<T>, greater<T>>

template <typename T1, typename T2>
inline void amin(T1& a, T2 const& b) {
    if (a > b) a = b;
}
template <typename T1, typename T2>
inline void amax(T1& a, T2 const& b) {
    if (a < b) a = b;
}
template <typename X, typename T>
auto vectors(X x, T a) {
    return vector<T>(x, a);
}
template <typename X, typename Y, typename Z, typename... Zs>
auto vectors(X x, Y y, Z z, Zs... zs) {
    auto cont = vectors(y, z, zs...);
    return vector<decltype(cont)>(x, cont);
}

inline ll square(ll x) { return x * x; }
inline ll gcd(ll a, ll b) {
    while (a) swap(a, b %= a);
    return b;
}
inline ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
template <typename T>
inline T mod(T a, T b) {
    return ((a % b) + b) % b;
}

template <typename T>
int find_left(vector<T>& v, T elem) {
    return (int)(upper_bound(v.begin(), v.end(), elem) - v.begin()) - 1;
}
template <typename T>
int find_right(vector<T>& v, T elem) {
    return (int)(lower_bound(v.begin(), v.end(), elem) - v.begin());
}

const ll MOD = 1000000007LL;

inline ll ADD(ll x, ll y) { return (x + y) % MOD; }
inline ll SUB(ll x, ll y) { return (x - y + MOD) % MOD; }
inline ll MUL(ll x, ll y) { return x * y % MOD; }
inline ll POW(ll x, ll e) {
    ll v = 1;
    for (; e; x = MUL(x, x), e >>= 1)
        if (e & 1) v = MUL(v, x);
    return v;
}
inline ll INV(ll y) { /*assert(y%MOD!=0);*/
    return POW(y, MOD - 2);
}
inline ll DIV(ll x, ll y) { return MUL(x, INV(y)); }

#define INTSPACE 12
char _buf[INTSPACE * 1000000 + 3];

int loadint() {
    if (fgets(_buf, INTSPACE + 3, stdin) == NULL) return 0;
    return atoi(_buf);
}

int loadvec(vector<int>& v, int N = -1) {
    if (N == 0) {
        v.clear();
        return 0;
    }
    if (N == -1) {
        N = loadint();
        if (N == 0) return 0;
    }
    int bufsize = INTSPACE * N + 3;
    if (fgets(_buf, bufsize, stdin) == NULL) return 0;
    v.resize(N);

    int i = 0;
    bool last = false;
    for (char* p = &_buf[0];;) {
        char* q = p;
        while (*q > ' ') ++q;
        if (*q == 0x0D || *q == 0x0A) last = true;
        *q = 0;
        v[i++] = atoi(p);
        if (last || i == N) break;
        p = q + 1;
    }
    return i;
}
void read_cr() { fgets(_buf, 256, stdin); }

void horizontal(vector<int>& v) {
    int L = v.size();
    for (int i = 0; i < L; ++i) {
        printf("%d%c", v[i], (i == L - 1) ? '\n' : ' ');
    }
}
void horizontall(vector<long long>& v) {
    int L = v.size();
    for (int i = 0; i < L; ++i) {
        printf("%lld%c", v[i], (i == L - 1) ? '\n' : ' ');
    }
}

vvi factorize_cyclic_permutation(vii& replaces) {
    unordered_map<int, int> mp;
    vvi res;
    for (ii& p : replaces) {
        mp[p.first] = p.second;
    }
    while (!mp.empty()) {
        vi tmp;
        int u = mp.begin()->first;
        while (found(mp, u)) {
            tmp.pb(u);
            int v = mp[u];
            mp.erase(u);
            u = v;
        }
        res.pb(tmp);
    }
    return res;
}

template <typename T1, typename T2>
vector<T2> accum(vector<T1>& a, T2 init) {
    int L = a.size();
    vector<T2> acc(L + 1);
    acc[0] = init;
    for (int i = 0; i < L; ++i) acc[i + 1] = acc[i] + a[i];
    return move(acc);
}

template <typename T>
T accumed(vector<T>& acc, int from, int to) {
    int M = acc.size() - 1;
    return acc[min(M, to)] - acc[max(0, from)];
}
using P = pair<ll, int>;
ll solve(int N, int K, vi& p, vi& c) {
    vii rp(N);
    rep(i, N) rp[i] = ii(i, p[i] - 1);
    vvi fa = factorize_cyclic_permutation(rp);
    ll best = LLONG_MIN;
    int F = fa.size();
    rep(i, F) {
        int L = fa[i].size();
        vi d(L * 2);
        rep(j, L) d[j] = d[L + j] = c[fa[i][j]];
        vll ac = accum(d, 0LL);
        ll cy = accumed(ac, 0, L);

        if (K <= L) {
            PQ(P) pq;
            ll sc = LLONG_MIN;
            for (int x = 0; x < L * 2; ++x) {
                while (!pq.empty() && pq.top().second < x - K) pq.pop();
                if (!pq.empty()) {
                    ll lov = pq.top().first;
                    ll dif = ac[x] - lov;
                    amax(sc, dif);
                }
                pq.emplace(ac[x], x);
            }
            amax(best, sc);
        } else {
            {
                PQ(P) pq;
                ll sc = LLONG_MIN;
                for (int x = 0; x < L * 2; ++x) {
                    while (!pq.empty() && pq.top().second < x - L) pq.pop();
                    if (!pq.empty()) {
                        ll lov = pq.top().first;
                        ll dif = ac[x] - lov;
                        amax(sc, dif);
                    }
                    pq.emplace(ac[x], x);
                }
                amax(best, sc);
            }
            if (cy > 0) {
                int q = K / L, rem = K % L;
                if (q >= 1) {
                    PQ(P) pq;
                    ll sc = LLONG_MIN;
                    for (int x = 0; x < L * 2; ++x) {
                        while (!pq.empty() && pq.top().second < x - L) pq.pop();
                        if (!pq.empty()) {
                            ll lov = pq.top().first;
                            ll dif = ac[x] - lov;
                            amax(sc, cy * (q - 1) + dif);
                        }
                        pq.emplace(ac[x], x);
                    }
                    amax(best, sc);
                }

                PQ(P) pq;
                ll sc = LLONG_MIN;
                for (int x = 0; x < L * 2; ++x) {
                    while (!pq.empty() && pq.top().second < x - rem) pq.pop();
                    if (!pq.empty()) {
                        ll lov = pq.top().first;
                        ll dif = ac[x] - lov;
                        amax(sc, cy * q + dif);
                    }
                    pq.emplace(ac[x], x);
                }
                amax(best, sc);
            }
        }
    }

    return best;
}

int main() {
    int N, K;
    scanf("%d %d%*c", &N, &K);
    vi p(N), c(N);
    loadvec(p, N);
    loadvec(c, N);
    cout << solve(N, K, p, c) << endl;
    return 0;
}


Measured memory_bytes: 4268