== include(page="template/taskheader" task_id="ultimulcartus") ==

**Spoiler alert!** Dupa moartea lui Miclovan viata a devenit monotona si absenta, comisarul fiind Roman este pus in situatia de a il prinde pe Semaca, anticarul proaspat achitat de justitie din lipsa de probe.

!>problema/ultimulcartus?roman.jpg!

Astfel, Roman ajunge in fata unei arhive vechi, plina cu $N$ dosare ({$N$} putere a lui {$2$}), aranjate intr-o ordine aleatorie. Un prim pas in analizarea acestora il reprezinta ordonarea lor alfabetica dupa titlu. Vom considera pentru simplitate ca titlurile celor $N$ dosare sunt numere naturale distincte, cuprinse intre $1$ si $N$ (altfel spus, ordinea dosarelor reprezinta o permutare a numerelor de la $1$ la $N$). Deoarece numarul dosarelor este destul de mare, Roman propune o abordare sistematica, pe care o va duce la bun sfarsit cu ajutorul subordonatilor sai. Aceasta poate fi descrisa prin urmatorul algoritm:

**Spoiler alert!** Dupa moartea lui Miclovan viata a devenit monotona si absenta, comisarul Roman este pus in situatia de a il prinde pe Semaca, anticarul proaspat achitat de justitie din lipsa de probe.
 
Astfel, Roman ajunge in fata unei arhive vechi, plina cu $N$ dosare ({$N$} putere de {$2$}), aranjate intr-o ordine aleatorie. Un prim pas in analizarea acestora il reprezinta ordonarea lor alfabetica dupa titlu. Vom considera pentru simplitate ca titlurile celor $N$ dosare sunt reprezentate prin numere naturale distincte, cuprinse intre $1$ si $N$ (altfel spus, ordinea dosarelor reprezinta o permutare a numerelor de la $1$ la $N$).
 
Deoarece numarul dosarelor este destul de mare, Roman propune o abordare sistematica, pe care o va duce la bun sfarsit cu ajutorul subordonatilor sai. Aceasta poate fi descrisa prin urmatorul algoritm:

== code(cpp) |
const int NMAX = 1000000000;
int N;

int p[NMAX + 1]; // = permutarea titlurilor dosarelor

int P[NMAX + 1]; //Permutarea

int ops;

void bubble(int gap) {

void Bubble(int gap) {

    bool ok = true;
    while (ok) {
        ok = false;
        for (int i = 1; i <= N - gap; ++ i)

            if (p[i] > p[i + gap]) {
                swap(p[i], p[i + gap]);

            if (P[i] > P[i + gap]) {
                swap(P[i], P[i + gap]);

                ++ ops;
                ok = true;
            }
    }
}

void bubblesort() {

void BubbleSort() {

    int gap = N;
    while (gap) {

        bubble(gap);

        Bubble(gap);

        gap /= 2;
    }
}
==

Mai exact, procedura lui Roman este un singur apel al functiei $bubblesort()$.

 
Mai exact, procedura lui Roman este un singur apel al functiei $BubbleSort()$.

Dupa imediata ordonare a dosarelor Roman isi pune o intrebare existentiala "Care e cea mai mare valoare posibila a variabilei $ops$ pentru o permutare oarecare?"
h2. Cerinta

Dandu-se $N$, numar natural nenul, putere a lui 2, sa se calculeze urmatoarele

Dandu-se $N$, numar natural nenul, putere de 2, sa se calculeze urmatoarele:

# Valoarea maxima posibila a variabilei $ops$ dupa un singur apel al functiei $bubblesort()$;

# Valoarea maxima posibila a variabilei $ops$ dupa un singur apel al functiei $BubbleSort()$;

# Numarul de permutari cu $N$ elemente pentru care se atinge acest maxim;

# Dintre acestea, permutarea minima din punct de vedere lexicografic. Deoarece output-ul poate fi prea mare, se va da un un sir cu $M$ elemente $a{~i~}$ si se va cere pentru fiecare element $a{~i~}$ sa se afiseze valoarea $p[a{~i~}]$.

# Dintre acestea, permutarea minima din punct de vedere lexicografic. Deoarece output-ul poate fi destul de mare, se va da un un sir cu $M$ elemente $a{~i~}$ si se va cere pentru fiecare element $a{~i~}$ sa se afiseze valoarea $P[a{~i~}]$ din permutarea ceruta.

h2. Date de intrare

h2. Date de ieşire

Fişierului de ieşire $ultimulcartus.out$ va contine 3 linii, cate una pentru fiecare cerinta. Pentru cerinta $3$ valorile $p[a{~i~}]$ se vor afisa toate pe aceeasi linie, oricare doua consecutive fiind separate prin cate un spatiu.

Fişierului de ieşire $ultimulcartus.out$ va contine 3 linii, cate una pentru fiecare cerinta. Pentru cerinta $3$ valorile $P[a{~i~}]$ se vor afisa toate pe aceeasi linie, oricare doua consecutive separate prin cate un spatiu.

h2. Restricţii

* $N$ este putere a lui $2$

* $N$ este putere de $2$

* $1 ≤ M ≤ 10 000$

* **Subtask $1$ (1 puncte):** $N = 1$
* **Subtask $2$ (1 puncte):** $N = 2$
* **Subtask $3$ (1 puncte):** $N = 3$
* **Subtask $4$ (2 puncte):** $N = 4$
* **Subtask $5$ (5 puncte):** $N = 5$
 
* **Subtask $6$ (20 puncte):** $1 ≤ N ≤ 3 000$
* **Subtask $7$ (35 puncte):** $1 ≤ N ≤ 1 000 000$
* **Subtask $8$ (35 puncte):** $1 ≤ N ≤ 1 000 000 000$
 

* **Subtask $1$ (1 puncte):** $N = 1$ (Feedback testul $1$)
* **Subtask $2$ (1 puncte):** $N = 2$ (Feedback testul $2$)
* **Subtask $3$ (1 puncte):** $N = 4$ (Feedback testul $3$)
* **Subtask $4$ (2 puncte):** $N = 8$ (Feedback testul $4$)
* **Subtask $5$ (5 puncte):** $N = 16$ (Feeback testul $5$)
 
* **Subtask $6$ (20 puncte):** $1 ≤ N ≤ 3 000$ (Feedback testul $12$)
* **Subtask $7$ (35 puncte):** $1 ≤ N ≤ 1 000 000$ (Feedback testul $20$)
* **Subtask $8$ (35 puncte):** $1 ≤ N ≤ 1 000 000 000$ (Feedback testul $28$)

h2. Exemplu

  1 2
| 1
  1

  1 2

  2 1

|
h3. Explicaţie