100 1
1000000 100 1000
 5 3
1 4 10
2 2 5
3 1 6
 10 4
1 5 20
2 5 200
100 6 20
101 1 100
 5 3
1 3 4
4 3 4
6 4 1
 4 1
6 1 1
 8 6
1 3 20
4 2 1
6 6 5
9 1 1
15 3 6
21 8 8
 4 5
1 2 3
2 1 3
3 1 2
4 3 3
5 4 1
 8 4
1 3 2
2 3 100
10 6 20
11 5 20
 4 10
1 1 1
3 1 2
4 1 2
6 1 2
8 1 2
13 1 2
16 1 1
17 1 2
19 3 1
20 1 1
 5 3
1 4 4
4 2 2
5 5 2
 4 3
1 3 10
2 2 15
12 4 1
 5 4
1 1 4
2 4 4
5 2 20
11 5 2
 1 10
4 1 1
9 1 1
10 1 1
12 1 1
13 1 1
15 1 1
16 1 1
18 1 1
19 1 1
20 1 1

5050
 10
-1
5
 15
40
-1
1
 6
-1
10
 1
 6
9
-1
4
15
36
 3
3
4
-1
10
 6
15
-1
21
 1
1
2
1
1
1
1
1
6
1
 10
-1
15
 6
-1
10
 1
14
-1
15
 1
1
1
1
1
1
1
1
1
1

import java.util.Comparator;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Scanner;

public class Solution {
    class ListNode {
        int val;
        ListNode next;

        ListNode(int val) {
            this.val = val;
        }
    }

    class LinkedListC {
        ListNode root;
        ListNode end;
        int size = 0;

        void add(int val) {
            ListNode toInsert = new ListNode(val);
            if (size == 0) {
                this.root = toInsert;
                this.end = this.root;
            } else {
                this.end.next = toInsert;
                this.end = this.end.next;
            }
            size++;
        }

        int poll() {
            int val = root.val;
            this.root = this.root.next;
            size--;
            return val;
        }

        int size() {
            return this.size;
        }

        void merge(LinkedListC other) {
            ListNode head, tail;
            head = new ListNode(Integer.MIN_VALUE);
            tail = head;
            ListNode l1 = root;
            ListNode l2 = other.root;
            while (l1 != null && l2 != null) {
                if (l1.val < l2.val) {
                    tail.next = l1;
                    tail = tail.next;
                    l1 = l1.next;
                } else {
                    tail.next = l2;
                    tail = tail.next;
                    l2 = l2.next;
                }
            }
            if (l1 != null) {
                tail.next = l1;
            } else {
                tail.next = l2;
            }
            this.root = head.next;
            this.size += other.size;
        }

        public String toString() {
            ListNode root = this.root;
            StringBuilder sb = new StringBuilder();
            while (root != null) {
                sb.append(root.val);
                sb.append(", ");
                root = root.next;
            }
            return sb.toString();
        }
    }

    class Event {
        int startTime;
        LinkedListC content;

        Event(int startTime, LinkedListC content) {
            this.startTime = startTime;
            this.content = content;
        }

        void simulate() {
            //System.out.println(content);
            server.merge(content);
            //System.out.println("Merging");
            //System.out.println(server);
        }
    }

    private LinkedListC server;
    private PriorityQueue<Event> events;

    Solution(int server) {
        this.server = new LinkedListC();
        this.events = new PriorityQueue<>(Comparator.comparingInt(a -> a.startTime));
        for (int i = 1; i <= server; i++) {
            this.server.add(i);
        }
        //System.out.println(this.server);
    }

    private int schedule(int startTime, int serverCount, int duration) {
        //System.out.println(this.server);
        while (events.size() > 0 && events.peek().startTime <= startTime) {
            events.poll().simulate();
        }
        //System.out.println(this.server);
        if (serverCount <= server.size()) {
            int idSum = 0;
            LinkedListC serverUsed = new LinkedListC();
            for (int i = 0; i < serverCount; i++) {
                int server = this.server.poll();
                idSum += server;
                serverUsed.add(server);
            }
            events.add(new Event(startTime + duration, serverUsed));
            return idSum;
        } else {
            return -1;
        }
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int server = in.nextInt();
        int caseSize = in.nextInt();
        Solution s = new Solution(server);
        for (int i = 0; i < caseSize; i++) {
            int startTime = in.nextInt();
            int serverCount = in.nextInt();
            int duration = in.nextInt();
            System.out.println(s.schedule(startTime, serverCount, duration));
        }
    }
}