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

using i64=int64_t;

#define rep(i,x,y) for(i64 i=i64(x),i##_max_for_repmacro=i64(y); i<i##_max_for_repmacro; ++i)
#define debug(x) #x << "=" << (x)
 
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define print(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define print(x)
#endif
 
const int inf=1.01e9;
const i64 inf64=4.01e18;
const double eps=1e-9;
 
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec){
    os << "[";
    for (const auto &v : vec) {
        os << v << ",";
    }
    os << "]";
    return os;
}

template <class flow_type, class cost_type>
struct min_cost_flow {
    struct edge {
        int to, from, rev;
        flow_type cap;
        cost_type cost;
        edge(int to, int from, int rev, flow_type cap, cost_type cost) : to(to), from(from), rev(rev), cap(cap), cost(cost) {}
    };
    const int size = 0;
    vector<vector<edge>> graph;
    min_cost_flow(int size_) : size(size_), graph(size_) {}
    void add_edge(int from, int to, flow_type cap, cost_type cost) {
        graph[from].push_back(edge(to, from, int(graph[to].size()), cap, cost));
        graph[to].push_back(edge(from, to, int(graph[from].size() - 1), 0, -cost));
    }
    cost_type min_path(int s, int t) {
        const cost_type inf = numeric_limits<cost_type>::max();
        vector<cost_type> dist(size, inf);
        vector<edge *> route(size);
        queue<int> que;
        vector<bool> inq(size);
        dist[s] = 0;
        que.push(s);
        inq[s] = true;
        while (!que.empty()) {
            int u = que.front();
            que.pop();
            inq[u] = false;
            for (edge &e : graph[u]) {
                if (e.cap == 0) continue;
                int v = e.to;
                if (dist[v] > dist[u] + e.cost) {
                     dist[v] = dist[u] + e.cost;
                    route[v] = &e;
                    if (!inq[v]) {
                        que.push(v);
                        inq[v] = true;
                    }
                }
            }
        }

        if (dist[t] == inf) return inf;
        flow_type flow = numeric_limits<flow_type>::max();
        {
            int v = t;
            while (v != s) {
                edge &e = *route[v];
                //e.cap-=1;
                //graph[e.to][e.rev].cap+=1;
                //c+=e.cost;
                flow = min(flow, e.cap);
                v = e.from;
            }
        }
        cost_type c = 0;
        {
            int v = t;
            while (v != s) {
                edge &e = *route[v];
                e.cap -= flow;
                graph[e.to][e.rev].cap += flow;
                c += e.cost * flow;
                v = e.from;
            }
        }
        return dist[t];
    }
    //流せない場合はnumeric_limits<cost_type>::max()を返すことに注意
    cost_type calc_min_cost_flow(int s, int t, flow_type flow) {
        cost_type total_cost = 0;
        for (flow_type i = 0; i < flow; ++i) {
            cost_type c = min_path(s, t);
            if (c == numeric_limits<cost_type>::max()) return c;
            total_cost += c;
        }
        return total_cost;
    }
};

void solve(){
    i64 N;
    cin >> N;

    vector<i64> A(N),B(N),hs;
    rep(i,0,N){
        cin >> A[i] >> B[i];
        hs.push_back(A[i]);
        hs.push_back(B[i]);
    }

    sort(begin(hs),end(hs));
    hs.erase(unique(begin(hs),end(hs)),end(hs));

    map<i64,i64> htoi;
    rep(i,0,hs.size()) htoi[hs[i]]=i;

    min_cost_flow<i64, i64> mcf(N+hs.size()+3);
    const i64 s=N+hs.size(),t=N+hs.size()+1,unused=N+hs.size()+2;
    rep(i,0,N){
        mcf.add_edge(s,i,1,0);
    }
    rep(i,0,N){;
        mcf.add_edge(i,unused,1,0);
        mcf.add_edge(i,N+htoi[A[i]],1,-B[i]);
        mcf.add_edge(i,N+htoi[B[i]],1,-A[i]);
    }
    mcf.add_edge(unused,t,inf64,0);
    rep(i,0,hs.size()){
        mcf.add_edge(N+i,t,1,0);
    }

    cout << -mcf.calc_min_cost_flow(s,t,N) << endl;
}

int main(){
    std::cin.tie(0);
    std::ios::sync_with_stdio(false);
    cout.setf(ios::fixed);
    cout.precision(16);
    solve();
    return 0;
}

