Detta är en uppgift med två körningar. På varje test kommer din lösning att köras två gånger.

På informatiklektionen studerar Алеся och Борис kryptografi. De har bestämt sig för att uppfinna ett eget sätt att kryptera meddelanden.

Алеся väljer $k$ olika heltal från $1$ till $n$ och betecknar den resulterande mängden med $T$. Алеся vill skicka mängden $T$ som ett krypterat meddelande till Борис. För att göra detta ska Алеся utifrån mängden $T$ konstruera och skicka en annan mängd $R$ till Борис, som också består av heltal från $1$ till $n$.

De vill inte att meddelandets storlek ska ändras vid kryptering, så $R$ måste också innehålla exakt $k$ tal. Dessutom anser de att krypteringen inte blir tillräckligt säker om $T$ och $R$ innehåller minst ett gemensamt element. Därför får inget tal finnas i både $T$ och $R$, det vill säga mängderna $T$ och $R$ måste vara disjunkta. Det garanteras att $k\le n/2$, så det är alltid möjligt att konstruera minst en mängd $R$ utifrån mängden $T$.

När Борис tar emot det krypterade meddelandet $R$ måste han dekryptera det och få fram det ursprungliga meddelandet $T$.

Hjälp Алеся och Борис att utforma och implementera algoritmer för kryptering och dekryptering. Vid den första körningen ska ditt program spela rollen som Алеся, och vid den andra körningen rollen som Борис.

Indata

Den första raden i indata innehåller ett tal $a$, lika med $1$ eller $2$: numret på körningen av ditt program.

Den andra raden innehåller ett tal $m$, antalet meddelanden ($1\le m\le300\,000$) som ditt program ska kryptera (vid den första körningen) eller dekryptera (vid den andra körningen).

De följande $2m$ raderna innehåller beskrivningar av $m$ meddelanden, två rader per meddelande.

Den första raden för ett meddelande innehåller två heltal $n_i$ och $k_i$ ($2\le n_i\le10^9$, $1\le k_i\le300\,000$, $k_i\le\frac{n_i}{2}$). Den andra raden för meddelandet innehåller $k_i$ olika heltal från $1$ till $n_i$ i stigande ordning.

Det garanteras att summan av alla värden $k_i$ i ett test inte överstiger $300\,000$.

Om $a=1$ är de givna talen det ursprungliga meddelandet. Om $a=2$ är de givna talen resultatet av att ditt program körts för att kryptera något meddelande vid programmets första körning.

Utdata

Programmet ska skriva ut $m$ rader. Den $i$-te raden ska innehålla $k_i$ olika heltal från $1$ till $n_i$ i stigande ordning.

Vid den första körningen ska programmet för varje ursprungligt meddelande $T_i$ skriva ut en mängd $R_i$ som måste vara disjunkt med $T_i$.

Vid den andra körningen ska programmet för varje krypterat meddelande $R_i$ återställa det ursprungliga meddelandet $T_i$.

Exempel

Första körningen

Indata 1

1
2
2 1
1
5 2
1 4

Utdata 1

2
2 3

Andra körningen

Indata 2

2
2
5 2
2 3
2 1
2

Utdata 2

1 4
1

Kommentar

Observera att exemplet visar specifika varianter av utdata vid den första körningen och indata vid den andra körningen. Om ditt program skriver ut en annan mängd $R$ blir även indata vid den andra körningen annorlunda.

Dessutom lämnas de krypterade meddelandena vid den andra körningen inte nödvändigtvis till deltagarens program i samma ordning som vid den första körningen.

Deluppgifter

För att ange ytterligare begränsningar för indata betecknar vi talföljden som definierar mängden $T_i$ med $t_1,t_2,\ldots,t_{k_i}$. Talen är ordnade i stigande ordning.

Låt $N$ beteckna summan av $n_i$ i ett test.

Låt $K$ beteckna summan av $k_i$ i ett test.