static int key(W_Event *data)
{
  if (data->y == (metaHeight-B_ADD)) return add_key(data);
  if (data->key == 113 || data->key == 196) { /* q or ^d */
    metadone();
    terminate(0);
  } else if (data->key == 114 || data->key == 210) { /* r or ^r */
    refresh();
  } else if (data->key == W_Key_Up) {
    choose(-1);
  } else if (data->key == W_Key_Down) {
    choose(1);
  } else if (data->key == '\r' || data->key == ' ') { /* enter or space */
    if (chosen != -1) return chose(chosen, W_LBUTTON);
  } else if (data->key == 'g') { /* g, for guest */
    if (chosen != -1) return chose(chosen, W_MBUTTON);
  } else if (data->key == 'o') { /* o, for observe */
    if (chosen != -1) return chose(chosen, W_RBUTTON);
  } else if (data->key == 'h') {
    toggle_help();
  } else {
    return button(data);
  }
  return 0;
}

int main()
{
	int caseNumber = 1;
	scanf("%d", &numOfCases);
	while(numOfCases--)
	{
		memset(dp, -1, sizeof dp);
		scanf("%lld %lld", &N, &K);
		long long array[N];
		for(long long i = 0; i < N; i++)	scanf("%lld", &array[i]);
		std::sort(array, array + sizeof(array)/sizeof(array[0]));
		//for(int i = 0; i < N; i++)	printf("%d ", array[i]);
		//printf("\n"); 
		long long num = choose(N, K);
		long long sum = 0;
		while(num--)
		{
			sum += choose(N-1, K-1);
		}
		printf("case #%d: %lld\n", caseNumber, sum);
		caseNumber++;
		return 0;
	}	
	return 0;
}

/**
 * Description not yet available.
 * \param
 */
void lvector::fill_multinomial(const int& seed, const dvector& p)
  // Fils a dvector with random numbers drawn from a multinomial distribution
  {
    double sum=mean(p)*p.size();
    int pmin=p.indexmin();
    int pmax=p.indexmax();
    dvector tmp(pmin,pmax);
    dvector tmp1(pmin,pmax);
    dvector choose(indexmin(),indexmax());
    choose.fill_randu(seed);
    tmp=p/sum;
    tmp1(pmin)=tmp(pmin);
    for (int j=pmin+1;j<=pmax-1;j++)
    {
      tmp1(j)=tmp1(j-1)+tmp(j);
    }
    tmp1(pmax)=1.0;

    for (int i=indexmin();i<=indexmax();i++)
    {
      int j=pmin;
      while (choose(i)>tmp1(j))
      {
        j++;
      }
      (*this)(i)=j;
    }
  }

long long choose(long long n, long long k)
{
	if(dp[n][k] != -1)	return dp[n][k];
	if(n < k)	return 0;
	if(n == 0)	return 0;
	if(k == 0)	return 1;
	if(n == k)	return 1;
	if(1 == k)	return n;
	else return (choose(n-1, k-1) + choose(n-1, k));	
}

//computes n choose m
mwSize choose(mwSize m, mwSize n)
{
   if(m > n) return 0;
   if(m == 0) return 1;
   if(m == 1) return n;
   if(m == n) return 1;
   if(m == (n-1)) return n;

   return(choose(m, n-1) + choose(m-1, n-1));
}

int choose(int n, int r)
{
	static int memo[100][100];

	if(memo[n][r] != 0 )
		return memo[n][r];

	if(r == 0 || n ==r)
		return memo[n][r] = 1;
	else
		return memo[n][r] = choose(n-1, r-1) + choose(n-1, r);
}

void Login_3()//教室登陆验证函数
{

	FILE *fp_1;
	FILE *fp_2;
	int find = 0;
	char Userstrcat[22] = { 0 };
	char Userdata[22] = { 0 };
	fp_1 = fopen("dataT.dat", "rb");
	fp_2 = fopen("dataL.dat", "wb");
	printf("================================================================================");
	printf("\n  Teacher,Please enter the information of yourself to register11\n ");
	/*
	printf("  ID :");
	fflush(stdin);
	gets(INPUT);
	printf("\n");
	printf("   Password :");
	fflush(stdin);
	gets((*Input).Password);
	*/
	scanf("%s %s", INPUT_1[IN].ID, INPUT_1[IN].Password);
	fwrite(&INPUT_1[IN], sizeof(struct Login_1), 1, fp_2);
	printf("\n                                                              Logining..........");
	printf("\n                                                              Please wait.......\n");


	while (!feof(fp_1))
	{
		fread(Userdata, sizeof(struct Login_1), 1, fp_1);
		if (strcmp(Userstrcat, Userdata) == 0)
		{
			getchar();
			printf("\n                                                              Login Successful!\n");
			printf("                                                             %s,Welcome back!\n", INPUT_1[IN].ID);
			find = 1;
			printf("===============================================================================");
			printf("\n\n                                                               Enter to next ");
			getchar();
			system("cls");
			choose();
			break;
		}
	}
	if (!find)
	{
		choose();
		//printf("\n  Login failed! Pleas try again!\n");
	}
	fclose(fp_1);
	fclose(fp_2);
}

real
choose(int n, int k) {
	if (n <= 0)
		return 1;
	if (k <= 0)
		return 1;
	if (n < k)
		return n;
	// Recurse if n is too high
	if ( (fact(n) == 0.) || isinf(fact(n)) )
		return choose(n-1, k-1)+choose(n-1, k);
	return fact(n)/(fact(k)*fact(n-k));
}

int main(void)
{
  int n = 2, m = 3;

  f(&a, &b);
  f(&c, &d);

  b = choose (0, n, m);
  a += choose (1, n, m);

  a += fs163_main (10);

  return a;
}

int main(void) {
    printf("Starting.\n");
    int count = 0;
    int n=0;
    int r=0;
    /* printf("upper int limit %d\n", INT_MAX); */
    /* printf("factorial(23) %d\n", factorial(23)); */
    /* printf("choose(23, 10) %d\n", choose(23,10)); */

    for(n=1; n <= N; n++) {
        for(r=0; r <= n; r++) {
        /* for(r=0; r <= n/2 + 1; r++) { */
            /* printf("%d choose %d\n", n, r); */
            mpz_t ans;
            choose(ans, n, r);
            gmp_printf("%d choose %d is %Zd\n", n, r, ans);
            if (mpz_cmp_ui(ans , 1000000) > 0) {
                count++;
            }
        }
    }

    printf("Answer %d\n", count);

    return 0;
}

constraint mk_class_instance_cnstr(std::shared_ptr<class_instance_context> const & C, local_context const & ctx, expr const & m, unsigned depth) {
    environment const & env = C->env();
    justification j         = mk_failed_to_synthesize_jst(env, m);
    auto choice_fn = [=](expr const & meta, expr const & meta_type, substitution const &, name_generator const &) {
        if (auto cls_name_it = is_ext_class(C->tc(), meta_type)) {
            name cls_name = *cls_name_it;
            list<expr> const & ctx_lst = ctx.get_data();
            list<expr> local_insts;
            if (C->use_local_instances())
                local_insts = get_local_instances(C->tc(), ctx_lst, cls_name);
            list<name>  insts = get_class_instances(env, cls_name);
            if (empty(local_insts) && empty(insts))
                return lazy_list<constraints>(); // nothing to be done
            // we are always strict with placeholders associated with classes
            return choose(std::make_shared<class_instance_elaborator>(C, ctx, meta, meta_type, local_insts, insts, j, depth));
        } else {
            // do nothing, type is not a class...
            return lazy_list<constraints>(constraints());
        }
    };
    bool owner      = false;
    bool relax      = C->m_relax;
    return mk_choice_cnstr(m, choice_fn, to_delay_factor(cnstr_group::Basic),
                           owner, j, relax);
}

 long long int choose(int n,int k)
 {
         if(k>n)
             return 0;
     if(n<=1)
         return 1;
     if(k==0)
         return 1;
  
         if(nck[n][k]!=-1)
             return nck[n][k];
         long long int answer = choose(n-1,k-1) + choose(n-1,k);
         answer%=MOD;
         nck[n][k] = answer;
         return answer;
 }

void KDTree<Dim>::buildKDTree(int dimension, int bottom, int top)
{
    if(top == bottom)
    {
        return; //"base case"
    }

    int middle = (top+bottom)/2;//declare middle

    //call the "choose" helper function to sort of split this thing
    choose(middle, bottom, top, dimension);



    if(top > middle) //check upper end
    {
        //make recursive call
        buildKDTree((dimension+1)%Dim, middle+1, top); //call this thing on the upper end
    }

    if(bottom < middle) //check lower end
    {
        //make recursive call
        buildKDTree((dimension+1)%Dim, bottom, middle-1); //call this thing on the lower end
    }



}

double dwilcox(double x, double m, double n, int give_log)
{
    double d;

#ifdef IEEE_754
    /* NaNs propagated correctly */
    if (ISNAN(x) || ISNAN(m) || ISNAN(n))
	return(x + m + n);
#endif
    m = R_forceint(m);
    n = R_forceint(n);
    if (m <= 0 || n <= 0)
	ML_ERR_return_NAN;

    if (fabs(x - R_forceint(x)) > 1e-7)
	return(R_D__0);
    x = R_forceint(x);
    if ((x < 0) || (x > m * n))
	return(R_D__0);

    int mm = (int) m, nn = (int) n, xx = (int) x;
    w_init_maybe(mm, nn);
    d = give_log ?
	log(cwilcox(xx, mm, nn)) - lchoose(m + n, n) :
	    cwilcox(xx, mm, nn)  /  choose(m + n, n);

    return(d);
}

int main( int argc,char **argv )
{
  int arg = argc>1 ? atoi( argv[1] ) : 0;
  choose( arg );

  return( arg );
}

static void
qansari(int len, double *P, double *Q, int m, int n)
{
    int i, l, u;
    double c, p, xi;
    double ***w;

    w = w_init(m, n);
    l = (m + 1) * (m + 1) / 4;
    u = l + m * n / 2;
    c = choose(m + n, m);
    for (i = 0; i < len; i++) {
        xi = P[i];
        if(xi < 0 || xi > 1)
            error(_("probabilities outside [0,1] in qansari()"));
        if(xi == 0)
            Q[i] = l;
        else if(xi == 1)
            Q[i] = u;
        else {
            p = 0.;
            int q = 0;
            for(;;) {
                p += cansari(q, m, n, w) / c;
                if (p >= xi) break;
                q++;
            }
            Q[i] = q;
        }
    }
}

int
main(int argc, char **argv)
{
	struct player_st player;
	struct msg_chn_list_st *chn_list = NULL;
	FILE *fp;
	/* Parse .conf */
	/* Check environ */
/*	while (1) {
		c=getopt();
	}
*/
	recv_sd = init_socket();
	if (recv_sd < 0){
		exit(1);
	}
	rcv_list(&chn_list);
	player.chn_id = choose(chn_list);
	free(chn_list);
	fp = popen(global_conf.player_cmdl,"w");
	player.pipefd = fileno(fp);
	play_job(&player);

	pclose(fp);
	while(1){
		pause();
	}
	return 0;
}

/* Attempt to solve 'board'; return 0 on success else -1 on error.
 *
 * The solution process attempts to fill-in deterministically as
 * much of the board as possible. Once that is no longer possible,
 * need to choose a square to fill in.
 */
static
int
solve( void )
{
    int idx;

    rb->yield();

    while( 1 )
    {
        if( 0 == deterministic( ) )
        {
            /* Solved, make a new choice, or rewind a previous choice */
            idx = choice( );
            if( -1 == idx )
                return 0;
            else
            if( ( idx < 0 || -1 == choose( idx, 1 ) ) && -1 == backtrack( ) )
                return -1;
        }
        else /* rewind to a previous choice */
        if( -1 == backtrack( ) )
            return -1;
    }
    return -1;
}

void choose(Stack *park_stack, Stack *temp_stack, Link_queue *wait_queue)
{
    char rec[10];
    
    printf("\t\033[40;36m请输入你的选择: \033[0m");
    scanf("%s",rec);

    if(my_strcmp(rec,"1") == 0)                       //比较输入
    {
        system("reset");
	park(park_stack,temp_stack,wait_queue);      //调用函数
    }
    else if(my_strcmp(rec,"2") == 0)
    {
        system("reset");
	out(park_stack,temp_stack,wait_queue);
    }
    else if(my_strcmp(rec,"3") == 0)
    {
        system("reset");
	see(park_stack,temp_stack,wait_queue);
    }
    else if(my_strcmp(rec,"4") == 0)
    {
        system("reset");
	printf("\n\033[40;36m感谢你使用新智停车管理系统,祝你旅途愉快！~^.^~\033[0m\n\n");
	exit(0);
    }
    else
    {
        printf("\t\033[40;36m选择错误,请正确选择你要使用的功能。\033[0m\n\n");
	choose(park_stack,temp_stack,wait_queue);
    }
}

bool Downloader::setup( PluginRegistry& from,const uint32_t internalFormat,
                        const float minQuality, const bool ignoreAlpha,
                        const uint64_t capabilities,const GLEWContext* gl)
{
    return impl_->setup( from, choose( from, internalFormat, minQuality,
                                       ignoreAlpha, capabilities, gl ), gl );
}