#include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>
#include <utility>
#include <cmath>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <tuple>
#include <numeric>
#include <functional>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef pair<ll, ll> P;
#define rep(i, n) for(ll i = 0; i < n; i++)
#define exrep(i, a, b) for(ll i = a; i <= b; i++)
#define out(x) cout << x << endl
#define exout(x) printf("%.10f\n", x)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
#define re0 return 0
const ll mod = 1000000007;
const ll INF = 1e16;
 
struct Edge {
    ll to, cost;
    Edge(ll to, ll cost): to(to), cost(cost) {}
};
 
vector<vector<Edge>> G;
vl visited;
vl finished;
vl hist;
 
ll pos = -1;  // サイクルに含まれる頂点pos(-1のときサイクルを含まない)
 
void dfs(ll v) {
    visited[v] = 1;
    hist.pb(v);
    for(Edge e : G[v]) {
        ll u = e.to;
        if(finished[u]) {
            continue;
        }
        // サイクルを検出
        if(visited[u] && !finished[u]) {
            pos = u;
            return;
        }
        dfs(u);
        if(pos != -1) {
            return;
        }
    }
    hist.pop_back();
    finished[v] = 1;
}
 
int main() {
    ll n, k;
    cin >> n >> k;  
 
    vl p(n);
    rep(i, n) {
        cin >> p[i];
        p[i]--;
    }  
    vl c(n);
    rep(i, n) {
        cin >> c[i];
    }  
    
    G.resize(n);
    rep(i, n) {
        G[i].emplace_back(p[i], c[p[i]]);
    }
 
    ll ans = -INF;
    rep(sv, n) {
 
        visited.assign(n, 0);
        finished.assign(n, 0); 
        pos = -1;
        dfs(sv);
 
        // サイクルを復元 
        vl cycle;
        while(!hist.empty()) {
            ll t = hist.back();
            cycle.pb(t);
            hist.pop_back();
            if(t == pos) {
                break;
            }
        }
        reverse(all(cycle));
        
        ll L = cycle.size();  // サイクルの長さ
 
        if(k < L) {  // そもそも1周できないとき
            ll x1 = 0;  // いまのスコア
            ll y1 = -INF;  // k回以下の移動で得られるスコアの最大値
            ll now = sv;
            rep(i, k) {
                x1 += G[now][0].cost;
                chmax(y1, x1);
                now = G[now][0].to;
            }
            chmax(ans, y1);
            continue;
        }
 
        // 以下、サイクルを1周以上できる
        ll x2 = 0;  // いまのスコア
        ll y2 = -INF;  // 1周以下の移動で得られるスコアの最大値
        ll now = sv;
        rep(i, L) {
            x2 += G[now][0].cost;
            chmax(y2, x2);
            now = G[now][0].to;
        }
        chmax(ans, y2);
 
        // x2の値はサイクルを1周したときのスコアになっている
        if(0 < x2) {  // サイクルを1周するとスコアが増えるなら、回れるだけ回った方がスコアが増えることもある
            if(k%L == 0) {
                chmax(ans, (k/L - 1)*x2 + y2);
            }
            else {
                ll x3 = 0;  // いまのスコア
                ll y3 = 0;  // 残りの移動で得られるスコアの最大値(1周以上しているからもう移動しなくてもよいので0以上)
                now = sv;
                rep(i, k%L) {
                    x3 += G[now][0].cost;
                    chmax(y3, x3);
                    now = G[now][0].to;
                }
                chmax(ans, (k/L)*x2 + y3);
            }
        }
    }
    
    out(ans);
    re0;
}

Measured memory_bytes: 4412