/* Function: PerformInsert(int value,
 *                         multiset<int>& minSet,
 *                         multiset<int>& maxSet)
 * Usage: bool success = PerformInsert(value, minSet, maxSet);
 * -----------------------------------------------------------------------------
 * Inserts one instance of the specified value into the minset or the maxset, 
 * according to the following logic: if the value exceeds the current maximum 
 * value in the minset, then add the value to the maxset; otherwise, add the 
 * value to the minset. The function returns true if the insert operation was 
 * successful, and false otherwise.
 */
bool PerformInsert(int value, multiset<int>& minSet, multiset<int>& maxSet)
{
  if (minSet.empty() || value <= *FindMaxElement(minSet))
    minSet.insert(value);
  else
    maxSet.insert(value);
  
  /* Always return true. */
  return true;
}

Node AStar::getNodeFromSet( multiset<Node> l,Node n){

    multiset<Node> ::iterator it;
    for(it = l.begin();it!=l.end();it++){
        if(n.id == (*it).id){
            return *it;
        }

    }
}

void inline cut(set<int> &s, multiset<int> &ss, int t) {
    s.insert(t);
    auto l = s.find(t), r = l;
    --l, ++r;
    int cur = *r - *l;
    //cout<<"cur: "<<cur<<endl;
    ss.erase(ss.find(cur));
    ss.insert(*r - t);
    ss.insert(t - *l);
}

int main(){
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cin >> t;
  while(t--){
    S.clear();
    cin >> n;
    for(int i=0;i<n;i++){
      cin >> x;
      it = S.upper_bound(x);
      if(it==S.end()){
        S.insert(x);
      }
      else{
        S.erase(it);
        S.insert(x);
        //(*it) = x;
      }
    }
    cout << S.size() << " ";
    for(multiset<int>::iterator it=S.begin();it!=S.end();it++){
      cout << (*it)  << " ";
    }
    cout << endl;
  }
  return 0;
}

multiset<Node,NodeCompare>::iterator FindNode(const multiset<Node, NodeCompare>& nodes, int i, int j)
{
   for (set<Node, NodeCompare>::iterator it = nodes.begin(); it != nodes.end(); ++it)
   {
      if (it->x == i && it->y == j) 
      { 
         return it;
      }
   }
   return nodes.end(); 
}

bool AStar::findInSet( multiset<Node> l,Node n){

    multiset<Node> ::iterator it;
    for(it = l.begin();it!=l.end();it++){
        if(n.id == (*it).id){
            return true;
        }

    }

    return false;
}

int main() {
	multiset<int>::iterator it;
	while (scanf("%d", &n) != EOF) {
		while (!S.empty())
			S.pop();
		lef.clear();
		righ.clear();
		for (int i = 0; i < n; ++i) {
			scanf("%s", buf);
			if (strcmp(buf, "Pop") == 0) {
				if (S.empty()) {
					printf("Invalid\n");
					continue;
				}
				int u = S.top();
				S.pop();
				if (u <= med) {
					it = lef.find(u);
					lef.erase(it);

				}
				else {
					it = righ.find(u);
					righ.erase(it);
				}
				adjust();
				printf("%d\n", u);
			}
			else if (strcmp(buf, "PeekMedian") == 0) {
				if (S.empty()) {
					printf("Invalid\n");
					continue;
				}
				printf("%d\n", med);
			}
			else if (strcmp(buf, "Push") == 0) {
				int u;
				scanf("%d", &u);
				if (S.empty()) {
					med = u;
					lef.insert(u);
					
				}
				else if (u > med) {
					righ.insert(u);
				}
				else {
					lef.insert(u);
				}
				S.push(u);
				adjust();
			}
			else
				printf("Invalid\n");
		}
	}
	return 0;
}

void debug()
{
      multiset<pair<int,int> > ::iterator it;
      puts("- - - - - - - - - -debug   begin-- - - - - - - - - - - - ");

      for(it=apple.begin();it!=apple.end();++it)
      {
            cout<<(*it).first<<" "<<(*it).second<<endl;
      }

      puts("- - - - - - - - - -debug   end-- - - - - - - - - - - - ");

}

Node AStar::getMinimumNode( multiset<Node> l){
    if(l.size()>=1){
        multiset<Node>::iterator it = l.begin();
#if DEBUG
        printf("Minimum f_score node is %lld \n", (*it).id);
#endif
        return *it;
    }
    else{
        printf("Set is empty, no nodes left to expand");
        //exit(0);
    }
}

bool TSP::is_BiASGS_goal( const search_node& s, const multiset<search_node, less<search_node> >& frontier )
{
  multiset<search_node>::iterator it;
  for ( it = frontier.begin(); it != frontier.end(); it++ )
  {
    if ( s.get_state() == (*it).get_state() )
    {
      return true;
    }
  }
    
  return false;
}

double Greedy01(const multiset<Elemento> & objetos, const double pesoM){
    double pesoact = 0, beneficio = 0;

    multiset<Elemento>::const_reverse_iterator it;

    for(it = objetos.rbegin(); it != objetos.rend() && pesoact < pesoM; ++it)
        if((pesoact + (*it).peso) <= pesoM){
            beneficio += (*it).beneficio;
            pesoact += (*it).peso;
        }

    return beneficio;
}

int two_array(multiset<int> &a, multiset<int> &b, int k)
{
	for(int i : a)
	{
		multiset<int>::iterator it = b.lower_bound(k-i);
		if(it == b.end())
			return 0;	
		
		b.erase(it);
	}
	
	return 1;
}

int main()
{
    int num;
    while(cin>>num&&num)
    {
        int key;
        vec.clear();
        for(int i=0;i<num;i++)
        {
            cin>>key;
            vec.insert(key);
        }
        int sum=0;
        int x,y,s;
        while(vec.size()>=2)
        {
            multiset<int>::iterator it1=vec.begin();
            x=*it1;
            vec.erase(it1);
            multiset<int>::iterator it2=vec.begin();
            y=*it2;
            vec.erase(it2);
            sum=sum+x+y;
            vec.insert(x+y);
        }
        cout<<sum<<endl;
    }
    return 0;
}

int main()
{
    //freopen("I.in","r",stdin);
    //freopen("I.out","w",stdout);
    int T;
    scanf("%d", &T);
    for(int cas=1;cas<=T;cas++)
    {
        mst.clear();
        int n, m, k, cnt = 0;
        long long  num;
        scanf("%d%d%d", &n, &m, &k);
        for(int i = 0; i < n; ++i)
        {
            scanf("%lld", &num);
            if(num <= k)
            {
                mst.insert(num);
            }
        }
        while(true)
        {
            int sz = mst.size();
            if(sz < 2)
                break;
            it1 = mst.end();
            it1--;
            long long  fst = *it1;
            mst.erase(it1);
            it2 = mst.lower_bound(min(fst, k - fst));
            if(it2 == mst.end())
                it2--;
            if(it2 == mst.begin() && *it2 > (k - fst))
                continue;
            if(*it2 <= k - fst)
            {
                ans[cnt++] = fst * ( *it2);
                mst.erase(it2);
            }
            else
            {
                it2 --;
                ans[cnt++] = fst * (*it2);
                mst.erase(it2);
            }
        }
        sort(ans, ans + cnt, cmp);
        long long  res = 0;
        for(int i = 0; i < min(m, cnt); ++i)
        {
            res += ans[i];
        }
        printf("CASE #%d: %lld\n",cas,res);
    }
    return 0;
}

int main(){
  int n;rit(n);
  for(int l,r;n;--n){
    rit(l,r);
    auto it=st.upper_bound(r);
    if(it!=st.end())st.erase(it);
    st.insert(l);
  }
  printf("%d\n",st.size());
}

	int update(int x){
		int u=V.back();
		int p=fa[u];
		if (p) D[p].erase(D[p].find(faW[u]+tree[0].mxR));
		ans.erase(ans.find(tree[0].mx));
		update_tree(0,n-1,at[x],0);
		ans.insert(tree[0].mx);
		if (p) D[p].insert(faW[u]+tree[0].mxR);
		return p;
	}

		void pushup() {
			if (this == EMPTY)	return ;
			mxv = val;
			if (s.size())
				mxv = max(mxv, *s.rbegin());
			if (ch[0] != EMPTY)
				mxv = max(mxv, ch[0]->mxv);
			if (ch[1] != EMPTY)
				mxv = max(mxv, ch[1]->mxv);
		}

void scan(int i, int n, int k, ll sum){
    if(i>k){
        mys.erase(mys.find(sum));
        return;
    }
    for(int j=pos[i-1]; j<=n; ++j){
        pos[i]=j;
        scan(i+1,n,k,sum+a[j]);
    }
}

int main()
{
    int n,d,r;
    while(scanf("%d%d%d",&n,&d,&r)!=EOF&&n||d||r)
    {
        int k;
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&k);
            s1.insert(k);
        }
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&k);
            s2.insert(k);
        }
        int ans=0;
        for(int i=1;i<=n;i++)
        {
            int num=*s1.begin();
            int index=d-num;
            __typeof(s2.begin()) it=s2.lower_bound(index);
            if(it==s2.end())it--;
            ans+=r*max(0,num+*it-d);
            s1.erase(s1.begin());
            s2.erase(it);
        }
        printf("%d\n",ans);
    }
    return 0;
}

int main()
{
    int n, m, a;

    while ( scanf("%d", &n), n )
    {
        long long ans = 0LL;
        urn.clear();
        for (int i = 0; i < n; i++)
        {
            scanf("%d", &m);
            for (int j = 0; j < m; j++)
            {
                scanf("%d", &a);
                urn.insert( a );
            }
            ans += *urn.rbegin() - *urn.begin();
            urn.erase( urn.begin() );
            urn.erase( urn.find(*urn.rbegin()) );
        }
        printf("%lld\n", ans);
    }

    return 0;
}