anchor.diff:  enough_nodes_connected_to_issue_remove(Nodes) ->
       length(Nodes) > 3.
   
  +initial_state_debug(Line, Args) ->
  +    case ?INITIAL_STATE_DEBUG of
  +        true ->
  +            lager:info(Line, Args);
  +        false ->
  +            ok
  +    end.
  +
  +precondition_debug(Line, Args) ->
  +    case ?PRECONDITION_DEBUG of
  +        true ->
  +            lager:info(Line, Args);
  +        false ->
  +            ok
  +    end.
  +
  +postcondition_debug(Line, Args) ->
  +    case ?POSTCONDITION_DEBUG of
  +        true ->
  +            lager:info(Line, Args);
  +        false ->
  +            ok
  +    end.
  +
   debug(Line, Args) ->
       case ?DEBUG of
           true ->
  
positive.code:     end, MajorityNodes);
  precondition(#state{nodes=Nodes, joined_nodes=JoinedNodes}, {call, _Mod, join_cluster, [Node, JoinedNodes]}) -> 
      %% Only allow dropping of the first unjoined node in the nodes list, for ease of debugging.
      debug("precondition join_cluster: invoked for node ~p joined_nodes ~p", [Node, JoinedNodes]),
  
      ToBeJoinedNodes = Nodes -- JoinedNodes,
      debug("precondition join_cluster: remaining nodes to be joined are: ~p", [ToBeJoinedNodes]),
  
      case length(ToBeJoinedNodes) > 0 of
          true ->
              ToBeJoinedNode = hd(ToBeJoinedNodes),
              debug("precondition join_cluster: attempting to join ~p", [ToBeJoinedNode]),
              case ToBeJoinedNode of
                  Node ->
                      debug("precondition join_cluster: YES attempting to join ~p is ~p", [ToBeJoinedNode, Node]),
                      true;
                  OtherNode ->
                      debug("precondition join_cluster: NO attempting to join ~p not ~p", [ToBeJoinedNode, OtherNode]),
                      false
              end;
          false ->
              debug("precondition join_cluster: no nodes left to join.", []),
              false %% Might need to be changed when there's no read/write operations.
      end;
  precondition(#state{joined_nodes=JoinedNodes}, {call, _Mod, leave_cluster, [Node, JoinedNodes]}) -> 
      %% Only allow dropping of the last node in the join list, for ease of debugging.
      debug("precondition leave_cluster: invoked for node ~p joined_nodes ~p", [Node, JoinedNodes]),
  
      ToBeRemovedNodes = JoinedNodes,
      debug("precondition leave_cluster: remaining nodes to be removed are: ~p", [ToBeRemovedNodes]),
  
      case length(ToBeRemovedNodes) > 3 of
          true ->
              ToBeRemovedNode = lists:last(ToBeRemovedNodes),
              debug("precondition leave_cluster: attempting to leave ~p", [ToBeRemovedNode]),
              case ToBeRemovedNode of
                  Node ->
                      debug("precondition leave_cluster: YES attempting to leave ~p is ~p", [ToBeRemovedNode, Node]),
                      true;
                  OtherNode ->
                      debug("precondition leave_cluster: NO attempting to leave ~p not ~p", [ToBeRemovedNode, OtherNode]),
                      false
              end;
          false ->
              debug("precondition leave_cluster: no nodes left to remove.", []),
              false %% Might need to be changed when there's no read/write operations.
      end;
  precondition(#state{majority_nodes=MajorityNodes, minority_nodes=MinorityNodes, node_state=NodeState, joined_nodes=JoinedNodes}, {call, Mod, Fun, [Node|_]=Args}=Call) -> 
      debug("precondition fired for node function: ~p, majority_nodes: ~p, minority_nodes ~p", [Fun, MajorityNodes, MinorityNodes]),
      case lists:member(Fun, node_functions()) of
          true ->
              case ?BIAS_MINORITY andalso length(MinorityNodes) > 0 of
                  true ->
                      debug("precondition fired for node function where minority is biased: ~p, bias_minority: ~p, checking whether node ~p is in minority", [Fun, ?BIAS_MINORITY, Node]),
                      case lists:member(Node, MinorityNodes) of
                          true ->
                              debug("=> bias towards minority, write is going to node ~p in minority", [Node]),
  
negative.code:     MajorityNodes = [],
  
      %% Debug message.
      initial_state_debug("initial_state: nodes ~p joined_nodes ~p", [Nodes, JoinedNodes]),
  
      #state{joined_nodes=JoinedNodes, 
             nodes=Nodes,
  