#include <iostream>
#include <vector>
#include <algorithm>
#include <map>

using namespace std;

vector<pair<int, int>> mergeSegments(int n, vector<pair<int, int>>& pairs) {
    map<int, int> segmentScores;
    
    for (const auto& p : pairs) {
        int segmentId = p.first;
        int score = p.second;
        segmentScores[segmentId] += score;
    }
    
    vector<pair<int, int>> result;
    for (const auto& entry : segmentScores) {
        result.push_back({entry.first, entry.second});
    }
    
    return result;
}

int main() {
    int n;
    cin >> n;
    
    vector<pair<int, int>> pairs(n);
    for (int i = 0; i < n; i++) {
        cin >> pairs[i].first >> pairs[i].second;
    }
    
    vector<pair<int, int>> result = mergeSegments(n, pairs);
    
    for (const auto& p : result) {
        cout << p.first << " " << p.second << endl;
    }
    
    return 0;
}

import java.util.*;

public class Main {
    /**
     * Merges segments of student performance.
     * 
     * @param n The number of performance entries.
     * @param pairs A 2D array of pairs {segmentId, score}.
     * @return A 2D array of merged segments {{segmentId, totalScore}, ...} sorted by segmentId.
     */
    public static int[][] mergeSegments(int n, int[][] pairs) {
        Map<Integer, Integer> segmentScores = new TreeMap<>();
        
        for (int[] pair : pairs) {
            int segmentId = pair[0];
            int score = pair[1];
            segmentScores.put(segmentId, segmentScores.getOrDefault(segmentId, 0) + score);
        }
        
        int[][] result = new int[segmentScores.size()][2];
        int index = 0;
        for (Map.Entry<Integer, Integer> entry : segmentScores.entrySet()) {
            result[index][0] = entry.getKey();
            result[index][1] = entry.getValue();
            index++;
        }
        
        return result;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        int n = scanner.nextInt();
        int[][] pairs = new int[n][2];
        
        for (int i = 0; i < n; i++) {
            pairs[i][0] = scanner.nextInt();
            pairs[i][1] = scanner.nextInt();
        }
        
        int[][] result = mergeSegments(n, pairs);
        
        for (int[] pair : result) {
            System.out.println(pair[0] + " " + pair[1]);
        }
        
        scanner.close();
    }
}

def merge_segments(n, pairs):
    """
    Merges segments of student performance.
    
    Args:
        n (int): The number of performance entries.
        pairs (list of list of int): A list of pairs [segmentId, score].
    
    Returns:
        list of list of int: A list of merged segments [[segmentId, totalScore], ...] sorted by segmentId.
    """
    segment_scores = {}
    
    for segment_id, score in pairs:
        if segment_id in segment_scores:
            segment_scores[segment_id] += score
        else:
            segment_scores[segment_id] = score
    
    result = []
    for segment_id in sorted(segment_scores.keys()):
        result.append([segment_id, segment_scores[segment_id]])
    
    return result

if __name__ == "__main__":
    import sys
    input = sys.stdin.read
    data = input().split()
    
    if not data:
        sys.exit(0)
    
    n = int(data[0])
    pairs = []
    index = 1
    for _ in range(n):
        segment_id = int(data[index])
        score = int(data[index + 1])
        pairs.append([segment_id, score])
        index += 2
    
    result = merge_segments(n, pairs)
    
    for seg in result:
        print(f"{seg[0]} {seg[1]}")

/**
 * @param {number} n - The number of performance entries.
 * @param {number[][]} pairs - An array of pairs [segmentId, score].
 * @return {number[][]} - An array of merged segments [[segmentId, totalScore], ...] sorted by segmentId.
 */
function mergeSegments(n, pairs) {
    const segmentScores = new Map();
    
    for (const [segmentId, score] of pairs) {
        segmentScores.set(segmentId, (segmentScores.get(segmentId) || 0) + score);
    }
    
    const result = [];
    for (const [segmentId, totalScore] of segmentScores.entries()) {
        result.push([segmentId, totalScore]);
    }
    
    result.sort((a, b) => a[0] - b[0]);
    
    return result;
}

// Driver code for local testing
const readline = require('readline');
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

rl.question('Enter n: ', (nStr) => {
    const n = parseInt(nStr);
    let pairs = [];
    let count = 0;
    
    const readPair = () => {
        if (count === n) {
            const result = mergeSegments(n, pairs);
            console.log(JSON.stringify(result));
            rl.close();
            return;
        }
        rl.question(`Enter pair ${count + 1} (id score): `, (line) => {
            const [id, score] = line.split(' ').map(Number);
            pairs.push([id, score]);
            count++;
            readPair();
        });
    };
    
    readPair();
});