anchor.diff:      case deadline(Timeout) of
           badarg = Reason ->
               erlang:error(Reason, [Socket, Data, Flags, Timeout]);
  +        nowait ->
  +            send_common_nowait(SockRef, Data, To, Flags, send);
           Deadline ->
  -            send_common(SockRef, Data, To, Flags, Deadline, send)
  +            send_common_deadline(SockRef, Data, To, Flags, Deadline, send)
       end;
   send(Socket, Data, Flags, Timeout) ->
       erlang:error(badarg, [Socket, Data, Flags, Timeout]).
   
  -
  -send_common(SockRef, Data, To, Flags, Deadline, SendName) ->
  -
  +send_common_nowait(SockRef, Data, To, Flags, SendName) ->
       SendRef = make_ref(),
  -
       case
           case SendName of
               send ->
  
positive.code: 
  deadline(Timeout) ->
      case Timeout of
          nowait -> Timeout;
          infinity -> Timeout;
          _ when is_integer(Timeout), 0 =< Timeout ->
              timestamp() + Timeout;
          _ -> badarg
      end.
  
  timeout(Deadline) ->
      case Deadline of
          nowait -> 0;
          infinity -> infinity;
          _ ->
              Now = timestamp(),
              if
                  Now < Deadline -> Deadline - Now;
                  true -> 0
              end
      end.
  
  
negative.code:             %% We need to cancel this partial write.
              %%
              _ = cancel(SockRef, sendmsg, SendRef),
              {ok, sendmsg_rest(maps:get(iov, MsgHdr), Written)};
          %%
          select when (Deadline =:= nowait) ->
              ?SELECT(sendmsg, SendRef);
          select ->
  	    Timeout = timeout(Deadline),
              receive
                  {?ESOCK_TAG, #socket{ref = SockRef}, select, SendRef} ->
                      sendmsg_loop(SockRef, MsgHdr, Flags, Deadline);
                  {?ESOCK_TAG, _Socket, abort, {SendRef, Reason}} ->
                      {error, Reason}
              after Timeout ->
                      _ = cancel(SockRef, sendmsg, SendRef),
                      {error, timeout}
              end;
          %%
          {error, exbusy = Reason} when Deadline =/= nowait ->
              %% Internal error:
              %%   we called send, got eagain, and called send again
              %%   - without waiting for select message
              erlang:error(Reason);
          {error, _} = ERROR ->
              ERROR
      end.
  
  sendmsg_rest([B|IOVec], Written) when Written >= byte_size(B) ->
      sendmsg_rest(IOVec, Written - byte_size(B));
  sendmsg_rest([B|IOVec], Written) ->
      <<_:Written/binary, Rest/binary>> = B,
      [Rest|IOVec].
  
  