anchor.diff:  %% default
   %% =========================================================================================================
   
  -encode(MsgFields = [{FieldName1, Value} | MsgFieldsRest],
  -   #field{type = Type, name = FieldName2, presence = Presence, operator = #default{value = InitialValue}},
  +encode([{FieldName, Value} | MsgFieldsRest],
  +   #field{type = Type, name = FieldName, presence = Presence, operator = #default{value = InitialValue}},
         Context = #context{pmap = PMap}) ->
      case Presence of
  -      optional when (FieldName1 =/= FieldName2) andalso (InitialValue == undef) ->
  -         {<<>>, MsgFields, Context#context{pmap = <<PMap/bits, 0:1>>}};
  -      optional when (FieldName1 == FieldName2) andalso (Value == absent) andalso (InitialValue == undef) ->
  +      optional when (Value == absent) andalso (InitialValue == undef) ->
            {<<>>, MsgFieldsRest, Context#context{pmap = <<PMap/bits, 0:1>>}};
  -      optional when (FieldName1 =/= FieldName2) ->
  -         {encode_type(Type, null, true), MsgFields, Context#context{pmap = <<PMap/bits, 1:1>>}};
  -      optional when (FieldName1 == FieldName2) andalso (Value == absent) ->
  +      optional when (Value == absent) ->
            {encode_type(Type, null, true), MsgFieldsRest, Context#context{pmap = <<PMap/bits, 1:1>>}};
  -      _ when (FieldName1 == FieldName2) andalso (Value =/= InitialValue) ->
  +      _ when (Value =/= InitialValue) ->
            {encode_type(Type, Value, is_nullable(Presence)), MsgFieldsRest, Context#context{pmap = <<PMap/bits, 1:1>>}};
  -      _ when (FieldName1 == FieldName2) andalso (Value == InitialValue) ->
  +      _ when (Value == InitialValue) ->
            {<<>>, MsgFieldsRest, Context#context{pmap = <<PMap/bits, 0:1>>}}
      end;
   
  
positive.code: %% copy
  %% =========================================================================================================
  
  encode([{FieldName1, Value} | _], #field{name = FieldName2, presence = mandatory, operator =
        #copy{}}, _Context) when (FieldName1 =/= FieldName2) orelse ((FieldName1 == FieldName2) andalso (Value == absent)) ->
     throw({error, {'ERR D6', FieldName2, "Mandatory field can not be absent with copy operator."}});
  
  encode(MsgFields = [{FieldName1, Value} | MsgFieldsRest],
     #field{type = Type, name = FieldName2, presence = optional, operator = #copy{dictionary = D, key = Key}},
        Context = #context{pmap = PMap, dicts = Dicts, application = App, template = #template{name = TemplateName}})
     when (FieldName1 =/= FieldName2) orelse ((FieldName1 == FieldName2) andalso (Value == absent)) ->
     Dict = select_dict(D, TemplateName, App),
     RetMsgFields = if (FieldName1 =/= FieldName2) -> MsgFields; true -> MsgFieldsRest end,
     case erlang_fast_dicts:get_value(Dict, Key, Dicts) of
        empty ->
           {<<>>, RetMsgFields, Context#context{pmap = <<PMap/bits, 0:1>>}};
        _Value -> % or undef
           Dicts1 = erlang_fast_dicts:put_value(Dict, Key, empty, Dicts),
           {encode_type(Type, null, true), RetMsgFields, Context#context{pmap = <<PMap/bits, 1:1>>, dicts = Dicts1}}
     end;
  
  encode([{_, Value} | MsgFieldsRest],
  
negative.code: %% no operator
  %% =========================================================================================================
  
  encode([{FieldName, Value} | MsgFieldsRest],
     #field{type = Type, name = FieldName, presence = _Presence, operator = undef}, Context) when (Value == absent) ->
     {encode_type(Type, null, true), MsgFieldsRest, Context};
  
  encode([{FieldName, Value} | MsgFieldsRest],
  