anchor.diff:  	    cleanup_timer(Timer);
   	{timerstopped, Timer} ->
   	    nil
  +    end.
  +
  +schedulers_on_node(Node) ->
  +    case get(plists_schedulers_on_nodes) of
  +	undefined ->
  +	    X = determine_schedulers(Node),
  +	    put(plists_schedulers_on_nodes,
  +		dict:store(Node, X, dict:new())),
  +	    X;
  +	Dict ->
  +	    case dict:is_key(Node, Dict) of
  +		true ->
  +		    dict:fetch(Node, Dict);
  +		false ->
  +		    X = determine_schedulers(Node),
  +		    put(plists_schedulers_on_nodes,
  +			dict:store(Node, X, Dict)),
  +		    X
  +	    end
  +    end.
  +
  +determine_schedulers(Node) ->
  +    Parent = self(),
  +    Child = spawn(fun () ->
  +		  Parent ! {self(), erlang:system_info(schedulers)}
  +	  end),
  +    erlang:monitor(process, Child),
  +    receive
  +	{Child, X} ->
  +	    receive
  +		{'DOWN', _, _, Child, _Reason} ->
  +		    nil
  +	    end,
  +	    X;
  +	{'DOWN', _, _, Child, Reason} when Reason =/= normal ->
  +	    0
       end.
   
   % local runmany, for when we weren't invoked with {processes, X}
  
positive.code: %
  % Malt = MaltComponent | [MaltComponent]<br/>
  % MaltComponent = SubListSize::integer() | {processes, integer()} |
  % {timeout, Milliseconds::integer()} | {nodes, [NodeSpec]}<br/>
  % NodeSpec = Node::atom() | {Node::atom(), NumProcesses::integer()}
  %
  % An integer can be given to specify the exact size for
  % sublists. 1 is a good choice for IO-bound operations and when
  
negative.code: % ways this can operate, lineraly and recursively. If Fuse is a function,
  % a fuse is done linearly left-to-right on the sublists, the results
  % of processing the first and second sublists being passed to Fuse, then
  % the result of the first fuse and processing the third sublits, and so on. If
  % Fuse is {reverse, FuseFunc}, then a fuse is done right-to-left, the results
  % of processing the second-to-last and last sublists being passed to FuseFunc,
  % then the results of processing the third-to-last sublist and
  % the results of the first fuse, and and so forth.
  % Both methods preserve the original order of the lists elements.
  %
  % To do a recursive fuse, pass Fuse as {recursive, FuseFunc}.
  % The recursive fuse makes no guarantee about the order the results of
  