anchor.diff:  
   -spec col(Col :: integer(), BcMatrix :: dict:dict()) -> {ok, [bc_vertex:vertex()]} | error.
   col(Col, BcMatrix) ->
  -	case dict:fold(fun(Row, ColSet, BcVertices) -> 
  -			      		case sets:is_element(Col, ColSet) of
  -					  		true ->
  -						  		BcVertices ++ [bc_vertex:init(Row, Col)];
  -					  		false ->
  -						  		BcVertices
  -				  		end
  -			  		end, [], BcMatrix) of
  +	case dict:fold(
  +			fun(Row, ColSet, BcVertices) -> 
  +				case sets:is_element(Col, ColSet) of
  +					true ->
  +						BcVertices ++ [bc_vertex:init(Row, Col)];
  +					false ->
  +						BcVertices
  +				end
  +			end, [], BcMatrix) of
   		Cols when length(Cols) > 0 ->
   			{ok, Cols};
   		Cols when length(Cols) == 0 ->
  
positive.code: 
  -spec to_vertices(BcMatrix :: dict:dict()) -> [bc_vertex:vertex()].
  to_vertices(BcMatrix) ->
  	dict:fold(fun(Row, ColSet, Acc) ->  
  				Cols = sets:to_list(ColSet),
  				BcVertices = 
  					lists:map(fun(Col) -> 
  								bc_vertex:init(Row, Col) 
  							  end, Cols),
  				BcVerticesSet = sets:from_list(BcVertices),
  				lists:append(Acc, BcVerticesSet)
  			  end, [], BcMatrix).
  
  %% ====================================================================
  %% Internal functions
  
negative.code: -spec init(BcVertices :: [bc_vertex:vertex()]) -> dict:dict(Row :: integer(), 
  													   		ColSet :: sets:set(Col :: integer())).
  init(BcVertices) ->
  	lists:foldl(
  		fun(BcVertex, BcMatrix) -> 
  			Row = bc_vertex:row(BcVertex),
  			Col = bc_vertex:col(BcVertex),
  			case dict:find(Row, BcMatrix) of
  				{ok, ColSet} ->
  					UpdatedColSet = sets:add_element(Col, ColSet),
  					dict:store(Row, UpdatedColSet, BcMatrix);
  				error ->
  					NewColSet = sets:add_element(Col, sets:new()),
  					dict:store(Row, NewColSet, BcMatrix)
  			end
  		end, dict:new(), BcVertices).
  
  -spec max_row(BcMatrix :: dict:dict()) -> integer().
  max_row(BcMatrix) ->
  