::is_integer) {\n if (src != src) {\n return NativeDestT{0};\n }\n if (src >=\n static_cast(std::numeric_limits::max())) {\n return std::numeric_limits::max();\n }\n if (src <=\n static_cast(std::numeric_limits::lowest())) {\n return std::numeric_limits::lowest();\n }\n }\n return static_cast(src);\n };\n\n NativeDestT* dest_data = static_cast(dst_base);\n for (const NativeSrcT& src : src_data) {\n *(dest_data++) = converter(src);\n }\n}\nvoid ConvertBetweenNativeTypes(absl::Span src_data,\n void* dst_base) {\n static_assert(!std::is_same_v);\n auto converter = [](NativeSrcT src) -> NativeDestT {\n // C++ [conv.bool]p1:\n // A prvalue of arithmetic [...] type can be converted to a prvalue of\n // type bool. A zero value [...] is converted to false; any other value is\n // converted to true.\n // C++ [conv.fpint]p1:\n // [...] The behavior is undefined if the truncated value cannot be\n // represented in the destination type.\n //\n // Using static_cast to convert a float to an integral type other than bool\n // may be undefined if the value's magnitude is too large or it is a NaN.\n // Let's choose saturating arithmetic as it captures the spirit of infinity\n // and arbitrarily map NaN to zero.\n if constexpr (!std::is_same_v &&\n !std::numeric_limits::is_integer &&\n std::numeric_limits::is_integer) {\n if (src != src) {\n return NativeDestT{0};\n }\n if (src >=\n static_cast(std::numeric_limits::max())) {\n return std::numeric_limits::max();\n }\n if (src <=\n static_cast(std::numeric_limits::lowest())) {\n return std::numeric_limits::lowest();\n }\n }\n return static_cast(src);\n };\n\n NativeDestT* dest_data = static_cast(dst_base);\n for (const NativeSrcT& src : src_data) {\n *(dest_data++) = converter(src);\n }\n}\nvoid ConvertBetweenNativeTypes(absl::Span src_data,\n void* dst_base) {\n static_assert(!std::is_same_v);\n auto converter = [](NativeSrcT src) -> NativeDestT {\n // C++ [conv.bool]p1:\n // A prvalue of arithmetic [...] type can be converted to a prvalue of\n // type bool. A zero value [...] is converted to false; any other value is\n // converted to true.\n // C++ [conv.fpint]p1:\n // [...] The behavior is undefined if the truncated value cannot be\n // represented in the destination type.\n //\n // Using static_cast to convert a float to an integral type other than bool\n // may be undefined if the value's magnitude is too large or it is a NaN.\n // Let's choose saturating arithmetic as it captures the spirit of infinity\n // and arbitrarily map NaN to zero.\n if constexpr (!std::is_same_v &&\n !std::numeric_limits::is_integer &&\n std::numeric_limits::is_integer) {\n if (src != src) {\n return NativeDestT{0};\n }\n if (src >=\n static_cast(std::numeric_limits::max())) {\n return std::numeric_limits::max();\n }\n if (src <=\n static_cast(std::numeric_limits::lowest())) {\n return std::numeric_limits::lowest();\n }\n }\n return static_cast(src);\n };\n\n NativeDestT* dest_data = static_cast(dst_base);\n for (const NativeSrcT& src : src_data) {\n *(dest_data++) = converter(src);\n }\n}\nvoid ConvertBetweenNativeTypes(absl::Span src_data,\n void* dst_base) {\n static_assert(!std::is_same_v);\n auto converter = [](NativeSrcT src) -> NativeDestT {\n // C++ [conv.bool]p1:\n // A prvalue of arithmetic [...] type can be converted to a prvalue of\n // type bool. A zero value [...] is converted to false; any other value is\n // converted to true.\n // C++ [conv.fpint]p1:\n // [...] The behavior is undefined if the truncated value cannot be\n // represented in the destination type.\n //\n // Using static_cast to convert a float to an integral type other than bool\n // may be undefined if the value's magnitude is too large or it is a NaN.\n // Let's choose saturating arithmetic as it captures the spirit of infinity\n // and arbitrarily map NaN to zero.\n if constexpr (!std::is_same_v &&\n !std::numeric_limits::is_integer &&\n std::numeric_limits::is_integer) {\n if (src != src) {\n return NativeDestT{0};\n }\n if (src >=\n static_cast(std::numeric_limits::max())) {\n return std::numeric_limits::max();\n }\n if (src <=\n static_cast(std::numeric_limits::lowest())) {\n return std::numeric_limits::lowest();\n }\n }\n return static_cast(src);\n };\n\n NativeDestT* dest_data = static_cast(dst_base);\n for (const NativeSrcT& src : src_data) {\n *(dest_data++) = converter(src);\n }\n}\nvoid ConvertBetweenNativeTypes(absl::Span src_data,\n void* dst_base) {\n static_assert(!std::is_same_v);\n auto converter = [](NativeSrcT src) -> NativeDestT {\n // C++ [conv.bool]p1:\n // A prvalue of arithmetic [...] type can be converted to a prvalue of\n // type bool. A zero value [...] is converted to false; any other value is\n // converted to true.\n // C++ [conv.fpint]p1:\n // [...] The behavior is undefined if the truncated value cannot be\n // represented in the destination type.\n //\n // Using static_cast to convert a float to an integral type other than bool\n // may be undefined if the value's magnitude is too large or it is a NaN.\n // Let's choose saturating arithmetic as it captures the spirit of infinity\n // and arbitrarily map NaN to zero.\n if constexpr (!std::is_same_v &&\n !std::numeric_limits::is_integer &&\n std::numeric_limits::is_integer) {\n if (src != src) {\n return NativeDestT{0};\n }\n if (src >=\n static_cast(std::numeric_limits::max())) {\n return std::numeric_limits::max();\n }\n if (src <=\n static_cast(std::numeric_limits::lowest())) {\n return std::numeric_limits::lowest();\n }\n }\n return static_cast(src);\n };\n\n NativeDestT* dest_data = static_cast(dst_base);\n for (const NativeSrcT& src : src_data) {\n *(dest_data++) = converter(src);\n }\n}\nvoid ConvertBetweenNativeTypes(absl::Span src_data,\n void* dst_base) {\n static_assert(!std::is_same_v);\n auto converter = [](NativeSrcT src) -> NativeDestT {\n // C++ [conv.bool]p1:\n // A prvalue of arithmetic [...] type can be converted to a prvalue of\n // type bool. A zero value [...] is converted to false; any other value is\n // converted to true.\n // C++ [conv.fpint]p1:\n // [...] The behavior is undefined if the truncated value cannot be\n // represented in the destination type.\n //\n // Using static_cast to convert a float to an integral type other than bool\n // may be undefined if the value's magnitude is too large or it is a NaN.\n // Let's choose saturating arithmetic as it captures the spirit of infinity\n // and arbitrarily map NaN to zero.\n if constexpr (!std::is_same_v &&\n !std::numeric_limits::is_integer &&\n std::numeric_limits::is_integer) {\n if (src != src) {\n return NativeDestT{0};\n }\n if (src >=\n static_cast(std::numeric_limits::max())) {\n return std::numeric_limits::max();\n }\n if (src <=\n static_cast(std::numeric_limits::lowest())) {\n return std::numeric_limits::lowest();\n }\n }\n return static_cast(src);\n };\n\n NativeDestT* dest_data = static_cast(dst_base);\n for (const NativeSrcT& src : src_data) {\n *(dest_data++) = converter(src);\n }\n}\nvoid ConvertBetweenNativeTypes(absl::Span src_data,\n void* dst_base) {\n static_assert(!std::is_same_v);\n auto converter = [](NativeSrcT src) -> NativeDestT {\n // C++ [conv.bool]p1:\n // A prvalue of arithmetic [...] type can be converted to a prvalue of\n // type bool. A zero value [...] is converted to false; any other value is\n // converted to true.\n // C++ [conv.fpint]p1:\n // [...] The behavior is undefined if the truncated value cannot be\n // represented in the destination type.\n //\n // Using static_cast to convert a float to an integral type other than bool\n // may be undefined if the value's magnitude is too large or it is a NaN.\n // Let's choose saturating arithmetic as it captures the spirit of infinity\n // and arbitrarily map NaN to zero.\n if constexpr (!std::is_same_v &&\n !std::numeric_limits::is_integer &&\n std::numeric_limits::is_integer) {\n if (src != src) {\n return NativeDestT{0};\n }\n if (src >=\n static_cast(std::numeric_limits::max())) {\n return std::numeric_limits::max();\n }\n if (src <=\n static_cast(std::numeric_limits::lowest())) {\n return std::numeric_limits::lowest();\n }\n }\n return static_cast(src);\n };\n\n NativeDestT* dest_data = static_cast(dst_base);\n for (const NativeSrcT& src : src_data) {\n *(dest_data++) = converter(src);\n }\n}\nvoid ConvertBetweenNativeTypes(absl::Span src_data,\n void* dst_base) {\n static_assert(!std::is_same_v);\n auto converter = [](NativeSrcT src) -> NativeDestT {\n // C++ [conv.bool]p1:\n // A prvalue of arithmetic [...] type can be converted to a prvalue of\n // type bool. A zero value [...] is converted to false; any other value is\n // converted to true.\n // C++ [conv.fpint]p1:\n // [...] The behavior is undefined if the truncated value cannot be\n // represented in the destination type.\n //\n // Using static_cast to convert a float to an integral type other than bool\n // may be undefined if the value's magnitude is too large or it is a NaN.\n // Let's choose saturating arithmetic as it captures the spirit of infinity\n // and arbitrarily map NaN to zero.\n if constexpr (!std::is_same_v &&\n !std::numeric_limits::is_integer &&\n std::numeric_limits::is_integer) {\n if (src != src) {\n return NativeDestT{0};\n }\n if (src >=\n static_cast(std::numeric_limits::max())) {\n return std::numeric_limits::max();\n }\n if (src <=\n static_cast(std::numeric_limits::lowest())) {\n return std::numeric_limits::lowest();\n }\n }\n return static_cast(src);\n };\n\n NativeDestT* dest_data = static_cast(dst_base);\n for (const NativeSrcT& src : src_data) {\n *(dest_data++) = converter(src);\n }\n}\nvoid ConvertBetweenNativeTypes(absl::Span src_data,\n void* dst_base) {\n static_assert(!std::is_same_v);\n auto converter = [](NativeSrcT src) -> NativeDestT {\n // C++ [conv.bool]p1:\n // A prvalue of arithmetic [...] type can be converted to a prvalue of\n // type bool. A zero value [...] is converted to false; any other value is\n // converted to true.\n // C++ [conv.fpint]p1:\n // [...] The behavior is undefined if the truncated value cannot be\n // represented in the destination type.\n //\n // Using static_cast to convert a float to an integral type other than bool\n // may be undefined if the value's magnitude is too large or it is a NaN.\n // Let's choose saturating arithmetic as it captures the spirit of infinity\n // and arbitrarily map NaN to zero.\n if constexpr (!std::is_same_v &&\n !std::numeric_limits::is_integer &&\n std::numeric_limits::is_integer) {\n if (src != src) {\n return NativeDestT{0};\n }\n if (src >=\n static_cast(std::numeric_limits::max())) {\n return std::numeric_limits::max();\n }\n if (src <=\n static_cast(std::numeric_limits::lowest())) {\n return std::numeric_limits::lowest();\n }\n }\n return static_cast(src);\n };\n\n NativeDestT* dest_data = static_cast(dst_base);\n for (const NativeSrcT& src : src_data) {\n *(dest_data++) = converter(src);\n }\n}\nvoid ConvertBetweenNativeTypes(absl::Span src_data,\n void* dst_base) {\n static_assert(!std::is_same_v);\n auto converter = [](NativeSrcT src) -> NativeDestT {\n // C++ [conv.bool]p1:\n // A prvalue of arithmetic [...] type can be converted to a prvalue of\n // type bool. A zero value [...] is converted to false; any other value is\n // converted to true.\n // C++ [conv.fpint]p1:\n // [...] The behavior is undefined if the truncated value cannot be\n // represented in the destination type.\n //\n // Using static_cast to convert a float to an integral type other than bool\n // may be undefined if the value's magnitude is too large or it is a NaN.\n // Let's choose saturating arithmetic as it captures the spirit of infinity\n // and arbitrarily map NaN to zero.\n if constexpr (!std::is_same_v &&\n !std::numeric_limits::is_integer &&\n std::numeric_limits::is_integer) {\n if (src != src) {\n return NativeDestT{0};\n }\n if (src >=\n static_cast(std::numeric_limits::max())) {\n return std::numeric_limits::max();\n }\n if (src <=\n static_cast(std::numeric_limits::lowest())) {\n return std::numeric_limits::lowest();\n }\n }\n return static_cast(src);\n };\n\n NativeDestT* dest_data = static_cast(dst_base);\n for (const NativeSrcT& src : src_data) {\n *(dest_data++) = converter(src);\n }\n}\nvoid ConvertBetweenNativeTypes(absl::Span src_data,\n void* dst_base) {\n static_assert(!std::is_same_v);\n auto converter = [](NativeSrcT src) -> NativeDestT {\n // C++ [conv.bool]p1:\n // A prvalue of arithmetic [...] type can be converted to a prvalue of\n // type bool. A zero value [...] is converted to false; any other value is\n // converted to true.\n // C++ [conv.fpint]p1:\n // [...] The behavior is undefined if the truncated value cannot be\n // represented in the destination type.\n //\n // Using static_cast to convert a float to an integral type other than bool\n // may be undefined if the value's magnitude is too large or it is a NaN.\n // Let's choose saturating arithmetic as it captures the spirit of infinity\n // and arbitrarily map NaN to zero.\n if constexpr (!std::is_same_v &&\n !std::numeric_limits::is_integer &&\n std::numeric_limits::is_integer) {\n if (src != src) {\n return NativeDestT{0};\n }\n if (src >=\n static_cast(std::numeric_limits::max())) {\n return std::numeric_limits::max();\n }\n if (src <=\n static_cast(std::numeric_limits::lowest())) {\n return std::numeric_limits::lowest();\n }\n }\n return static_cast(src);\n };\n\n NativeDestT* dest_data = static_cast(dst_base);\n for (const NativeSrcT& src : src_data) {\n *(dest_data++) = converter(src);\n }\n}\nvoid ConvertBetweenNativeTypes(absl::Span src_data,\n void* dst_base) {\n static_assert(!std::is_same_v);\n auto converter = [](NativeSrcT src) -> NativeDestT {\n // C++ [conv.bool]p1:\n // A prvalue of arithmetic [...] type can be converted to a prvalue of\n // type bool. A zero value [...] is converted to false; any other value is\n // converted to true.\n // C++ [conv.fpint]p1:\n // [...] The behavior is undefined if the truncated value cannot be\n // represented in the destination type.\n //\n // Using static_cast to convert a float to an integral type other than bool\n // may be undefined if the value's magnitude is too large or it is a NaN.\n // Let's choose saturating arithmetic as it captures the spirit of infinity\n // and arbitrarily map NaN to zero.\n if constexpr (!std::is_same_v &&\n !std::numeric_limits::is_integer &&\n std::numeric_limits::is_integer) {\n if (src != src) {\n return NativeDestT{0};\n }\n if (src >=\n static_cast(std::numeric_limits::max())) {\n return std::numeric_limits::max();\n }\n if (src <=\n static_cast(std::numeric_limits::lowest())) {\n return std::numeric_limits::lowest();\n }\n }\n return static_cast(src);\n };\n\n NativeDestT* dest_data = static_cast(dst_base);\n for (const NativeSrcT& src : src_data) {\n *(dest_data++) = converter(src);\n }\n}\nvoid ConvertBetweenNativeTypes(absl::Span src_data,\n void* dst_base) {\n static_assert(!std::is_same_v);\n auto converter = [](NativeSrcT src) -> NativeDestT {\n // C++ [conv.bool]p1:\n // A prvalue of arithmetic [...] type can be converted to a prvalue of\n // type bool. A zero value [...] is converted to false; any other value is\n // converted to true.\n // C++ [conv.fpint]p1:\n // [...] The behavior is undefined if the truncated value cannot be\n // represented in the destination type.\n //\n // Using static_cast to convert a float to an integral type other than bool\n // may be undefined if the value's magnitude is too large or it is a NaN.\n // Let's choose saturating arithmetic as it captures the spirit of infinity\n // and arbitrarily map NaN to zero.\n if constexpr (!std::is_same_v &&\n !std::numeric_limits::is_integer &&\n std::numeric_limits::is_integer) {\n if (src != src) {\n return NativeDestT{0};\n }\n if (src >=\n static_cast(std::numeric_limits::max())) {\n return std::numeric_limits::max();\n }\n if (src <=\n static_cast(std::numeric_limits::lowest())) {\n return std::numeric_limits::lowest();\n }\n }\n return static_cast(src);\n };\n\n NativeDestT* dest_data = static_cast(dst_base);\n for (const NativeSrcT& src : src_data) {\n *(dest_data++) = converter(src);\n }\n}\nvoid ConvertBetweenNativeTypes(absl::Span src_data,\n void* dst_base) {\n static_assert(!std::is_same_v);\n auto converter = [](NativeSrcT src) -> NativeDestT {\n // C++ [conv.bool]p1:\n // A prvalue of arithmetic [...] type can be converted to a prvalue of\n // type bool. A zero value [...] is converted to false; any other value is\n // converted to true.\n // C++ [conv.fpint]p1:\n // [...] The behavior is undefined if the truncated value cannot be\n // represented in the destination type.\n //\n // Using static_cast to convert a float to an integral type other than bool\n // may be undefined if the value's magnitude is too large or it is a NaN.\n // Let's choose saturating arithmetic as it captures the spirit of infinity\n // and arbitrarily map NaN to zero.\n if constexpr (!std::is_same_v &&\n !std::numeric_limits::is_integer &&\n std::numeric_limits::is_integer) {\n if (src != src) {\n return NativeDestT{0};\n }\n if (src >=\n static_cast(std::numeric_limits::max())) {\n return std::numeric_limits::max();\n }\n if (src <=\n static_cast(std::numeric_limits::lowest())) {\n return std::numeric_limits::lowest();\n }\n }\n return static_cast(src);\n };\n\n NativeDestT* dest_data = static_cast(dst_base);\n for (const NativeSrcT& src : src_data) {\n *(dest_data++) = converter(src);\n }\n}\nvoid ConvertBetweenNativeTypes(absl::Span src_data,\n void* dst_base) {\n static_assert(!std::is_same_v);\n auto converter = [](NativeSrcT src) -> NativeDestT {\n // C++ [conv.bool]p1:\n // A prvalue of arithmetic [...] type can be converted to a prvalue of\n // type bool. A zero value [...] is converted to false; any other value is\n // converted to true.\n // C++ [conv.fpint]p1:\n // [...] The behavior is undefined if the truncated value cannot be\n // represented in the destination type.\n //\n // Using static_cast to convert a float to an integral type other than bool\n // may be undefined if the value's magnitude is too large or it is a NaN.\n // Let's choose saturating arithmetic as it captures the spirit of infinity\n // and arbitrarily map NaN to zero.\n if constexpr (!std::is_same_v &&\n !std::numeric_limits::is_integer &&\n std::numeric_limits::is_integer) {\n if (src != src) {\n return NativeDestT{0};\n }\n if (src >=\n static_cast(std::numeric_limits::max())) {\n return std::numeric_limits::max();\n }\n if (src <=\n static_cast(std::numeric_limits::lowest())) {\n return std::numeric_limits::lowest();\n }\n }\n return static_cast(src);\n };\n\n NativeDestT* dest_data = static_cast(dst_base);\n for (const NativeSrcT& src : src_data) {\n *(dest_data++) = converter(src);\n }\n}\nvoid ConvertBetweenNativeTypes(absl::Span src_data,\n void* dst_base) {\n static_assert(!std::is_same_v);\n auto converter = [](NativeSrcT src) -> NativeDestT {\n // C++ [conv.bool]p1:\n // A prvalue of arithmetic [...] type can be converted to a prvalue of\n // type bool. A zero value [...] is converted to false; any other value is\n // converted to true.\n // C++ [conv.fpint]p1:\n // [...] The behavior is undefined if the truncated value cannot be\n // represented in the destination type.\n //\n // Using static_cast to convert a float to an integral type other than bool\n // may be undefined if the value's magnitude is too large or it is a NaN.\n // Let's choose saturating arithmetic as it captures the spirit of infinity\n // and arbitrarily map NaN to zero.\n if constexpr (!std::is_same_v &&\n !std::numeric_limits::is_integer &&\n std::numeric_limits::is_integer) {\n if (src != src) {\n return NativeDestT{0};\n }\n if (src >=\n static_cast(std::numeric_limits::max())) {\n return std::numeric_limits::max();\n }\n if (src <=\n static_cast(std::numeric_limits::lowest())) {\n return std::numeric_limits::lowest();\n }\n }\n return static_cast(src);\n };\n\n NativeDestT* dest_data = static_cast(dst_base);\n for (const NativeSrcT& src : src_data) {\n *(dest_data++) = converter(src);\n }\n}\nvoid ConvertBetweenNativeTypes(absl::Span src_data,\n void* dst_base) {\n static_assert(!std::is_same_v);\n auto converter = [](NativeSrcT src) -> NativeDestT {\n // C++ [conv.bool]p1:\n // A prvalue of arithmetic [...] type can be converted to a prvalue of\n // type bool. A zero value [...] is converted to false; any other value is\n // converted to true.\n // C++ [conv.fpint]p1:\n // [...] The behavior is undefined if the truncated value cannot be\n // represented in the destination type.\n //\n // Using static_cast to convert a float to an integral type other than bool\n // may be undefined if the value's magnitude is too large or it is a NaN.\n // Let's choose saturating arithmetic as it captures the spirit of infinity\n // and arbitrarily map NaN to zero.\n if constexpr (!std::is_same_v &&\n !std::numeric_limits::is_integer &&\n std::numeric_limits::is_integer) {\n if (src != src) {\n return NativeDestT{0};\n }\n if (src >=\n static_cast(std::numeric_limits::max())) {\n return std::numeric_limits::max();\n }\n if (src <=\n static_cast(std::numeric_limits::lowest())) {\n return std::numeric_limits::lowest();\n }\n }\n return static_cast(src);\n };\n\n NativeDestT* dest_data = static_cast(dst_base);\n for (const NativeSrcT& src : src_data) {\n *(dest_data++) = converter(src);\n }\n}\nvoid ConvertBetweenNativeTypes(absl::Span src_data,\n void* dst_base) {\n static_assert(!std::is_same_v);\n auto converter = [](NativeSrcT src) -> NativeDestT {\n // C++ [conv.bool]p1:\n // A prvalue of arithmetic [...] type can be converted to a prvalue of\n // type bool. A zero value [...] is converted to false; any other value is\n // converted to true.\n // C++ [conv.fpint]p1:\n // [...] The behavior is undefined if the truncated value cannot be\n // represented in the destination type.\n //\n // Using static_cast to convert a float to an integral type other than bool\n // may be undefined if the value's magnitude is too large or it is a NaN.\n // Let's choose saturating arithmetic as it captures the spirit of infinity\n // and arbitrarily map NaN to zero.\n if constexpr (!std::is_same_v &&\n !std::numeric_limits::is_integer &&\n std::numeric_limits::is_integer) {\n if (src != src) {\n return NativeDestT{0};\n }\n if (src >=\n static_cast(std::numeric_limits::max())) {\n return std::numeric_limits::max();\n }\n if (src <=\n static_cast(std::numeric_limits::lowest())) {\n return std::numeric_limits::lowest();\n }\n }\n return static_cast(src);\n };\n\n NativeDestT* dest_data = static_cast(dst_base);\n for (const NativeSrcT& src : src_data) {\n *(dest_data++) = converter(src);\n }\n}\nvoid ConvertBetweenNativeTypes(absl::Span src_data,\n void* dst_base) {\n static_assert(!std::is_same_v);\n auto converter = [](NativeSrcT src) -> NativeDestT {\n // C++ [conv.bool]p1:\n // A prvalue of arithmetic [...] type can be converted to a prvalue of\n // type bool. A zero value [...] is converted to false; any other value is\n // converted to true.\n // C++ [conv.fpint]p1:\n // [...] The behavior is undefined if the truncated value cannot be\n // represented in the destination type.\n //\n // Using static_cast to convert a float to an integral type other than bool\n // may be undefined if the value's magnitude is too large or it is a NaN.\n // Let's choose saturating arithmetic as it captures the spirit of infinity\n // and arbitrarily map NaN to zero.\n if constexpr (!std::is_same_v &&\n !std::numeric_limits::is_integer &&\n std::numeric_limits::is_integer) {\n if (src != src) {\n return NativeDestT{0};\n }\n if (src >=\n static_cast(std::numeric_limits::max())) {\n return std::numeric_limits::max();\n }\n if (src <=\n static_cast(std::numeric_limits::lowest())) {\n return std::numeric_limits::lowest();\n }\n }\n return static_cast(src);\n };\n\n NativeDestT* dest_data = static_cast(dst_base);\n for (const NativeSrcT& src : src_data) {\n *(dest_data++) = converter(src);\n }\n}\nvoid ConvertBetweenNativeTypes(absl::Span src_data,\n void* dst_base) {\n static_assert(!std::is_same_v);\n auto converter = [](NativeSrcT src) -> NativeDestT {\n // C++ [conv.bool]p1:\n // A prvalue of arithmetic [...] type can be converted to a prvalue of\n // type bool. A zero value [...] is converted to false; any other value is\n // converted to true.\n // C++ [conv.fpint]p1:\n // [...] The behavior is undefined if the truncated value cannot be\n // represented in the destination type.\n //\n // Using static_cast to convert a float to an integral type other than bool\n // may be undefined if the value's magnitude is too large or it is a NaN.\n // Let's choose saturating arithmetic as it captures the spirit of infinity\n // and arbitrarily map NaN to zero.\n if constexpr (!std::is_same_v &&\n !std::numeric_limits::is_integer &&\n std::numeric_limits::is_integer) {\n if (src != src) {\n return NativeDestT{0};\n }\n if (src >=\n static_cast(std::numeric_limits::max())) {\n return std::numeric_limits::max();\n }\n if (src <=\n static_cast(std::numeric_limits