anchor.diff:  			FResult = end_of_part(Rest, Pattern),
   			{body, PBody, fun () -> FResult end};
   		nomatch ->
  -			PartialLength = byte_size(Bin) - PSize + 1,
  -			<<PBody:PartialLength/binary, Rest/binary>> = Bin,
  -			{body, PBody, fun () -> parse_body(Rest, Pattern) end}
  +			case suffix_match(Bin, Pattern) of
  +				nomatch ->
  +					%% Prefix of boundary not found at end of input. it's
  +					%% safe to return the whole binary. Saves copying of
  +					%% next input onto tail of current input binary.
  +					{body, Bin, fun () -> parse_body(<<>>, Pattern) end};
  +				{BoundaryStart, Len} ->
  +					PBody = binary:part(Bin, BoundaryStart, Len),
  +					Rest = binary:part(Bin, 0, BoundaryStart),
  +					{body, PBody, fun () -> parse_body(Rest, Pattern) end}
  +			end
   	end;
   parse_body(Bin, Pattern) ->
   	more(Bin, fun (NewBin) -> parse_body(NewBin, Pattern) end).
   
  --spec end_of_part(binary(), pattern()) -> end_of_part().
  +-spec end_of_part(binary(), patterns()) -> end_of_part().
   end_of_part(Bin, Pattern) ->
   	{end_of_part, fun () -> parse_boundary_tail(Bin, Pattern) end}.
   
  --spec skip(binary(), pattern()) -> more(part_result()).
  -skip(Bin, Pattern = {P, PSize}) ->
  +-spec skip(binary(), patterns()) -> more(part_result()).
  +skip(Bin, Pattern = {{P, PSize}, _}) ->
   	case binary:match(Bin, P) of
   		{BoundaryStart, _Length} ->
   			% Boundary found, proceed with parsing of the next part.
  
positive.code: 	more(Bin, fun (NewBin) -> parse_boundary_tail(NewBin, Pattern) end).
  
  %% @doc Skip whitespace and unknown chars until CRLF.
  -spec parse_boundary_eol(binary(), pattern()) -> more(part_result()).
  parse_boundary_eol(Bin, Pattern) ->
  	case binary:match(Bin, <<"\r\n">>) of
  		{CrlfStart, _Length} ->
  
negative.code: 	more(Bin, fun (NewBin) -> parse(NewBin, Boundary) end).
  
  -type pattern() :: {binary:cp(), non_neg_integer()}.
  -type patterns() :: {pattern(), pattern()}.
  
  %% @doc Return two compiled binary patterns with their sizes in bytes.
  %% The boundary pattern is the boundary prepended with "\r\n--".
  %% The boundary suffix pattern matches all prefixes of the boundary.
  -spec pattern(binary()) -> patterns().
  pattern(Boundary) ->
  	MatchPattern = <<"\r\n--", Boundary/binary>>,
  	MatchPrefixes = prefixes(MatchPattern),
  	{{binary:compile_pattern(MatchPattern), byte_size(MatchPattern)},
  	 {binary:compile_pattern(MatchPrefixes), byte_size(MatchPattern)}}.
  
  %% @doc Return all prefixes of a binary string.
  %% The list of prefixes includes the full string.
  -spec prefixes(binary()) -> [binary()].
  prefixes(<<C, Rest/binary>>) ->
  	prefixes(Rest, <<C>>).
  
  -spec prefixes(binary(), binary()) -> [binary()].
  prefixes(<<C, Rest/binary>>, Acc) ->
  	[Acc|prefixes(Rest, <<Acc/binary, C>>)];
  prefixes(<<>>, Acc) ->
  	[Acc].
  
  %% @doc Test if a boundary is a possble suffix.
  %% The patterns are expected to have been returned from `pattern/1`.
  -spec suffix_match(binary(), patterns()) -> nomatch | {integer(), integer()}.
  suffix_match(Bin, {_Boundary, {Pat, Len}}) ->
  	Size = byte_size(Bin),
  	suffix_match(Bin, Pat, Size, max(-Size, -Len)).
  
  -spec suffix_match(binary(), tuple(), non_neg_integer(), 0|neg_integer()) ->
  		nomatch | {integer(), integer()}.
  suffix_match(_Bin, _Pat, _Size, _Match=0) ->
  	nomatch;
  suffix_match(Bin, Pat, Size, Match) when Match < 0 ->
  	case binary:match(Bin, Pat, [{scope, {Size, Match}}]) of
  		{Pos, Len}=Part when Pos + Len =:= Size -> Part;
  		{_, Len} -> suffix_match(Bin, Pat, Size, Match + Len);
  		nomatch -> nomatch
  	end.
  
  %% @doc Parse remaining characters of a line beginning with the boundary.
  %% If followed by "--", <em>eof</em> is returned and parsing is finished.
  -spec parse_boundary_tail(binary(), patterns()) -> more(part_result()).
  parse_boundary_tail(Bin, Pattern) when byte_size(Bin) >= 2 ->
  	case Bin of
  		<<"--", _Rest/binary>> ->
  