C++ code:

namespace {

struct LoadU8 {
	typedef uint8_t type;

	static inline FORCE_INLINE __m256 load8(const uint8_t *ptr)
	{
		return _mm256_cvtepi32_ps(_mm256_cvtepu8_epi32(_mm_loadl_epi64((const __m128i *)ptr)));
	}
};

struct LoadU16 {
	typedef uint16_t type;

	static inline FORCE_INLINE __m256 load8(const uint16_t *ptr)
	{
		return _mm256_cvtepi32_ps(_mm256_cvtepu16_epi32(_mm_load_si128((const __m128i *)ptr)));
	}
};

struct LoadF16 {
	typedef uint16_t type;

	static inline FORCE_INLINE __m256 load8(const uint16_t *ptr)
	{
		return _mm256_cvtph_ps(_mm_load_si128((const __m128i *)ptr));
	}
};

struct LoadF32 {
	typedef float type;

	static inline FORCE_INLINE __m256 load8(const float *ptr)
	{
		return _mm256_load_ps(ptr);
	}
};

struct StoreU8 {
	typedef uint8_t type;

	static inline FORCE_INLINE void store16(uint8_t *ptr, __m256i x)
	{
		_mm_store_si128((__m128i *)ptr, mm256_cvtusepi16_epi8(x));
	}

	static inline FORCE_INLINE void store16_idxlo(uint8_t *ptr, __m256i x, unsigned idx)
	{
		mm_store_idxlo_epi8((__m128i *)ptr, mm256_cvtusepi16_epi8(x), idx);
	}

	static inline FORCE_INLINE void store16_idxhi(uint8_t *ptr, __m256i x, unsigned idx)
	{
		mm_store_idxhi_epi8((__m128i *)ptr, mm256_cvtusepi16_epi8(x), idx);
	}
};

struct StoreU16 {
	typedef uint16_t type;

	static inline FORCE_INLINE void store16(uint16_t *ptr, __m256i x) { _mm256_store_si256((__m256i *)ptr, x); }

	static inline FORCE_INLINE void store16_idxlo(uint16_t *ptr, __m256i x, unsigned idx) { mm256_store_idxlo_epi16((__m256i *)ptr, x, idx); }

	static inline FORCE_INLINE void store16_idxhi(uint16_t *ptr, __m256i x, unsigned idx) { mm256_store_idxhi_epi16((__m256i *)ptr, x, idx); }
};


template <class Load, class Store>
inline FORCE_INLINE void ordered_dither_avx2_impl(const float *dither, unsigned dither_offset, unsigned dither_mask,
                                                  const void *src, void *dst, float scale, float offset, unsigned bits, unsigned left, unsigned right)
{
	const typename Load::type *src_p = static_cast<const typename Load::type *>(src);
	typename Store::type *dst_p = static_cast<typename Store::type *>(dst);

	unsigned vec_left = ceil_n(left, 16);
	unsigned vec_right = floor_n(right, 16);

	const __m256 scale_ps = _mm256_set1_ps(scale);
	const __m256 offset_ps = _mm256_set1_ps(offset);
	const __m256i out_max = _mm256_set1_epi16(static_cast<uint16_t>((1 << bits) - 1));

#define XARGS dither, dither_offset, dither_mask, scale_ps, offset_ps, out_max
	if (left != vec_left) {
		__m256 lo = Load::load8(src_p + vec_left - 16 + 0);
		__m256 hi = Load::load8(src_p + vec_left - 16 + 8);
		__m256i x = ordered_dither_avx2_xiter(lo, hi, vec_left - 16, XARGS);
		Store::store16_idxhi(dst_p + vec_left - 16, x, left % 16);
	}
	for (unsigned j = vec_left; j < vec_right; j += 16) {
		__m256 lo = Load::load8(src_p + j + 0);
		__m256 hi = Load::load8(src_p + j + 8);
		__m256i x = ordered_dither_avx2_xiter(lo, hi, j, XARGS);
		Store::store16(dst_p + j, x);
	}
	if (right != vec_right) {
		__m256 lo = Load::load8(src_p + vec_right + 0);
		__m256 hi = Load::load8(src_p + vec_right + 8);
		__m256i x = ordered_dither_avx2_xiter(lo, hi, vec_right, XARGS);
		Store::store16_idxlo(dst_p + vec_right, x, right % 16);
	}
#undef XARGS
}

} // namespace