anchor.diff:      [{ok, _} = machi_flu_psup:start_flu_package(Name, Port, Dir, FLUOpts) ||
           {#p_srvr{name=Name, port=Port}, Dir} <- AllListE],
       [machi_chain_manager1:set_chain_members(MgrName, Dict) || {_, MgrName} <- MgrNames],
  -
  -    {CRList, FCList} = setup_pool(AllListE),
  -    State = #state{num=Num, seed=Seed, verbose=Verbose,
  -                   flu_names=FLUNames, mgr_names=MgrNames,
  -                   cr_count=cr_count(Num),
  -                   cr_list=CRList, fc_list=FCList},
  -    %% Don't wait for complete chain. Even partialy completed, the chain
  -    %% should work fine. Right?
  -    wait_until_stable(chain_state_all_ok(FLUNames), FLUNames, MgrNames,
  -                      20, Verbose),
  -    State.
  -
  -setup_pool(AllListE) ->
  +    ok.
  +
  +setup_cpool(AllListE, FLUNames, Dict) ->
       Num = length(AllListE),
  -    FLUNames = [P#p_srvr.name || {P, _Dir} <- AllListE],
  -    Dict = orddict:from_list([{P#p_srvr.name, P} || {P, _Dir} <- AllListE]),
  -
       FCList = [begin
                     {ok, PCPid} = machi_proxy_flu1_client:start_link(P),
                     {Name, PCPid}
  
positive.code: chunk() ->
      non_empty(binary(10)).
  
  %% Property
  
  prop_repair(Verbose) ->
      error_logger:tty(false),
  
negative.code:     ?FORALL(Cmds,
              %% Now try-and-err'ing, how to control command length and concurrency?
              ?SUCHTHAT(Cmds0, ?SIZED(Size, resize(Size,
                        parallel_commands(?MODULE, initial_state(Num, Verbose)))),
                        commands_len(Cmds0) > 20
                        andalso
                        concurrency(Cmds0) > 2),
              begin
                  CmdsLen= commands_len(Cmds),
                  Target = setup_target(Num, Seed, Verbose),
                  {Seq, Par, Res0} = run_parallel_commands(?MODULE, Cmds),
                  %% ?V("Seq=~w~n", [Seq]),
                  %% ?V("Par=~w~n", [Par]),
                  ?V("==== Start post operations, stabilize and confirm results~n", []),
                  {FinalRes, {Dataloss, Critical}} =
                      case Res0 of
                          ok ->
                              Res1 = stabilize(CmdsLen, Target),
                              {Res1, confirm_result(Target)};
                          _ ->
                              ?V("Res0=~w~n", [Res0]),
                              {Res0, {undefined, undefined}}
                  end,
                  _ = cleanup(Target),
                  %% Process is leaking? This log line can be removed after fix.
                  [?V("process_count=~w~n", [erlang:system_info(process_count)]) || Verbose],
                  pretty_commands(
                    ?MODULE, Cmds, {Seq, Par, Res0},
                    aggregate(with_title(cmds), command_names(Cmds),
                    collect(with_title(length5), (CmdsLen div 5) * 5,
                    collect(with_title(conc),    concurrency(Cmds),
                            {FinalRes, {Dataloss, Critical}} =:= {ok, {0, 0}})))
                   )
              end)).
  
  