import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.Map; import java.util.Scanner;

public class Solution {

private static Map<Integer, ArrayList<Track>> tracksPerRow = new HashMap<Integer, ArrayList<Track>>();

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int numberOfRows = scanner.nextInt();
    int numberOfColumns = scanner.nextInt();
    int numberOfTracks = scanner.nextInt();

    for (int i = 0; i < numberOfTracks; i++) {
        int row = scanner.nextInt();
        int startColumn = scanner.nextInt();
        int endColumn = scanner.nextInt();
        fillMap(row, startColumn, endColumn);
    }
    scanner.close();

    sortTracksInsideRows_decreasingOrderOfStartColumn();
    long totalCellsWithTracks__exludingOverlaps = getTotalCellsWithTracks_exludingOverlaps();

    long spotsForLampPosts = (long) numberOfRows * numberOfColumns - (long) totalCellsWithTracks__exludingOverlaps;
    System.out.println(spotsForLampPosts);
}

private static void fillMap(int row, int start, int end) {
    Track track = new Track(start, end);

    if (!tracksPerRow.containsKey(row)) {
        ArrayList<Track> tracks = new ArrayList<Track>();
        tracks.add(track);
        tracksPerRow.put(row, tracks);
    } else {
        tracksPerRow.get(row).add(track);
    }
}

private static void sortTracksInsideRows_decreasingOrderOfStartColumn() {
    for (int row : tracksPerRow.keySet()) {
        Collections.sort(tracksPerRow.get(row));
    }
}

private static long getTotalCellsWithTracks_exludingOverlaps() {

    long totalCellsWithTracks__exludingOverlaps = 0;

    for (int row : tracksPerRow.keySet()) {

        int index = 0;

        ArrayList<Track> tracks = tracksPerRow.get(row);

        for (int i = 0; i < tracks.size(); i++) {

            if (index != 0 && tracks.get(index - 1).startColumn <= tracks.get(i).endColumn) {
                while (index != 0 && tracks.get(index - 1).startColumn <= tracks.get(i).endColumn) {

                    int minStart = Math.min(tracks.get(index - 1).startColumn, tracks.get(i).startColumn);
                    int maxEnd = Math.max(tracks.get(index - 1).endColumn, tracks.get(i).endColumn);

                    tracks.get(index - 1).startColumn = minStart;
                    tracks.get(index - 1).endColumn = maxEnd;
                    index--;
                }
            }
            else {
                tracks.set(index, tracks.get(i));
            }
            index++;
        }

        for (int j = 0; j < index; j++) {
            totalCellsWithTracks__exludingOverlaps += (long) tracks.get(j).endColumn
                    - (long) tracks.get(j).startColumn + 1;
        }
    }
    return totalCellsWithTracks__exludingOverlaps;
}

private static class Track implements Comparable<Track> {

    int startColumn;
    int endColumn;

    public Track(int startColumn, int endColumn) {
        this.startColumn = startColumn;
        this.endColumn = endColumn;
    }

    @Override
    public int compareTo(Track arg0) {
        return arg0.startColumn - this.startColumn;
    }
}

}