anchor.diff:           {Win, Rest} = winend(SPrev, S, SPos, SNext, L, EndFun, [], Only),
            % could send Win someplace now
            if Type == tumbling ->
  -               winstart(Rest, StartFun, EndFun, Type, Only) ++ Win;
  +               [Win | winstart(Rest, StartFun, EndFun, Type, Only)];
               true ->
  -               winstart(tl(L), StartFun, EndFun, Type, Only) ++ Win
  +               [Win | winstart(tl(L), StartFun, EndFun, Type, Only)]
            end;
         _ ->
            winstart(tl(L), StartFun, EndFun, Type, Only)
  
positive.code:    lists:map(fun(I) ->
                    lists:flatten(lists:reverse(lists:nth(I, List)))
               end, lists:seq(1, Sz)).
  
  %% int_order_1(Tuple,Clauses) ->
  %%    Cs = lists:map(fun({C,D,E}) ->
  %%                    V = C(Tuple),
  %%                    {V,D,E}
  %%              end, Clauses),
  %%    {Tuple,Cs}.
  %% 
  %% pmap(F, [L1,L2,L3,L4,L5,L6,L7,L8,L9,L10,
  %%          L11,L12,L13,L14,L15,L16,L17,L18,L19,L20|T]) ->
  %%    S = self(),
  %%    Ref = make_ref(),
  %%    Pids = lists:map(fun(I) ->
  %%                           spawn(fun() ->
  %%                                       do_f(S,Ref,F,I) 
  %%                                 end)
  %%                     end, [L1,L2,L3,L4,L5,L6,L7,L8,L9,L10,
  %%          L11,L12,L13,L14,L15,L16,L17,L18,L19,L20]),
  %%    H = gather(Pids,Ref),
  %%    H ++ pmap(F,T);
  %% pmap(F, [L1,L2,L3,L4,L5,L6,L7,L8,L9,L10|T]) ->
  %%    S = self(),
  %%    Ref = make_ref(),
  %%    Pids = lists:map(fun(I) ->
  %%                           spawn(fun() ->
  %%                                       do_f(S,Ref,F,I) 
  %%                                 end)
  %%                     end, [L1,L2,L3,L4,L5,L6,L7,L8,L9,L10]),
  %%    H = gather(Pids,Ref),
  %%    H ++ pmap(F,T);
  %% pmap(F, L) ->
  %%    lists:map(fun(I) ->
  %%                    F(I)
  %%              end,L).
  %% 
  %% do_f(Parent,Ref,F,I) ->
  %%    Parent ! {self(),Ref,F(I)}.
  %% 
  %% gather([Pid|T],Ref) ->
  %%    receive
  %%       {Pid,Ref,Ret} ->
  %%          %?dbg("Ret",Ret),
  %%          [Ret|gather(T,Ref)]
  %%    end;
  %% gather([],_) ->
  %%    [].
  
  
  % Clauses are funs that take an entire VarStream tuple
  orderbyclause(VarStream, Clauses) ->
  
negative.code:                            Vs = [V || {_K,V} <- Ks],
                    V = reverse(maps:get(K, Mapped)),
                    V1 = lists:map(fun(ListVal) ->
                                         xqerl_seq3:from_list(ListVal)
                                   end, V),
                    New = list_to_tuple(Vs ++ V1) ,
                    [New|Acc]
  