#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define SIZE 1000001
#define clear(x) memset(x,0,sizeof(x));

struct node{
    int fa,val,g;
    bool ring;
};

node f[SIZE];
vector<int> son[SIZE];
ll dp[SIZE][2],res[SIZE];
ll dp0[SIZE],dp1[SIZE];
ll n,tot,ans;
stack<int> s;
bool vis[SIZE],v[SIZE];

void ring_get(int x){
    v[x]=true;
    if(vis[x]){
        tot++;
        f[x].ring=true;
        f[x].g=tot;
        while(s.top()!=x){
            int y=s.top();
            f[y].ring=true;
            f[y].g=tot;
            s.pop();
        }
        clear(vis);
        while(!s.empty()) 
        s.pop();
        return;
    }
    s.push(x);
    vis[x]=true;
    ring_get(f[x].fa);
}
void dfs1(int x){
    dp[x][1]=f[x].val;
    int add=0;
    for(int i=0;i<son[x].size();i++){
        int y=son[x][i];
        if(f[y].ring) continue;
        dfs1(y);
        dp[x][1]+=dp[y][0];
        dp[x][0]+=max(dp[y][0],dp[y][1]);
    }
}
void dfs2(int x,int lim,bool s){
    if(x==lim){
        dp1[x]=dp[x][s];
        dp0[x]=dp[x][0];
        return;
    }
    int y=f[x].fa;
    dfs2(y,lim,s);
    dp1[x]=dp[x][1]+dp0[y];
    dp0[x]=dp[x][0]+max(dp0[y],dp1[y]);
    dp0[y]=0;
    dp1[y]=0;
}

void init(){
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>f[i].val>>f[i].fa;
        son[f[i].fa].push_back(i);
    }
    for(int i=1;i<=n;i++)
    if(!v[i])
    ring_get(i);    
}
void solve(){
    for(int i=1;i<=n;i++)
    if(f[i].ring)
    dfs1(i);

    for(int y=1;y<=n;y++)
    if(f[y].ring){
        int x=f[y].fa;

        dfs2(x,y,1);
        res[f[x].g]=max(res[f[x].g],dp0[x]);
        dp0[x]=0;dp1[x]=0;

        dfs2(x,y,0);
        res[f[x].g]=max(res[f[x].g],max(dp0[x],dp1[x]));
        dp0[x]=0;dp1[x]=0;
    }    
}
void print(){
    for(int i=1;i<=tot;i++)
    ans+=res[i];
    cout<<ans;    
}

int main(){
    init();
    solve();
    print();
    return 0;
}