#include <iostream>
#include <algorithm>
using namespace std;


int main()
{
    int n; cin >> n;
    double sum = 0;
    long  r, u,max;
    
    long **Arr=new long*[2];
    for ( int count = 0; count < 2; count++) {
        Arr[count] = new long[n];
    }
    for (int i = 0; i < n; i++) {
        do {  cin >> r >> u;} while (r < 0 && u < 0);
        Arr[0][i] = r;
        Arr[1][i] = u;
    }
    for (int startIndex = 0; startIndex < n - 1; ++startIndex)
    {
        int smallestIndex = startIndex;
        for (int currentIndex = startIndex + 1; currentIndex < n; ++currentIndex)
        {
            if (Arr[0][currentIndex] < Arr[0][smallestIndex])
            smallestIndex = currentIndex;
        }
        swap(Arr[0][startIndex], Arr[0][smallestIndex]);
        swap(Arr[1][startIndex], Arr[1][smallestIndex]);
    }
    
    sum = sum + Arr[1][0];

    for (int i = 0; i < n; i++) {
        if (Arr[0][i] < Arr[0][i + 1])sum = sum + Arr[1][i];
        else if (Arr[0][i] == Arr[0][i + 1]) {
            if (Arr[1][i] < Arr[1][i + 1])sum = sum + Arr[1][i + 1]; 
            else sum = sum + Arr[1][i];
            i++;
        }
    }
    cout << sum;
    delete [] Arr[n];
    return 0;
}

import java.util.*;

public class Main {

    public static void main(String[] args) {
        List<Cake> cakes = new ArrayList<>();
        getData(cakes);
        System.out.println(resultedVolume(cakes));
    }
    private static void getData(List<Cake> cakes) {
        Scanner in = new Scanner(System.in);
        int amount = in.nextInt();

        for (int i = 0; i < amount; i++) {
            Cake cake = new Cake();
            cake.radius = in.nextInt();
            cakes.add(cake);
        }
        for (Cake cake : cakes) {
            cake.volume = in.nextInt();
        }
        in.close();
    }
    private static long resultedVolume(List<Cake> cakes) {
        Collections.sort(cakes);
        Cake cake_0 = cakes.get(0);
        long previousRadius = cake_0.radius, previousVolume = cake_0.volume, previousVolumeSum = cake_0.volume;
        for (int i = 1; i < cakes.size(); i++) {
            Cake cake_i = cakes.get(i);
            if (previousRadius == cake_i.radius) {
                if (cake_i.volume > previousVolume) {
                    previousVolumeSum -= previousVolume;
                    previousVolumeSum += cake_i.volume;
                    previousRadius = cake_i.radius;
                    previousVolume = cake_i.volume;
                } else {
                    continue;
                }
            } else {
                previousVolumeSum += cake_i.volume;
                previousRadius = cake_i.radius;
                previousVolume = cake_i.volume;
            }
        }
        return previousVolumeSum;
    }
}
class Cake implements Comparable<Cake>{
    long radius, volume;

    @Override
    public int compareTo(Cake o) {
        return Long.compare(o.radius, radius);
    }
}