anchor.diff:  		false ->
   			TupleTrees = tuple_es(Tree),
   			concrete(hd(TupleTrees))
  -	end.+	end.
  +
  +%% TODO: Document me.
  +%% This is the analyze program function, but it starts at a node.
  +interprocedural(NamesToFunctions, Tree) ->
  +	Worklist = [Tree],
  +	interprocedural_loop(NamesToFunctions, Worklist, sets:new()).
  +
  +%% TODO: Document me.
  +%% NOTE: This is all context insensitive for now.
  +%% TODO: This does not handle higher order functions.
  +%% This is the analyze function and the containing loop.
  +interprocedural_loop(_NamesToFunctions, [], Sends) ->
  +	% io:format("Done with interprocedural analysis: ~p~n", [sets:to_list(Sends)]),
  +	Sends;
  +interprocedural_loop(NamesToFunctions, [Tree|Rest], Sends0) ->
  +	% Anns = get_ann(Tree),
  +	% io:format("Entering interprocedural loop: ~p~n", [Anns]),
  +
  +	%% Run the intraprocedural analysis.
  +	{_Xs, _Out, _Esc, _Deps, _Par, Sends1, Applys} = intraprocedural(Tree),
  +	% io:format("=> Applys: ~p~n", [sets:to_list(Applys)]),
  +
  +	WorklistAdditions = lists:flatmap(fun(X) ->
  +		case dict:find(X, NamesToFunctions) of 
  +			{ok, {_, ApplyTree}} ->
  +				[ApplyTree];
  +			_ ->
  +				[]
  +		end
  +	end, sets:to_list(Applys)),
  +
  +	%% Recurse on the remainder of the loop.
  +	interprocedural_loop(NamesToFunctions, Rest ++ WorklistAdditions, sets:union(Sends0, Sends1)).
positive.code: 	lists:foldr(FoldFun, Acc, ReversePostorderTraversal).
  
  %% TODO: Document me.
  analysis_from_function_clause(Tree) ->
  	FindFunctionClauseFun = fun(T, {Found, Dict0}) ->
  		case type(T) of 
  			'case' ->
  
negative.code: 		    St3 = call_site(Ls, L, As, St2),
  		    L1 = get_label(T),
  		    D = dict:store(L1, X, St3#intraprocedural_state.dep),
  
  			ApplyOp = cerl:apply_op(T),
  			St4 = case type(ApplyOp) of 
  				var ->
  					VarName = var_name(ApplyOp),
  					case VarName of 
  						{external, 1} ->
  							%% Called only by outside of this module.
  							St3;
  						{_, _} ->
  							% io:format("found function usage here: ~p~n", [VarName]),
  							St3#intraprocedural_state{applys=sets:add_element(VarName, St3#intraprocedural_state.applys)};
  						_ ->
  							St3
  					end;
  				_ ->
  					St3
  			end,
  
  		    {Xs1, St4#intraprocedural_state{dep = D}};
  		none ->
  		    {none, St2}
  	    end;
  