```
template <class InputIterator, class OutputIterator>
OutputIterator
adjacent_difference(InputIterator first, InputIterator last,
OutputIterator result);
template <class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
ForwardIterator2
adjacent_difference(ExecutionPolicy&& exec,
ForwardIterator1 first, ForwardIterator1 last,
ForwardIterator2 result);
template <class InputIterator, class OutputIterator, class BinaryOperation>
OutputIterator
adjacent_difference(InputIterator first, InputIterator last,
OutputIterator result,
BinaryOperation binary_op);
template <class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
class BinaryOperation>
ForwardIterator2
adjacent_difference(ExecutionPolicy&& exec,
ForwardIterator1 first, ForwardIterator1 last,
ForwardIterator2 result,
BinaryOperation binary_op);
```

Requires:

- For the overloads with no ExecutionPolicy, InputIterator's value type shall be MoveAssignable (Table 25) and shall be constructible from the type of *first.acc (defined below) shall be writable ([iterator.requirements.general]) to the result output iterator.The result of the expression val - acc or binary_op(val, acc) shall be writable to the result output iterator.

Effects: For the overloads with no ExecutionPolicy and a non-empty range,
the function creates an accumulator acc whose type is InputIterator's
value type, initializes it with *first,
and assigns the result to *result.

For every iterator i in [first + 1, last)
in order, creates an object val whose type is InputIterator's value type, initializes it
with *i, computes val - acc or binary_op(val, acc), assigns the result
to *(result + (i - first)), and move assigns from val to acc.

For the overloads with an ExecutionPolicy and a non-empty range, first the
function creates an object whose type is ForwardIterator1's value type,
initializes it with *first, and assigns the result to *result.

Then for every d
in [1, last - first - 1], creates an object val whose type is
ForwardIterator1's value type, initializes it with
*(first + d) - *(first + d - 1) or
binary_op(*(first + d), *(first + d - 1)), and assigns the result to
*(result + d).