anchor.diff:              #delay_bounded{bound = Bound};
             none ->
               case ?opt(dpor, Options) =:= optimal of
  -              false -> {recursive, branch};
  +              false -> {recursive, one_step};
                 true -> {recursive, tree}
               end;
             _ ->
  
positive.code: 
  -type estimation_style() ::
          {'hard_bound', pos_integer(), estimation_style()} |
          {'recursive', 'branch' | 'tree'} |
          #delay_bounded{} |
          'unknown'.
  
  
negative.code:                 {ok, More} -> [L|More]
                end,
              Sum = lists:sum(AllExplored),
              AllPlanned =
                case dict:find(M, Planned) of
                  error -> 0;
                  {ok, P} ->
                    case Subtree of
                      one_step ->
                        %% Each one-step plan will explore a similar tree
                        P * Sum / length(AllExplored);
                      tree ->
                        %% Each plan is a single planned execution so
                        %% plans are the size of the tree and the
                        %% estimation is an average between everything
                        %% we so far know (already explored plus this
                        %% planned tree).
                        (Sum + P) / (length(AllExplored) + 1)
                    end
                end,
              Sum + AllPlanned
          end,
  