#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <time.h>
#include <math.h>


#define minf(a, b) a < b? a : b
#define maxf(a, b) a > b? a : b


long *rss, *lss, lastls, lastrs, *precrow, *lastrow, nalloc;
char *stalls;


void place(long n, double ex, long k)
{
    long i, j, maxmin, maxmax, bestplace;
    long temp;
    double div;

    /*Primo caso, quando c'è solo la radice dell'albero*/
    if (ex == 1)
    {
        bestplace = (long)round((double)n / 2);
        lastrow = (long *)malloc(sizeof(long));
        *lastrow = bestplace;
        stalls[bestplace] = '0';

        for (i = bestplace - 1; i > 0 && stalls[i] == '.'; i--)
            rss[i] = bestplace - i - 1;

        for (i = bestplace + 1; i <= n && stalls[i] == '.'; i++)
            lss[i] = i - bestplace - 1;

        lastrs = n - bestplace;
        lastls = bestplace - 1;
        nalloc++;
        return;
    }

    precrow = lastrow;

    /*Creazione nuova linea dell'albero*/

    lastrow = (long *)malloc((long)pow(2, ex - 1) * sizeof(long));

    div = pow(2, ex);
    j = 0;

    for (i = 0; i < (long)(pow(2, ex - 2)); i++)
    {
        lastrow[j++] = (long)round((double)precrow[i] - (double)n / div);
        lastrow[j++] = (long)round((double)precrow[i] + (double)n / div);
    }

    maxmin = LONG_MIN;
    maxmax = LONG_MIN;

    free(precrow);

    /*Valutazione di tutti gli elementi calcolati*/
    temp = j;
    for (j = 0; j < temp && nalloc < k; j++)
    {
        bestplace = n + 2;

        for (i = 0; i < temp; i++)
        {
            if (lastrow[i] > 0 && stalls[lastrow[i]] == '.') /*Scarta gli elementi già valutati o non validi*/
            {
                if (minf(rss[lastrow[i]], lss[lastrow[i]]) > maxmin)
                {
                    bestplace = lastrow[i];
                    maxmin = minf(rss[lastrow[i]], lss[lastrow[i]]);
                    maxmax = maxf(rss[lastrow[i]], lss[lastrow[i]]);
                }
                else if (maxf(rss[lastrow[i]], lss[lastrow[i]]) > maxmax)
                {
                    bestplace = lastrow[i];
                    maxmin = minf(rss[lastrow[i]], lss[lastrow[i]]);
                    maxmax = maxf(rss[lastrow[i]], lss[lastrow[i]]);
                }
                else if (lastrow[i] < bestplace)
                {
                    bestplace = lastrow[i];
                    maxmin = minf(rss[lastrow[i]], lss[lastrow[i]]);
                    maxmax = maxf(rss[lastrow[i]], lss[lastrow[i]]);
                }
            }
        }

        stalls[bestplace] = '0';

        /*Aggiorna le distanze per gli elementi più vicini*/
        for (i = bestplace - 1; i > 0 && stalls[i] == '.'; i--)
            rss[i] = bestplace - i - 1;

        for (i = bestplace + 1; i <= n && stalls[i] == '.'; i++)
            lss[i] = i - bestplace - 1;

        lastrs = rss[bestplace];
        lastls = lss[bestplace];

        nalloc++;
    }

    return;
}


int main(int argc, char *argv[])
{
    FILE *fin, *fout;
    long n, k, j;
    int ncases, i;
    double ex, clockstart, clockend;

    fin = fopen("C-small-2-attempt0.in", "r");
    fout = fopen("output.txt", "w");

    fscanf(fin, "%d", &ncases);

    for (i = 1; i <= ncases; i++)
    {
        clockstart = (double)clock();

        fscanf(fin, "%d %d", &n, &k);

        ex = 1;

        rss = (long *)malloc((n + 2) * sizeof(long));
        lss = (long *)malloc((n + 2) * sizeof(long));
        stalls = (char *)malloc((n + 2) * sizeof(char));
        nalloc = 0;

        for (j = 0; j < n + 2; j++)
        {
            if (j == 0 || j == n + 1)
            {
                stalls[j] = 'X';
                rss[j] = -1;
                lss[j] = -1;
            }
            else
            {
                stalls[j] = '.';
                rss[j] = n - j;
                lss[j] = n - 1;
            }
        }

        while (nalloc < k)
        {
            place(n, ex, k);
            ex++;
        }

        fprintf(fout, "Case #%d: %d %d", i, maxf(lastls, lastrs), minf(lastls, lastrs));

        clockend = (double)clock();
        printf("Case #%d: %d %d solved in %.8f seconds\n", i, maxf(lastls, lastrs), minf(lastls, lastrs), (clockend - clockstart) / CLOCKS_PER_SEC);
    }

    fclose(fin);
    fclose(fout);

    return EXIT_SUCCESS;
}