anchor.diff:  				  end
   			  end
   		  end),
  -    Ans = try runmany(Fun, Fuse, List, Nodes, Malt)
  +    Ans = try runmany(Fun, Fuse, List, Nodes, Split, Malt)
   	  catch
   	      % we really just want the after block, the syntax
   	      % makes this catch necessary.
  
positive.code: 	    cleanup_timer(Timer)
  	  end,
      Ans;
  runmany(Fun, Fuse, List, local, [{nodes, NodeList}|Malt]) ->
      Nodes = lists:foldl(fun ({Node, X}, A) ->
  				lists:reverse(lists:duplicate(X, Node), A);
  			    (Node, A) ->
  				[Node|A]
  			end,
  			[], NodeList),
      runmany(Fun, Fuse, List, Nodes, Malt);
  % local recursive fuse, for when we weren't invoked with {processes, X}
  % or {nodes, NodeList}. Degenerates recursive fuse into linear fuse.
  runmany(Fun, {recursive, Fuse}, List, local, []) ->
      runmany(Fun, Fuse, List, local, []);
  runmany(Fun, Fuse, List, local, []) ->
      local_runmany(Fun, Fuse, List);
  runmany(Fun, Fuse, List, Nodes, []) ->
      cluster_runmany(Fun, Fuse, List, Nodes).
  
  cleanup_timer(Timer) ->
      receive
  
negative.code: %
  % You can use {processes, X} to have the list processed
  % by X processes on the local machine. A good choice for X is the number of
  % lines of execution (cores) the machine provides. This can be done
  % automatically with {processes, schedulers}, which sets
  % the number of processes to the number of schedulers in the erlang virtual
  % machine (probably equal to the number of cores).
  %
  % {timeout, Milliseconds} specifies a timeout. This is a timeout for the entire
  % operation, both operating on the sublists and combining the results.
  