anchor.diff:  	application ->
   	    Op = refac_syntax:application_operator(Node),
   	    Args = refac_syntax:application_arguments(Node),
  -	    Op1 = add_category(Op, C),
  -	    Op2 = update_ann(Op1, {category, application_op}),
  +            Op2 = update_ann(Op, {category, application_op}),
   	    Args1 = add_category(Args, C),
   	    Node1 = rewrite(Node, refac_syntax:application(Op2, Args1)),
   	    {update_ann(Node1, {category, C}), true};
  +        arity_qualifier ->
  +            Name = refac_syntax:arity_qualifier_body(Node),
  +            Arity = refac_syntax:arity_qualifier_argument(Node),
  +            Name1 = update_ann(Name, {category, name}),
  +            Arity1 = update_ann(Arity, {category, arity}),
  +            Node1 = rewrite(Node, refac_syntax:arity_qualifier(Name1, Arity1)),
  +            {update_ann(Node1, {category, C}), true};
   	match_expr ->
   	    P = refac_syntax:match_expr_pattern(Node),
   	    B = refac_syntax:match_expr_body(Node),
  
positive.code: 	    Name1 = add_category(Name, {macro_name, NumOfArgs, C}),
  	    Args1 = case Args of
  			none -> none;
  			_ -> add_category(Args, C) 
  		    end,
  	    Node1 = rewrite(Node, refac_syntax:macro(Name1, Args1)),
  	    {update_ann(Node1, {category, C}), true};
  	record_access ->
  	   Argument = refac_syntax:record_access_argument(Node),
  
negative.code: 	    B1 = add_category(B, expression),
  	    Node1=rewrite(Node, refac_syntax:binary_generator(P1, B1)),
  	    {update_ann(Node1, {category, generator}), true};
          binary_field ->
              Body = refac_syntax:binary_field_body(Node),
              Size = refac_syntax:binary_field_size(Node),
              Types = refac_syntax:binary_field_types(Node),
              Body1 = case refac_syntax:type(Body) of 
                          size_qualifier ->
                              add_category(refac_syntax:size_qualifier_body(Body));
                          _ ->
                              add_category(Body, C)
                      end,
              Size1 = case Size of 
                          none -> none;
                          _ ->add_category(Size, C)
                      end,
              Types1 = [add_category(T, type)||T<-Types],
              Node1 = rewrite(Node, refac_syntax:binary_field(Body1, Size1, Types1)),
              {update_ann(Node1, {category, binary_field}), true};            
  	macro ->
  	    Name = refac_syntax:macro_name(Node),
  	    Args = refac_syntax:macro_arguments(Node),
  