anchor.diff:              Accumulate = lists:member(accumulate, Behaviors),
               Converge = lists:member(converge, Behaviors),
               {ok, executing, #state{mod=PhaseMod, modstate=ModState, next_phases=NextPhases,
  -                                   flow=Flow, accumulate=Accumulate, converge=Converge, timeout=Timeout}, Timeout};
  +                                   flow=Flow, accumulate=Accumulate, converge=Converge, flow_timeout=Timeout}};
           {stop, Reason} ->
               {stop, Reason}
       end.
   
  -executing({partners, Lead0, Partners0}, #state{converge=true, timeout=Timeout}=State) when is_list(Partners0) ->
  +executing({partners, Lead0, Partners0}, #state{converge=true}=State) when is_list(Partners0) ->
       Me = self(),
       Lead = case Lead0 of
                  Me ->
  
positive.code: 
  %% Internal functions
  %% Handle callback module return values
  handle_callback({no_output, NewModState}, #state{timeout=Timeout}=State) ->
      {next_state, executing, State#state{modstate=NewModState}, Timeout};
  handle_callback({no_output, NewModState, TempTimeout}, #state{timeout=Timeout}=State) when TempTimeout < Timeout ->
      {next_state, executing, State#state{modstate=NewModState, cb_timeout=true}, TempTimeout};
  handle_callback({output, Output, NewModState}, #state{timeout=Timeout}=State) ->
      State1 = route_output(Output, State),
      {next_state, executing, State1#state{modstate=NewModState}, Timeout};
  handle_callback({output, Output, NewModState, TempTimeout}, #state{timeout=Timeout}=State) when TempTimeout < Timeout ->
      State1 = route_output(Output, State),
      {next_state, executing, State1#state{modstate=NewModState, cb_timeout=true}, TempTimeout};
  handle_callback({stop, Reason, NewModState}, State) ->
      {stop, Reason, State#state{modstate=NewModState}};
  handle_callback(BadValue, _State) ->
  
negative.code:                     true ->
                          1
                  end,
      {next_state, executing, State#state{lead_partner=Lead, partners=Partners, done_count=DoneCount}};
  executing({partners, _, _}, State) ->
      {stop, {error, no_convergence}, State};
  executing({inputs, Input}, #state{mod=PhaseMod, modstate=ModState, flow_timeout=Timeout}=State) ->
      handle_callback(PhaseMod:handle_input(Input, ModState, Timeout), State);
  executing(inputs_done, #state{mod=PhaseMod, modstate=ModState, done_count=DoneCount0}=State) ->
      case DoneCount0 - 1 of
  