anchor.diff:      GH = G * 10 + H,
       PPP = EF + GH,
       io:format("[PPP] EF:~p, GH:~p, PPP:~p~n",[EF, GH, PPP]),
  -%% Let's pretent PPP is not 111
  +%% Let's pretend PPP is not 111
   %    case PPP of
   %        111 ->
       case {PPP div 100, PPP rem 100 div 10, PPP rem 10} of
           {P,P,P} ->
               case lists:member(P, Rest) of
                   true ->
  -                    [P | List];
  +                    {done, [P | List]};
                   _ ->
                       error
               end;
  
positive.code: 
  main(_) ->
      List = lists:seq(0,9),
      Ret = pick_one(List, [], [], 0),
      [A, B, C, D, E, F, G, H, P] = lists:reverse(Ret),
      io:format("  ~p~p~n- ~p~p~n----~n  ~p~p~n+ ~p~p~n----~n ~p~p~p~n", [A,B,C,D,E,F,G,H,P,P,P]).
  
  pick_one([], _, _, _) ->
      error;
  pick_one([Head | Rest], Acc, Err, Round) ->
      Acc2 = [Head | Acc],
      Check = case Round of
                  3 ->
  
negative.code:             end,
      Check2 = case Check of
                   {ok, NewAcc, NewList} ->
                       pick_one(NewList, NewAcc, [], Round + 1, SoFar);
                   Ret2 ->
                       Ret2
               end,
      case Check2 of
          error ->
              pick_one(Rest, Acc, Err ++ [Head], Round, SoFar);
          {error, SoFar2} ->
              pick_one(Rest, Acc, Err ++ [Head], Round, SoFar2);
          {done, New} ->
              pick_one(Rest, Acc, Err ++ [Head], Round, [New | SoFar])
      end.
  
  eval_ef(List, Rest) ->
  