anchor.diff:  		 compression_method = Compression,
   		 is_resumable = IsResumable,
   		 peer_certificate = PeerCert} = Session ->
  -	    ReuseEnabled 
  -		andalso resumable(IsResumable)
  +	    resumable(IsResumable)
   		andalso (OwnCert == SessionOwnCert)
  -		andalso valid_session(Session, SecondLifeTime) 
  -		andalso ReuseFun(SuggestedSessionId, PeerCert, 
  +		andalso valid_session(Session, SecondLifeTime)
  +		andalso ReuseFun(SuggestedSessionId, PeerCert,
   				 Compression, CipherSuite);
   	undefined ->
   	    false
  
positive.code: %%--------------------------------------------------------------------
  %%% Internal functions
  %%--------------------------------------------------------------------
  select_session({HostIP, Port, SslOpts}, Cache, CacheCb, OwnCert) ->
      Sessions = CacheCb:select_session(Cache, {HostIP, Port}),
      select_session(Sessions, SslOpts, OwnCert).
  
  select_session([], _, _) ->
      no_session;
  
  select_session(Sessions, #ssl_options{ciphers = Ciphers,
  				      reuse_sessions = ReuseSession}, OwnCert) ->
      IsResumable =
  	fun(Session) ->
  		ReuseSession andalso resumable(Session#session.is_resumable) andalso
   		    lists:member(Session#session.cipher_suite, Ciphers)
  		    andalso (OwnCert == Session#session.own_certificate)
   	end,
      case [Id || [Id, Session] <- Sessions, IsResumable(Session)] of
   	[] ->
   	    no_session;
   	List ->
   	    hd(List)
      end.
  
  %% If we can not generate a not allready in use session ID in
  
negative.code: 	    new_id(Port, Tries - 1, Cache, CacheCb)
      end.
  
  is_resumable(_, _, false, _, _, _, _, _) ->
      false;
  is_resumable(SuggestedSessionId, Port, true, ReuseFun, Cache,
  	     CacheCb, SecondLifeTime, OwnCert) ->
      case CacheCb:lookup(Cache, {Port, SuggestedSessionId}) of
  	#session{cipher_suite = CipherSuite,
  