Dispatching on iterator strength:

• vector::_Insert_range() (changed by Use iterator concept in vector's range constructor #1794)
  

  STL/stl/inc/vector

  Lines 1027 to 1166 in f099e9c

  	template <class _Iter>
  	_CONSTEXPR20 void _Insert_range(const_iterator _Where, _Iter _First, _Iter _Last, input_iterator_tag) {
  	// insert input range [_First, _Last) at _Where
  	if (_First == _Last) {
  	return; // nothing to do, avoid invalidating iterators
  	}
  	auto& _My_data = _Mypair._Myval2;
  	pointer& _Myfirst = _My_data._Myfirst;
  	pointer& _Mylast = _My_data._Mylast;
  	const auto _Whereoff = static_cast<size_type>(_Where._Ptr - _Myfirst);
  	const auto _Oldsize = static_cast<size_type>(_Mylast - _Myfirst);
  	// For one-at-back, provide strong guarantee.
  	// Otherwise, provide basic guarantee (despite N4659 26.3.11.5 [vector.modifiers]/1).
  	// Performance note: except for one-at-back, _Emplace_one_at_back()'s strong guarantee is unnecessary here.
  	for (; _First != _Last; ++_First) {
  	_Emplace_one_at_back(*_First);
  	}
  	_Orphan_range(_Myfirst + _Whereoff, _Myfirst + _Oldsize);
  	_STD rotate(_Myfirst + _Whereoff, _Myfirst + _Oldsize, _Mylast);
  	}
  	template <class _Iter>
  	_CONSTEXPR20 void _Insert_range(const_iterator _Where, _Iter _First, _Iter _Last, forward_iterator_tag) {
  	// insert forward range [_First, _Last) at _Where
  	const pointer _Whereptr = _Where._Ptr;
  	const auto _Count = _Convert_size<size_type>(static_cast<size_t>(_STD distance(_First, _Last)));
  	auto& _Al = _Getal();
  	auto& _My_data = _Mypair._Myval2;
  	pointer& _Mylast = _My_data._Mylast;
  	const pointer _Oldfirst = _My_data._Myfirst;
  	const pointer _Oldlast = _Mylast;
  	const auto _Unused_capacity = static_cast<size_type>(_My_data._Myend - _Oldlast);
  	if (_Count == 0) { // nothing to do, avoid invalidating iterators
  	} else if (_Count > _Unused_capacity) { // reallocate
  	const auto _Oldsize = static_cast<size_type>(_Oldlast - _Oldfirst);
  	if (_Count > max_size() - _Oldsize) {
  	_Xlength();
  	}
  	const size_type _Newsize = _Oldsize + _Count;
  	const size_type _Newcapacity = _Calculate_growth(_Newsize);
  	const pointer _Newvec = _Al.allocate(_Newcapacity);
  	const auto _Whereoff = static_cast<size_type>(_Whereptr - _Oldfirst);
  	const pointer _Constructed_last = _Newvec + _Whereoff + _Count;
  	pointer _Constructed_first = _Constructed_last;
  	_TRY_BEGIN
  	_Uninitialized_copy(_First, _Last, _Newvec + _Whereoff, _Al);
  	_Constructed_first = _Newvec + _Whereoff;
  	if (_Count == 1 && _Whereptr == _Oldlast) { // one at back, provide strong guarantee
  	if constexpr (is_nothrow_move_constructible_v<_Ty> || !is_copy_constructible_v<_Ty>) {
  	_Uninitialized_move(_Oldfirst, _Oldlast, _Newvec, _Al);
  	} else {
  	_Uninitialized_copy(_Oldfirst, _Oldlast, _Newvec, _Al);
  	}
  	} else { // provide basic guarantee
  	_Uninitialized_move(_Oldfirst, _Whereptr, _Newvec, _Al);
  	_Constructed_first = _Newvec;
  	_Uninitialized_move(_Whereptr, _Oldlast, _Newvec + _Whereoff + _Count, _Al);
  	}
  	_CATCH_ALL
  	_Destroy_range(_Constructed_first, _Constructed_last, _Al);
  	_Al.deallocate(_Newvec, _Newcapacity);
  	_RERAISE;
  	_CATCH_END
  	_Change_array(_Newvec, _Newsize, _Newcapacity);
  	} else { // Attempt to provide the strong guarantee for EmplaceConstructible failure.
  	// If we encounter copy/move construction/assignment failure, provide the basic guarantee.
  	// (For one-at-back, this provides the strong guarantee.)
  	const auto _Affected_elements = static_cast<size_type>(_Oldlast - _Whereptr);
  	_ASAN_VECTOR_EXTEND_GUARD(static_cast<size_type>(_Oldlast - _Oldfirst) + _Count);
  	if (_Count < _Affected_elements) { // some affected elements must be assigned
  	_Mylast = _Uninitialized_move(_Oldlast - _Count, _Oldlast, _Oldlast, _Al);
  	_Move_backward_unchecked(_Whereptr, _Oldlast - _Count, _Oldlast);
  	_Destroy_range(_Whereptr, _Whereptr + _Count, _Al);
  	_TRY_BEGIN
  	_Uninitialized_copy(_First, _Last, _Whereptr, _Al);
  	_CATCH_ALL
  	// glue the broken pieces back together
  	_TRY_BEGIN
  	_Uninitialized_move(_Whereptr + _Count, _Whereptr + 2 * _Count, _Whereptr, _Al);
  	_CATCH_ALL
  	// vaporize the detached piece
  	_Orphan_range(_Whereptr, _Oldlast);
  	_Destroy_range(_Whereptr + _Count, _Mylast, _Al);
  	_Mylast = _Whereptr;
  	_RERAISE;
  	_CATCH_END
  	_Move_unchecked(_Whereptr + 2 * _Count, _Mylast, _Whereptr + _Count);
  	_Destroy_range(_Oldlast, _Mylast, _Al);
  	_Mylast = _Oldlast;
  	_RERAISE;
  	_CATCH_END
  	} else { // affected elements don't overlap before/after
  	const pointer _Relocated = _Whereptr + _Count;
  	_Mylast = _Uninitialized_move(_Whereptr, _Oldlast, _Relocated, _Al);
  	_Destroy_range(_Whereptr, _Oldlast, _Al);
  	_TRY_BEGIN
  	_Uninitialized_copy(_First, _Last, _Whereptr, _Al);
  	_CATCH_ALL
  	// glue the broken pieces back together
  	_TRY_BEGIN
  	_Uninitialized_move(_Relocated, _Mylast, _Whereptr, _Al);
  	_CATCH_ALL
  	// vaporize the detached piece
  	_Orphan_range(_Whereptr, _Oldlast);
  	_Destroy_range(_Relocated, _Mylast, _Al);
  	_Mylast = _Whereptr;
  	_RERAISE;
  	_CATCH_END
  	_Destroy_range(_Relocated, _Mylast, _Al);
  	_Mylast = _Oldlast;
  	_RERAISE;
  	_CATCH_END
  	}
  	_Orphan_range(_Whereptr, _Oldlast);
  	_ASAN_VECTOR_RELEASE_GUARD;
  	}
  	}

• vector::_Assign_range() (changed by Use iterator concept in vector's range constructor #1794)
  

  STL/stl/inc/vector

  Lines 1236 to 1315 in f099e9c

  	template <class _Iter>
  	_CONSTEXPR20 void _Assign_range(_Iter _First, _Iter _Last, input_iterator_tag) {
  	// assign input range [_First, _Last)
  	auto& _My_data = _Mypair._Myval2;
  	pointer& _Myfirst = _My_data._Myfirst;
  	pointer& _Mylast = _My_data._Mylast;
  	_My_data._Orphan_all();
  	pointer _Next = _Myfirst;
  	for (; _First != _Last && _Next != _Mylast; ++_First, (void) ++_Next) {
  	*_Next = *_First;
  	}
  	// Code size optimization: we've exhausted only the source, only the dest, or both.
  	// If we've exhausted only the source: we Trim, then Append does nothing.
  	// If we've exhausted only the dest: Trim does nothing, then we Append.
  	// If we've exhausted both: Trim does nothing, then Append does nothing.
  	// Trim.
  	_Destroy_range(_Next, _Mylast, _Getal());
  	_ASAN_VECTOR_MODIFY(static_cast<difference_type>(_Next - _Mylast)); // negative when destroying elements
  	_Mylast = _Next;
  	// Append.
  	for (; _First != _Last; ++_First) {
  	// performance note: _Emplace_one_at_back()'s strong guarantee is unnecessary here
  	_Emplace_one_at_back(*_First);
  	}
  	}
  	template <class _Iter>
  	_CONSTEXPR20 void _Assign_range(_Iter _First, _Iter _Last, forward_iterator_tag) {
  	// assign forward range [_First, _Last)
  	const auto _Newsize = _Convert_size<size_type>(static_cast<size_t>(_STD distance(_First, _Last)));
  	auto& _Al = _Getal();
  	auto& _My_data = _Mypair._Myval2;
  	pointer& _Myfirst = _My_data._Myfirst;
  	pointer& _Mylast = _My_data._Mylast;
  	pointer& _Myend = _My_data._Myend;
  	constexpr bool _Nothrow_construct = conjunction_v<is_nothrow_constructible<_Ty, _Iter_ref_t<_Iter>>,
  	_Uses_default_construct<_Alloc, _Ty*, _Iter_ref_t<_Iter>>>;
  	_My_data._Orphan_all();
  	const auto _Oldcapacity = static_cast<size_type>(_Myend - _Myfirst);
  	if (_Newsize > _Oldcapacity) {
  	_Clear_and_reserve_geometric(_Newsize);
  	if constexpr (_Nothrow_construct) {
  	_Mylast = _Uninitialized_copy(_First, _Last, _Myfirst, _Al);
  	_ASAN_VECTOR_CREATE;
  	} else {
  	_ASAN_VECTOR_CREATE_GUARD;
  	_Mylast = _Uninitialized_copy(_First, _Last, _Myfirst, _Al);
  	}
  	return;
  	}
  	const auto _Oldsize = static_cast<size_type>(_Mylast - _Myfirst);
  	if (_Newsize > _Oldsize) {
  	// performance note: traversing [_First, _Mid) twice
  	const _Iter _Mid = _STD next(_First, static_cast<difference_type>(_Oldsize));
  	_Copy_unchecked(_First, _Mid, _Myfirst);
  	if constexpr (_Nothrow_construct) {
  	_ASAN_VECTOR_MODIFY(static_cast<difference_type>(_Newsize - _Oldsize));
  	_Mylast = _Uninitialized_copy(_Mid, _Last, _Mylast, _Al);
  	} else {
  	_ASAN_VECTOR_EXTEND_GUARD(_Newsize);
  	_Mylast = _Uninitialized_copy(_Mid, _Last, _Mylast, _Al);
  	_ASAN_VECTOR_RELEASE_GUARD;
  	}
  	} else {
  	const pointer _Newlast = _Myfirst + _Newsize;
  	_Copy_unchecked(_First, _Last, _Myfirst);
  	_Destroy_range(_Newlast, _Mylast, _Al);
  	_ASAN_VECTOR_MODIFY(static_cast<difference_type>(_Newsize - _Oldsize));
  	_Mylast = _Newlast;
  	}
  	}

• vector<bool>::_Insert() (fixed by Untag dispatch vector<👻>::_Insert #2694)
  

  STL/stl/inc/vector

  Lines 3089 to 3104 in f099e9c

  	template <class _Iter>
  	_CONSTEXPR20 void _Insert(const_iterator _Where, _Iter _First, _Iter _Last, input_iterator_tag) {
  	difference_type _Off = _Where - begin();
  	for (; _First != _Last; ++_First, (void) ++_Off) {
  	insert(begin() + _Off, *_First);
  	}
  	}
  	template <class _Iter>
  	_CONSTEXPR20 void _Insert(const_iterator _Where, _Iter _First, _Iter _Last, forward_iterator_tag) {
  	_Adl_verify_range(_First, _Last);
  	auto _Count = _Convert_size<size_type>(static_cast<size_t>(_STD distance(_First, _Last)));
  	size_type _Off = _Insert_x(_Where, _Count);
  	_Copy_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last), begin() + static_cast<difference_type>(_Off));
  	}

There are candidates in <format> but not sure if it worth to untag dispatch them.