anchor.diff:  is_time_to_renegotiate(N, M) when N < M->
       false;
   is_time_to_renegotiate(_,_) ->
  -    true.
  +    renegotiate.
   
   call(FsmPid, Event) ->
       try gen_statem:call(FsmPid, Event)
  
positive.code: set_opts(SocketOptions, [{packet, N}]) ->
      SocketOptions#socket_options{packet = N}.
  
  time_to_renegotiate(_Data, 
  		    #{current_write := #{sequence_number := Num}}, 
  		    RenegotiateAt) ->
      
      %% We could do test:
      %% is_time_to_renegotiate((erlang:byte_size(_Data) div
  
negative.code:                                               negotiated_version = Version,
                                                transport_cb = Transport,
                                                renegotiate_at = RenegotiateAt,
                                                key_update_at = KeyUpdateAt,
                                                bytes_sent = BytesSent,
                                                log_level = LogLevel},
                               connection_states = ConnectionStates0} = StateData0) ->
      case time_to_rekey(Version, Data, ConnectionStates0, RenegotiateAt, KeyUpdateAt, BytesSent) of
          key_update ->
              KeyUpdate = tls_handshake_1_3:key_update(update_requested),
              {keep_state_and_data, [{next_event, internal, {post_handshake_data, From, KeyUpdate}},
                                     {next_event, internal, {key_update, From}},
                                     {next_event, internal, {application_packets, From, Data}}]};
  	renegotiate ->
  	    ssl_connection:internal_renegotiation(Pid, ConnectionStates0),
              {next_state, handshake, StateData0, 
               [{next_event, internal, {application_packets, From, Data}}]};
  