anchor.diff:    when is_binary(Verifier), is_binary(Generator), is_binary(Prime), is_atom(Version) ->
       Private = case PrivArg of
   		  undefined -> random_bytes(32);
  -		  _ -> PrivArg
  +		  _ -> ensure_int_as_bin(PrivArg)
   	      end,
       host_srp_gen_key(Private, Verifier, Generator, Prime, Version);
   
  
positive.code: 	    {user, [DerivedKey, Prime, Generator, Version | ScramblerArg]}) when
        is_binary(Prime),
        is_binary(Generator),
        is_binary(UserPrivate),
        is_atom(Version) ->
      HostPubBin = ensure_int_as_bin(HostPublic),
      Multiplier = srp_multiplier(Version, Generator, Prime),
  
negative.code: 					HostPubBin, Prime);
  		    [S] -> S
  		end,
      srp_user_secret_nif(ensure_int_as_bin(UserPrivate), Scrambler, HostPubBin,
  			Multiplier, Generator, DerivedKey, Prime);
  
  compute_key(srp, UserPublic, {HostPublic, HostPrivate},
  	    {host,[Verifier, Prime, Version | ScramblerArg]}) when
        is_binary(Verifier),
        is_binary(Prime),
        is_atom(Version) ->
      UserPubBin = ensure_int_as_bin(UserPublic),
      Scrambler = case ScramblerArg of
  		    [] -> srp_scrambler(Version, UserPubBin, ensure_int_as_bin(HostPublic), Prime);
  		    [S] -> S
  		end,
      srp_host_secret_nif(Verifier, ensure_int_as_bin(HostPrivate), Scrambler,
  			UserPubBin, Prime);
  
  compute_key(ecdh, Others, My, Curve) ->
      ecdh_compute_key_nif(ensure_int_as_bin(Others),
  