private static <T> List<List<T>> mysubn(int n, List<T> li) {
		List<List<T>> ret = new ArrayList<List<T>>();
		int size = li.size();
		if (n == 0) {
			ret.add(new ArrayList<T>());
			return ret;
		}
		if (li.isEmpty()) {
			return ret;
		}
		if (size < n) {
			return ret;
		}
		if (size == n) {
			ret.add(li);
			return ret;
		}
 
		/* I use counters to actually keep track of where I am in the list,
		 * but iterators to actually get the elements.  This is because we can't
		 * assume what type of list we are accessing.  list.get(n) is O(1) for
		 * ArrayList, but O(n) for LinkedList, so we'd like to minimize these
		 * as much as possible.
		 * The reason we need to keep the counters and ending array, 
		 * instead of going until the iterators run out of elements, 
		 * is we only want them to the point where they could still make a
		 * subsequence.
		 */
		ArrayList<ListIterator<T>> iters = new ArrayList<ListIterator<T>>(n);
		ArrayList<T> currElems = new ArrayList<T>(n);
		int[] counters = new int[n];
		int[] endings = new int[n];
		// Set up our initial values
		for(int i = 0; i < n; i++) {
			iters.add(li.listIterator(i));
			currElems.add(iters.get(i).next());
			counters[i] = i;
			endings[i] = size - n + i;
		}
		// Go until the we don't have enough elements left to make a subsequence
		while(counters[0] <= endings[0]) {
			List<T> sub = new ArrayList<T>();
			for(int i = 0; i < n; i++) {
				sub.add(currElems.get(i));
			}
			ret.add(sub);
			int c = n - 1;
			// Here we figure out how many of the counters (indexes) need updating.
			while(c > 0) {
				if(counters[c] < endings[c])
					break;
				else
					c--;
			}
			// Update the left-most counter (index)
			counters[c]++;
			if(iters.get(c).hasNext())
				currElems.set(c, iters.get(c).next());
			c++;
			// Starting from the next left-most counter (if there is one),
			// set counter to be 1 more than previous counter, and reset
			// the iterator to start there as well.
			while(c < n) {
				// Reset the counter, and reset the iterator
				// to the new starting position.
				counters[c] = counters[c-1] + 1;
				iters.set(c, li.listIterator(counters[c]));
				// We make sure the iterator has another element.
				// The only time this will return false is when we are completely done
				// and the outer while is over.
				if(iters.get(c).hasNext())
					currElems.set(c, iters.get(c).next());
				c++;
			}
		}
		return ret;
	}

(define (dump-list word sequence)
 
  (define (dump-list-iter word sequence count)
 
    (if (null? sequence)
 
        '()
 
        (cond ((list? (car sequence))
 
                (dump-list-iter
 
                 (string-append
 
                  word "." (number->string count)) (car sequence) 0)
 
                (dump-list-iter word (cdr sequence) (+ count 1)))
 
               (#t
 
                (display
 
                 (string-append word "." (number->string count)
 
                                ": " (car sequence)))
 
                (newline)
 
                (dump-list-iter word (cdr sequence) (+ count 1))))))
 
  (dump-list-iter word sequence 0))

(define (make-appetizer name cost)
  (cons name cost))
(define (name app)
  (car app))
(define (cost app)
  (cdr app))
 
(define delta 0.000001)
(define (float-equal? x y)
  (< (abs (- x y)) delta))
 
(define appetizers
  (list
   (make-appetizer "mixed fruit" 2.15)
   (make-appetizer "french fries" 2.75)
   (make-appetizer "side salad" 3.35)
   (make-appetizer "hot wings" 3.55)
   (make-appetizer "mozzarella sticks" 4.20)
   (make-appetizer "sampler plate" 5.80)))
 
(define (append-unless-null set elem)
  (if (null? set)
      '()
      (cons elem set)))
 
(define (appetizers-for-cost-n apps n)
  (if (null? apps)
      '()
      (cond ((float-equal? (cost (car apps)) n) (list (car apps)))
            ((> (cost (car apps)) n)
             (appetizers-for-cost-n (cdr apps) n))
            (else
             (append
              (map (lambda (x) (cons (car apps) x))
                   (appetizers-for-cost-n apps (- n (cost (car apps)))))
              (appetizers-for-cost-n (cdr apps) n))))))

; define a tree structure to work with
(define (make-tree val left right)
  (list val left right))
(define (value tree)
  (car tree))
(define (left-branch tree)
  (cadr tree))
(define (right-branch tree)
  (caddr tree))
 
; converts postfix list to an expression-tree
(define (postfix-to-tree ops)
  (define (postfix-iter symbols values) ;progress through symbols keeping a list of values
    (if (null? symbols)
        (car values) ; returning end result
        (let ((x (car symbols)))
          (cond ((number? x) (postfix-iter (cdr symbols) (cons x values)))
                (else (postfix-iter
                       (cdr symbols)
                       (cons (make-tree x (cadr values) (car values))
                             (cddr values))))))))
  (postfix-iter ops '()))
;(postfix-to-tree '(2 1 + 3 4 * +)) == (+ (* 4 3) (+ 1 2))

(define (eval-op op a b)
  (cond ((eq? '+ op) (+ a b))
        ((eq? '- op) (- a b))
        ((eq? '* op) (* a b))
        ((eq? '/ op) (/ a b))))
 
; evaluates postfix-expression
(define (eval-postfix ops)
  (define (postfix-iter symbols values) ;progress through symbols keeping a list of values
    (if (null? symbols)
        (car values) ; returning end result
        (let ((x (car symbols)))
          (cond ((number? x) (postfix-iter (cdr symbols) (cons x values)))
                (else (postfix-iter
                       (cdr symbols)
                       (cons (eval-op x (cadr values) (car values))
                             (cddr values))))))))
  (postfix-iter ops '()))
; (eval-postfix '(2 1 + 3 4 * +)) == 15