#include <stdio.h>
#include <stdlib.h>
#include <mem.h>

//#define DEBUG TRUE

#ifdef DEBUG
#define INPUT_FILE "C:\\Users\\Maksim Ignatyev\\CLionProjects\\AaDS\\taskC\\input.txt"
#define OUTPUT_FILE "C:\\Users\\Maksim Ignatyev\\CLionProjects\\AaDS\\taskC\\output.txt"
#else
#define INPUT_FILE "input.txt"
#define OUTPUT_FILE "output.txt"
#endif

typedef struct{
    int balls;
    int num;
    int time;
} t_member;

int member_comparator(t_member*, t_member*);

void heap_push(t_member);
void heap_sift_up(int);
void heap_sift_down(int);
t_member heap_extract_max();

int heap_size = 0;

t_member heap[100000];
int helper[100000];

const t_member null_member = {-1, -1, -1};

int main(){

    int n, m;
    FILE* ifile = fopen(INPUT_FILE, "r");
    FILE* ofile = fopen(OUTPUT_FILE, "a+");
    fscanf(ifile, "%d %d", &n, &m);
    t_member member;
    //memset(helper, -1, 200000);
    for(int i = 0; i < n; i++) helper[i] = -1;
    int m_num;
    int m_balls;
    for(int i = 0; i < m; i++){
        fscanf(ifile, "%d %d", &m_num, &m_balls);
        t_member temp[3] = {null_member, null_member, null_member};
        if(helper[m_num] == -1){
            member.num = m_num;
            member.balls = m_balls;
            member.time = i;
            heap_push(member);
        }else{
            heap[helper[m_num]].balls += m_balls;

            void (*heap_sift)(int);
            if(m_balls > 0){
                heap[helper[m_num]].time = i;
                heap_sift = &heap_sift_up;
            }
            if(m_balls < 0) heap_sift = &heap_sift_down;
            heap_sift(helper[m_num]);
        }
        int k = heap_size < 3 ? heap_size : 3;
        int c = 0;
        for(int j = 0; j < k; j++){
            temp[j] = heap_extract_max();
            if(temp[j].balls > 0) c++;
        }
        for(int j = 0; j < k; j++){
            heap_push(temp[j]);
        }
        fprintf(ofile, "%d ", c);
        for(int j = 0; j < c; j++){
            //if(temp[j].num == -1) break;
            fprintf(ofile, "%d ", temp[j].num);
            temp[j] = null_member;
        }
        fprintf(ofile, "\n");
    }
    fclose(ifile);
    fclose(ofile);
}

void heap_push(t_member member){
    heap_size++;
    heap[heap_size - 1] = member;
    helper[member.num] = heap_size - 1;
    heap_sift_up(heap_size - 1);
}

void heap_sift_up(int i){

    if(heap_size == 1)
        return;

    while(member_comparator(&heap[i], &heap[(i - 1) / 2]) == 1){

        helper[heap[i].num] = (i - 1) / 2;
        helper[heap[(i - 1) / 2].num] = i;

        t_member t = heap[i];
        heap[i] = heap[(i - 1) / 2];
        heap[(i - 1) / 2] = t;

        i = (i - 1) / 2;
    }

}

void heap_sift_down(int i){
    while(1){
        int left = 2 * i + 1;
        int right = 2 * i + 2;

        if(left >= heap_size) return;

        int k = left;

        if(right < heap_size && member_comparator(&heap[right], &heap[k]) == 1)
            k = right;

        if(member_comparator(&heap[k], &heap[i]) == -1)
            return;

        helper[heap[i].num] = k;
        helper[heap[k].num] = i;

        t_member t = heap[i];
        heap[i] = heap[k];
        heap[k] = t;

        i = k;
    }
}

t_member heap_extract_max(){
    t_member max = heap[0];
    heap[0] = heap[heap_size - 1];
    heap_size--;
    heap_sift_down(0);
    return max;
}

int member_comparator(t_member* a, t_member* b){
    if(a->balls > b->balls) return 1;
    if(a->balls == b->balls){
        if(a->time > b->time) return 1;
        if(a->time == b->time) return 0;
        if(a->time < b->time) return -1;
    }
    if(a->balls < b->balls) return -1;
}