::data_)))[16]' may be used uninitialized [-Werror=maybe-uninitialized])

Debian Bug Tracking System Fri, 05 Sep 2025 12:21:23 -0700

Your message dated Fri, 05 Sep 2025 19:19:34 +0000
with message-id <[email protected]>
and subject line Bug#1114197: fixed in mapbox-variant 1.2.0-4
has caused the Debian Bug report #1114197,
regarding mapbox-variant: FTBFS: /usr/include/c++/15/bits/char_traits.h:352:16: 
error: '((const std::char_traits<char>::char_type*)((char*)&temp + 
offsetof(boost::variant<int, double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> > >,boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
>::storage_.boost::aligned_storage<32, 
8>::<unnamed>.boost::detail::aligned_storage::aligned_storage_imp<32, 
8>::data_)))[16]' may be used uninitialized [-Werror=maybe-uninitialized]
to be marked as done.


This means that you claim that the problem has been dealt with.
If this is not the case it is now your responsibility to reopen the
Bug report if necessary, and/or fix the problem forthwith.

(NB: If you are a system administrator and have no idea what this
message is talking about, this may indicate a serious mail system
misconfiguration somewhere. Please contact [email protected]
immediately.)


-- 
1114197: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=1114197
Debian Bug Tracking System
Contact [email protected] with problems

--- Begin Message ---

Package: src:mapbox-variant
Version: 1.2.0-3
Severity: serious
Tags: ftbfs forky sid

Dear maintainer:

During a rebuild of all packages in unstable, your package failed to build.

Below you will find how the build ends (probably the most relevant part,
but not necessarily). If required, the full build log is available here:

https://people.debian.org/~sanvila/build-logs/202509/

About the archive rebuild: The build was made on virtual machines from AWS,
using sbuild and a reduced chroot with only build-essential packages.

If you could not reproduce the bug please contact me privately, as I
am willing to provide ssh access to a virtual machine where the bug is
fully reproducible.

If this is really a bug in one of the build-depends, please use
reassign and add an affects on src:mapbox-variant, so that this is still
visible in the BTS web page for this package.

Thanks.

--------------------------------------------------------------------------------
[...]
 debian/rules clean
dh clean
   dh_auto_clean
        make -j2 clean
make[1]: Entering directory '/<<PKGBUILDDIR>>'
rm -rf ./out
rm -rf *.dSYM
rm -f unit.gc*
rm -f *gcov
rm -f test/unit.gc*
rm -f test/*gcov
rm -f *.gcda *.gcno
make[1]: Leaving directory '/<<PKGBUILDDIR>>'
   dh_clean
 debian/rules binary
dh binary
   dh_update_autotools_config
   dh_autoreconf
   dh_auto_configure
   dh_auto_build
        make -j2 "INSTALL=install --strip-program=true"
make[1]: Entering directory '/<<PKGBUILDDIR>>'
mkdir -p ./out
mkdir -p ./out
g++ -o out/bench-variant test/bench_variant.cpp -I./include -isystem 
test/include -std=c++11 -Werror -Wall -Wextra -pedantic -Wformat=2 
-Wsign-conversion -Wshadow -Wunused-parameter -O3 -DNDEBUG -march=native 
-DSINGLE_THREADED -fvisibility-inlines-hidden -fvisibility=hidden -g -O2 
-ffile-prefix-map=/<<PKGBUILDDIR>>=. -fstack-protector-strong 
-fstack-clash-protection -Wformat -Werror=format-security -fcf-protection 
-pthread -Wl,-z,relro 
g++ -o out/unique_ptr_test test/unique_ptr_test.cpp -I./include -isystem 
test/include -std=c++11 -Werror -Wall -Wextra -pedantic -Wformat=2 
-Wsign-conversion -Wshadow -Wunused-parameter -O3 -DNDEBUG -march=native 
-DSINGLE_THREADED -fvisibility-inlines-hidden -fvisibility=hidden -g -O2 
-ffile-prefix-map=/<<PKGBUILDDIR>>=. -fstack-protector-strong 
-fstack-clash-protection -Wformat -Werror=format-security -fcf-protection 
-pthread -Wl,-z,relro 
mkdir -p ./out
g++ -o out/recursive_wrapper_test test/recursive_wrapper_test.cpp -I./include 
-isystem test/include -std=c++11 -Werror -Wall -Wextra -pedantic -Wformat=2 
-Wsign-conversion -Wshadow -Wunused-parameter -O3 -DNDEBUG -march=native 
-DSINGLE_THREADED -fvisibility-inlines-hidden -fvisibility=hidden -g -O2 
-ffile-prefix-map=/<<PKGBUILDDIR>>=. -fstack-protector-strong 
-fstack-clash-protection -Wformat -Werror=format-security -fcf-protection 
-pthread -Wl,-z,relro 
In file included from /usr/include/c++/15/ios:44,
                 from /usr/include/c++/15/bits/ostream.h:43,
                 from /usr/include/c++/15/ostream:42,
                 from /usr/include/c++/15/iostream:43,
                 from test/bench_variant.cpp:3:
In static member function âstatic void 
std::char_traits<char>::assign(char_type&, const char_type&)â,
    inlined from âstatic void std::__cxx11::basic_string<_CharT, _Traits, 
_Alloc>::_S_copy(_CharT*, const _CharT*, size_type) [with _CharT = char; 
_Traits = std::char_traits<char>; _Alloc = std::allocator<char>]â at 
/usr/include/c++/15/bits/basic_string.h:451:23,
    inlined from âstd::__cxx11::basic_string<_CharT, _Traits, _Alloc>& 
std::__cxx11::basic_string<_CharT, _Traits, 
_Alloc>::operator=(std::__cxx11::basic_string<_CharT, _Traits, _Alloc>&&) [with 
_CharT = char; _Traits = std::char_traits<char>; _Alloc = 
std::allocator<char>]â at /usr/include/c++/15/bits/basic_string.h:969:18,
    inlined from âvoid 
boost::detail::variant::move_storage::internal_visit(T&, int) const [with T = 
std::__cxx11::basic_string<char>]â at 
/usr/include/boost/variant/variant.hpp:597:21,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl_invoke_impl(int, Visitor&, VoidPtrCV, 
T*, mpl_::true_) [with Visitor = move_storage; VoidPtrCV = void*; T = 
std::__cxx11::basic_string<char>]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:117:34,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl_invoke(int, Visitor&, VoidPtrCV, T*, 
NoBackupFlag, int) [with Visitor = move_storage; VoidPtrCV = void*; T = 
std::__cxx11::basic_string<char>; NoBackupFlag = boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
>::has_fallback_type_]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:157:41,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl(int, int, Visitor&, VoidPtrCV, 
mpl_::false_, NoBackupFlag, Which*, step0*) [with Which = mpl_::int_<0>; step0 
= visitation_impl_step<boost::mpl::l_iter<boost::mpl::l_item<mpl_::long_<3>, 
int, boost::mpl::l_item<mpl_::long_<2>, double, 
boost::mpl::l_item<mpl_::long_<1>, std::__cxx11::basic_string<char>, 
boost::mpl::l_end> > > >, boost::mpl::l_iter<boost::mpl::l_end> >; Visitor = 
move_storage; VoidPtrCV = void*; NoBackupFlag = boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
>::has_fallback_type_]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:238:5,
    inlined from âstatic typename Visitor::result_type boost::variant<T0, 
TN>::internal_apply_visitor_impl(int, int, Visitor&, VoidPtrCV) [with Visitor = 
boost::detail::variant::move_storage; VoidPtrCV = void*; T0_ = int; TN = 
{double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> >}]â at /usr/include/boost/variant/variant.hpp:2338:48,
    inlined from âtypename Visitor::result_type boost::variant<T0, 
TN>::internal_apply_visitor(Visitor&) [with Visitor = 
boost::detail::variant::move_storage; T0_ = int; TN = {double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> 
>}]â at /usr/include/boost/variant/variant.hpp:2350:43,
    inlined from âvoid boost::variant<T0, 
TN>::variant_assign(boost::variant<T0, TN>&&) [with T0_ = int; TN = {double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> 
>}]â at /usr/include/boost/variant/variant.hpp:2081:41,
    inlined from âvoid boost::variant<T0, TN>::assign(const T&) [with T = 
double; T0_ = int; TN = {double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> >}]â at 
/usr/include/boost/variant/variant.hpp:2108:27,
    inlined from âvoid boost::variant<T0, TN>::assign(const T&) [with T = 
double; T0_ = int; TN = {double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> >}]â at 
/usr/include/boost/variant/variant.hpp:2095:10,
    inlined from âtypename boost::enable_if<boost::mpl::or_< 
[too-long-redacted] st/variant/variant.hpp:2160:15,
    inlined from âvoid dummy<V>::operator()(T&&) const [with T = const 
double&; V = boost::variant<int, double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> > >]â at 
test/bench_variant.cpp:63:12,
    inlined from âtypename boost::disable_if_c<(MoveSemantics && 
boost::is_same<Value2, Value2>::value), typename Visitor::result_type>::type 
boost::detail::variant::invoke_visitor<Visitor, 
MoveSemantics>::internal_visit(T&&, int) [with T = const double&; Visitor = 
dummy<boost::variant<int, double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> > > >; bool MoveSemantics = 
false]â at /usr/include/boost/variant/variant.hpp:1028:24,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl_invoke_impl(int, Visitor&, VoidPtrCV, 
T*, mpl_::true_) [with Visitor = invoke_visitor<dummy<boost::variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > > >, false>; VoidPtrCV = const void*; T = double]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:117:34,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl_invoke(int, Visitor&, VoidPtrCV, T*, 
NoBackupFlag, int) [with Visitor = invoke_visitor<dummy<boost::variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > > >, false>; VoidPtrCV = const void*; T = double; 
NoBackupFlag = boost::variant<int, double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> > >::has_fallback_type_]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:157:41,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl(int, int, Visitor&, VoidPtrCV, 
mpl_::false_, NoBackupFlag, Which*, step0*) [with Which = mpl_::int_<0>; step0 
= visitation_impl_step<boost::mpl::l_iter<boost::mpl::l_item<mpl_::long_<3>, 
int, boost::mpl::l_item<mpl_::long_<2>, double, 
boost::mpl::l_item<mpl_::long_<1>, std::__cxx11::basic_string<char>, 
boost::mpl::l_end> > > >, boost::mpl::l_iter<boost::mpl::l_end> >; Visitor = 
invoke_visitor<dummy<boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
> >, false>; VoidPtrCV = const void*; NoBackupFlag = boost::variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > >::has_fallback_type_]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:238:5,
    inlined from âstatic typename Visitor::result_type boost::variant<T0, 
TN>::internal_apply_visitor_impl(int, int, Visitor&, VoidPtrCV) [with Visitor = 
boost::detail::variant::invoke_visitor<dummy<boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
> >, false>; VoidPtrCV = const void*; T0_ = int; TN = {double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> 
>}]â at /usr/include/boost/variant/variant.hpp:2338:48,
    inlined from âtypename Visitor::result_type boost::variant<T0, 
TN>::internal_apply_visitor(Visitor&) const [with Visitor = 
boost::detail::variant::invoke_visitor<dummy<boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
> >, false>; T0_ = int; TN = {double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> >}]â at 
/usr/include/boost/variant/variant.hpp:2359:43,
    inlined from âtypename Visitor::result_type boost::variant<T0, 
TN>::apply_visitor(Visitor&) const & [with Visitor = dummy<boost::variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > > >; T0_ = int; TN = {double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> 
>}]â at /usr/include/boost/variant/variant.hpp:2405:44,
    inlined from âtypename Visitor::result_type 
boost::apply_visitor(Visitor&, Visitable&&) [with Visitor = dummy<variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > > >; Visitable = const variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
>&]â at /usr/include/boost/variant/detail/apply_visitor_unary.hpp:48:64,
    inlined from âvoid run_boost_test(std::size_t)â at 
test/bench_variant.cpp:98:29:
/usr/include/c++/15/bits/char_traits.h:352:16: error: â((const 
std::char_traits<char>::char_type*)((char*)&temp + offsetof(boost::variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > >,boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
>::storage_.boost::aligned_storage<32, 
8>::<unnamed>.boost::detail::aligned_storage::aligned_storage_imp<32, 
8>::data_)))[16]â may be used uninitialized [-Werror=maybe-uninitialized]
  352 |         __c1 = __c2;
      |                ^~~~
In file included from /usr/include/boost/variant.hpp:17,
                 from test/bench_variant.cpp:12:
/usr/include/boost/variant/variant.hpp: In function âvoid 
run_boost_test(std::size_t)â:
/usr/include/boost/variant/variant.hpp:2107:21: note: âtempâ declared here
 2107 |             variant temp(rhs);
      |                     ^~~~
In file included from /usr/include/c++/15/string:56,
                 from /usr/include/c++/15/bits/locale_classes.h:42,
                 from /usr/include/c++/15/bits/ios_base.h:43,
                 from /usr/include/c++/15/ios:46:
In member function âstd::__cxx11::basic_string<_CharT, _Traits, 
_Alloc>::size_type std::__cxx11::basic_string<_CharT, _Traits, _Alloc>::size() 
const [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = 
std::allocator<char>]â,
    inlined from âstd::__cxx11::basic_string<_CharT, _Traits, 
_Alloc>::size_type std::__cxx11::basic_string<_CharT, _Traits, 
_Alloc>::length() const [with _CharT = char; _Traits = std::char_traits<char>; 
_Alloc = std::allocator<char>]â at 
/usr/include/c++/15/bits/basic_string.h:1176:20,
    inlined from âstd::__cxx11::basic_string<_CharT, _Traits, _Alloc>& 
std::__cxx11::basic_string<_CharT, _Traits, 
_Alloc>::operator=(std::__cxx11::basic_string<_CharT, _Traits, _Alloc>&&) [with 
_CharT = char; _Traits = std::char_traits<char>; _Alloc = 
std::allocator<char>]â at /usr/include/c++/15/bits/basic_string.h:991:15,
    inlined from âvoid 
boost::detail::variant::move_storage::internal_visit(T&, int) const [with T = 
std::__cxx11::basic_string<char>]â at 
/usr/include/boost/variant/variant.hpp:597:21,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl_invoke_impl(int, Visitor&, VoidPtrCV, 
T*, mpl_::true_) [with Visitor = move_storage; VoidPtrCV = void*; T = 
std::__cxx11::basic_string<char>]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:117:34,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl_invoke(int, Visitor&, VoidPtrCV, T*, 
NoBackupFlag, int) [with Visitor = move_storage; VoidPtrCV = void*; T = 
std::__cxx11::basic_string<char>; NoBackupFlag = boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
>::has_fallback_type_]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:157:41,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl(int, int, Visitor&, VoidPtrCV, 
mpl_::false_, NoBackupFlag, Which*, step0*) [with Which = mpl_::int_<0>; step0 
= visitation_impl_step<boost::mpl::l_iter<boost::mpl::l_item<mpl_::long_<3>, 
int, boost::mpl::l_item<mpl_::long_<2>, double, 
boost::mpl::l_item<mpl_::long_<1>, std::__cxx11::basic_string<char>, 
boost::mpl::l_end> > > >, boost::mpl::l_iter<boost::mpl::l_end> >; Visitor = 
move_storage; VoidPtrCV = void*; NoBackupFlag = boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
>::has_fallback_type_]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:238:5,
    inlined from âstatic typename Visitor::result_type boost::variant<T0, 
TN>::internal_apply_visitor_impl(int, int, Visitor&, VoidPtrCV) [with Visitor = 
boost::detail::variant::move_storage; VoidPtrCV = void*; T0_ = int; TN = 
{double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> >}]â at /usr/include/boost/variant/variant.hpp:2338:48,
    inlined from âtypename Visitor::result_type boost::variant<T0, 
TN>::internal_apply_visitor(Visitor&) [with Visitor = 
boost::detail::variant::move_storage; T0_ = int; TN = {double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> 
>}]â at /usr/include/boost/variant/variant.hpp:2350:43,
    inlined from âvoid boost::variant<T0, 
TN>::variant_assign(boost::variant<T0, TN>&&) [with T0_ = int; TN = {double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> 
>}]â at /usr/include/boost/variant/variant.hpp:2081:41,
    inlined from âvoid boost::variant<T0, TN>::assign(const T&) [with T = 
double; T0_ = int; TN = {double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> >}]â at 
/usr/include/boost/variant/variant.hpp:2108:27,
    inlined from âvoid boost::variant<T0, TN>::assign(const T&) [with T = 
double; T0_ = int; TN = {double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> >}]â at 
/usr/include/boost/variant/variant.hpp:2095:10,
    inlined from âtypename boost::enable_if<boost::mpl::or_< 
[too-long-redacted] st/variant/variant.hpp:2160:15,
    inlined from âvoid dummy<V>::operator()(T&&) const [with T = const 
double&; V = boost::variant<int, double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> > >]â at 
test/bench_variant.cpp:63:12,
    inlined from âtypename boost::disable_if_c<(MoveSemantics && 
boost::is_same<Value2, Value2>::value), typename Visitor::result_type>::type 
boost::detail::variant::invoke_visitor<Visitor, 
MoveSemantics>::internal_visit(T&&, int) [with T = const double&; Visitor = 
dummy<boost::variant<int, double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> > > >; bool MoveSemantics = 
false]â at /usr/include/boost/variant/variant.hpp:1028:24,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl_invoke_impl(int, Visitor&, VoidPtrCV, 
T*, mpl_::true_) [with Visitor = invoke_visitor<dummy<boost::variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > > >, false>; VoidPtrCV = const void*; T = double]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:117:34,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl_invoke(int, Visitor&, VoidPtrCV, T*, 
NoBackupFlag, int) [with Visitor = invoke_visitor<dummy<boost::variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > > >, false>; VoidPtrCV = const void*; T = double; 
NoBackupFlag = boost::variant<int, double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> > >::has_fallback_type_]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:157:41,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl(int, int, Visitor&, VoidPtrCV, 
mpl_::false_, NoBackupFlag, Which*, step0*) [with Which = mpl_::int_<0>; step0 
= visitation_impl_step<boost::mpl::l_iter<boost::mpl::l_item<mpl_::long_<3>, 
int, boost::mpl::l_item<mpl_::long_<2>, double, 
boost::mpl::l_item<mpl_::long_<1>, std::__cxx11::basic_string<char>, 
boost::mpl::l_end> > > >, boost::mpl::l_iter<boost::mpl::l_end> >; Visitor = 
invoke_visitor<dummy<boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
> >, false>; VoidPtrCV = const void*; NoBackupFlag = boost::variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > >::has_fallback_type_]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:238:5,
    inlined from âstatic typename Visitor::result_type boost::variant<T0, 
TN>::internal_apply_visitor_impl(int, int, Visitor&, VoidPtrCV) [with Visitor = 
boost::detail::variant::invoke_visitor<dummy<boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
> >, false>; VoidPtrCV = const void*; T0_ = int; TN = {double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> 
>}]â at /usr/include/boost/variant/variant.hpp:2338:48,
    inlined from âtypename Visitor::result_type boost::variant<T0, 
TN>::internal_apply_visitor(Visitor&) const [with Visitor = 
boost::detail::variant::invoke_visitor<dummy<boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
> >, false>; T0_ = int; TN = {double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> >}]â at 
/usr/include/boost/variant/variant.hpp:2359:43,
    inlined from âtypename Visitor::result_type boost::variant<T0, 
TN>::apply_visitor(Visitor&) const & [with Visitor = dummy<boost::variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > > >; T0_ = int; TN = {double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> 
>}]â at /usr/include/boost/variant/variant.hpp:2405:44,
    inlined from âtypename Visitor::result_type 
boost::apply_visitor(Visitor&, Visitable&&) [with Visitor = dummy<variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > > >; Visitable = const variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
>&]â at /usr/include/boost/variant/detail/apply_visitor_unary.hpp:48:64,
    inlined from âvoid run_boost_test(std::size_t)â at 
test/bench_variant.cpp:98:29:
/usr/include/c++/15/bits/basic_string.h:1165:19: error: â*(const 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> 
>*)((char*)&temp + offsetof(boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
>,boost::variant<int, double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> > 
>::storage_.boost::aligned_storage<32, 
8>::<unnamed>.boost::detail::aligned_storage::aligned_storage_imp<32, 
8>::data_)).std::__cxx11::basic_string<char>::_M_string_lengthâ may be used 
uninitialized [-Werror=maybe-uninitialized]
 1165 |         size_type __sz = _M_string_length;
      |                   ^~~~
/usr/include/boost/variant/variant.hpp: In function âvoid 
run_boost_test(std::size_t)â:
/usr/include/boost/variant/variant.hpp:2107:21: note: âtempâ declared here
 2107 |             variant temp(rhs);
      |                     ^~~~
In member function âstd::__cxx11::basic_string<_CharT, _Traits, _Alloc>& 
std::__cxx11::basic_string<_CharT, _Traits, 
_Alloc>::operator=(std::__cxx11::basic_string<_CharT, _Traits, _Alloc>&&) [with 
_CharT = char; _Traits = std::char_traits<char>; _Alloc = 
std::allocator<char>]â,
    inlined from âvoid 
boost::detail::variant::move_storage::internal_visit(T&, int) const [with T = 
std::__cxx11::basic_string<char>]â at 
/usr/include/boost/variant/variant.hpp:597:21,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl_invoke_impl(int, Visitor&, VoidPtrCV, 
T*, mpl_::true_) [with Visitor = move_storage; VoidPtrCV = void*; T = 
std::__cxx11::basic_string<char>]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:117:34,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl_invoke(int, Visitor&, VoidPtrCV, T*, 
NoBackupFlag, int) [with Visitor = move_storage; VoidPtrCV = void*; T = 
std::__cxx11::basic_string<char>; NoBackupFlag = boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
>::has_fallback_type_]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:157:41,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl(int, int, Visitor&, VoidPtrCV, 
mpl_::false_, NoBackupFlag, Which*, step0*) [with Which = mpl_::int_<0>; step0 
= visitation_impl_step<boost::mpl::l_iter<boost::mpl::l_item<mpl_::long_<3>, 
int, boost::mpl::l_item<mpl_::long_<2>, double, 
boost::mpl::l_item<mpl_::long_<1>, std::__cxx11::basic_string<char>, 
boost::mpl::l_end> > > >, boost::mpl::l_iter<boost::mpl::l_end> >; Visitor = 
move_storage; VoidPtrCV = void*; NoBackupFlag = boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
>::has_fallback_type_]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:238:5,
    inlined from âstatic typename Visitor::result_type boost::variant<T0, 
TN>::internal_apply_visitor_impl(int, int, Visitor&, VoidPtrCV) [with Visitor = 
boost::detail::variant::move_storage; VoidPtrCV = void*; T0_ = int; TN = 
{double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> >}]â at /usr/include/boost/variant/variant.hpp:2338:48,
    inlined from âtypename Visitor::result_type boost::variant<T0, 
TN>::internal_apply_visitor(Visitor&) [with Visitor = 
boost::detail::variant::move_storage; T0_ = int; TN = {double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> 
>}]â at /usr/include/boost/variant/variant.hpp:2350:43,
    inlined from âvoid boost::variant<T0, 
TN>::variant_assign(boost::variant<T0, TN>&&) [with T0_ = int; TN = {double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> 
>}]â at /usr/include/boost/variant/variant.hpp:2081:41,
    inlined from âvoid boost::variant<T0, TN>::assign(const T&) [with T = 
double; T0_ = int; TN = {double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> >}]â at 
/usr/include/boost/variant/variant.hpp:2108:27,
    inlined from âvoid boost::variant<T0, TN>::assign(const T&) [with T = 
double; T0_ = int; TN = {double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> >}]â at 
/usr/include/boost/variant/variant.hpp:2095:10,
    inlined from âtypename boost::enable_if<boost::mpl::or_< 
[too-long-redacted] st/variant/variant.hpp:2160:15,
    inlined from âvoid dummy<V>::operator()(T&&) const [with T = const 
double&; V = boost::variant<int, double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> > >]â at 
test/bench_variant.cpp:63:12,
    inlined from âtypename boost::disable_if_c<(MoveSemantics && 
boost::is_same<Value2, Value2>::value), typename Visitor::result_type>::type 
boost::detail::variant::invoke_visitor<Visitor, 
MoveSemantics>::internal_visit(T&&, int) [with T = const double&; Visitor = 
dummy<boost::variant<int, double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> > > >; bool MoveSemantics = 
false]â at /usr/include/boost/variant/variant.hpp:1028:24,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl_invoke_impl(int, Visitor&, VoidPtrCV, 
T*, mpl_::true_) [with Visitor = invoke_visitor<dummy<boost::variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > > >, false>; VoidPtrCV = const void*; T = double]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:117:34,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl_invoke(int, Visitor&, VoidPtrCV, T*, 
NoBackupFlag, int) [with Visitor = invoke_visitor<dummy<boost::variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > > >, false>; VoidPtrCV = const void*; T = double; 
NoBackupFlag = boost::variant<int, double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> > >::has_fallback_type_]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:157:41,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl(int, int, Visitor&, VoidPtrCV, 
mpl_::false_, NoBackupFlag, Which*, step0*) [with Which = mpl_::int_<0>; step0 
= visitation_impl_step<boost::mpl::l_iter<boost::mpl::l_item<mpl_::long_<3>, 
int, boost::mpl::l_item<mpl_::long_<2>, double, 
boost::mpl::l_item<mpl_::long_<1>, std::__cxx11::basic_string<char>, 
boost::mpl::l_end> > > >, boost::mpl::l_iter<boost::mpl::l_end> >; Visitor = 
invoke_visitor<dummy<boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
> >, false>; VoidPtrCV = const void*; NoBackupFlag = boost::variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > >::has_fallback_type_]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:238:5,
    inlined from âstatic typename Visitor::result_type boost::variant<T0, 
TN>::internal_apply_visitor_impl(int, int, Visitor&, VoidPtrCV) [with Visitor = 
boost::detail::variant::invoke_visitor<dummy<boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
> >, false>; VoidPtrCV = const void*; T0_ = int; TN = {double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> 
>}]â at /usr/include/boost/variant/variant.hpp:2338:48,
    inlined from âtypename Visitor::result_type boost::variant<T0, 
TN>::internal_apply_visitor(Visitor&) const [with Visitor = 
boost::detail::variant::invoke_visitor<dummy<boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
> >, false>; T0_ = int; TN = {double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> >}]â at 
/usr/include/boost/variant/variant.hpp:2359:43,
    inlined from âtypename Visitor::result_type boost::variant<T0, 
TN>::apply_visitor(Visitor&) const & [with Visitor = dummy<boost::variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > > >; T0_ = int; TN = {double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> 
>}]â at /usr/include/boost/variant/variant.hpp:2405:44,
    inlined from âtypename Visitor::result_type 
boost::apply_visitor(Visitor&, Visitable&&) [with Visitor = dummy<variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > > >; Visitable = const variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
>&]â at /usr/include/boost/variant/detail/apply_visitor_unary.hpp:48:64,
    inlined from âvoid run_boost_test(std::size_t)â at 
test/bench_variant.cpp:98:29:
/usr/include/c++/15/bits/basic_string.h:992:24: error: 
â*(std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> >*)((char*)&temp + offsetof(boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
>,boost::variant<int, double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> > 
>::storage_.boost::aligned_storage<32, 
8>::<unnamed>.boost::detail::aligned_storage::aligned_storage_imp<32, 
8>::data_)).std::__cxx11::basic_string<char>::<anonymous>.std::__cxx11::basic_string<char>::<unnamed
 union>::_M_allocated_capacityâ may be used uninitialized 
[-Werror=maybe-uninitialized]
  992 |             _M_capacity(__str._M_allocated_capacity);
      |             ~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/boost/variant/variant.hpp: In function âvoid 
run_boost_test(std::size_t)â:
/usr/include/boost/variant/variant.hpp:2107:21: note: âtempâ declared here
 2107 |             variant temp(rhs);
      |                     ^~~~
In member function âstd::__cxx11::basic_string<_CharT, _Traits, _Alloc>& 
std::__cxx11::basic_string<_CharT, _Traits, 
_Alloc>::operator=(std::__cxx11::basic_string<_CharT, _Traits, _Alloc>&&) [with 
_CharT = char; _Traits = std::char_traits<char>; _Alloc = 
std::allocator<char>]â,
    inlined from âvoid 
boost::detail::variant::move_storage::internal_visit(T&, int) const [with T = 
std::__cxx11::basic_string<char>]â at 
/usr/include/boost/variant/variant.hpp:597:21,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl_invoke_impl(int, Visitor&, VoidPtrCV, 
T*, mpl_::true_) [with Visitor = move_storage; VoidPtrCV = void*; T = 
std::__cxx11::basic_string<char>]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:117:34,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl_invoke(int, Visitor&, VoidPtrCV, T*, 
NoBackupFlag, int) [with Visitor = move_storage; VoidPtrCV = void*; T = 
std::__cxx11::basic_string<char>; NoBackupFlag = boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
>::has_fallback_type_]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:157:41,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl(int, int, Visitor&, VoidPtrCV, 
mpl_::false_, NoBackupFlag, Which*, step0*) [with Which = mpl_::int_<0>; step0 
= visitation_impl_step<boost::mpl::l_iter<boost::mpl::l_item<mpl_::long_<3>, 
int, boost::mpl::l_item<mpl_::long_<2>, double, 
boost::mpl::l_item<mpl_::long_<1>, std::__cxx11::basic_string<char>, 
boost::mpl::l_end> > > >, boost::mpl::l_iter<boost::mpl::l_end> >; Visitor = 
move_storage; VoidPtrCV = void*; NoBackupFlag = boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
>::has_fallback_type_]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:238:5,
    inlined from âstatic typename Visitor::result_type boost::variant<T0, 
TN>::internal_apply_visitor_impl(int, int, Visitor&, VoidPtrCV) [with Visitor = 
boost::detail::variant::move_storage; VoidPtrCV = void*; T0_ = int; TN = 
{double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> >}]â at /usr/include/boost/variant/variant.hpp:2338:48,
    inlined from âtypename Visitor::result_type boost::variant<T0, 
TN>::internal_apply_visitor(Visitor&) [with Visitor = 
boost::detail::variant::move_storage; T0_ = int; TN = {double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> 
>}]â at /usr/include/boost/variant/variant.hpp:2350:43,
    inlined from âvoid boost::variant<T0, 
TN>::variant_assign(boost::variant<T0, TN>&&) [with T0_ = int; TN = {double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> 
>}]â at /usr/include/boost/variant/variant.hpp:2081:41,
    inlined from âvoid boost::variant<T0, TN>::assign(const T&) [with T = 
double; T0_ = int; TN = {double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> >}]â at 
/usr/include/boost/variant/variant.hpp:2108:27,
    inlined from âvoid boost::variant<T0, TN>::assign(const T&) [with T = 
double; T0_ = int; TN = {double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> >}]â at 
/usr/include/boost/variant/variant.hpp:2095:10,
    inlined from âtypename boost::enable_if<boost::mpl::or_< 
[too-long-redacted] st/variant/variant.hpp:2160:15,
    inlined from âvoid dummy<V>::operator()(T&&) const [with T = const 
double&; V = boost::variant<int, double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> > >]â at 
test/bench_variant.cpp:63:12,
    inlined from âtypename boost::disable_if_c<(MoveSemantics && 
boost::is_same<Value2, Value2>::value), typename Visitor::result_type>::type 
boost::detail::variant::invoke_visitor<Visitor, 
MoveSemantics>::internal_visit(T&&, int) [with T = const double&; Visitor = 
dummy<boost::variant<int, double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> > > >; bool MoveSemantics = 
false]â at /usr/include/boost/variant/variant.hpp:1028:24,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl_invoke_impl(int, Visitor&, VoidPtrCV, 
T*, mpl_::true_) [with Visitor = invoke_visitor<dummy<boost::variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > > >, false>; VoidPtrCV = const void*; T = double]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:117:34,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl_invoke(int, Visitor&, VoidPtrCV, T*, 
NoBackupFlag, int) [with Visitor = invoke_visitor<dummy<boost::variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > > >, false>; VoidPtrCV = const void*; T = double; 
NoBackupFlag = boost::variant<int, double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> > >::has_fallback_type_]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:157:41,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl(int, int, Visitor&, VoidPtrCV, 
mpl_::false_, NoBackupFlag, Which*, step0*) [with Which = mpl_::int_<0>; step0 
= visitation_impl_step<boost::mpl::l_iter<boost::mpl::l_item<mpl_::long_<3>, 
int, boost::mpl::l_item<mpl_::long_<2>, double, 
boost::mpl::l_item<mpl_::long_<1>, std::__cxx11::basic_string<char>, 
boost::mpl::l_end> > > >, boost::mpl::l_iter<boost::mpl::l_end> >; Visitor = 
invoke_visitor<dummy<boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
> >, false>; VoidPtrCV = const void*; NoBackupFlag = boost::variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > >::has_fallback_type_]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:238:5,
    inlined from âstatic typename Visitor::result_type boost::variant<T0, 
TN>::internal_apply_visitor_impl(int, int, Visitor&, VoidPtrCV) [with Visitor = 
boost::detail::variant::invoke_visitor<dummy<boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
> >, false>; VoidPtrCV = const void*; T0_ = int; TN = {double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> 
>}]â at /usr/include/boost/variant/variant.hpp:2338:48,
    inlined from âtypename Visitor::result_type boost::variant<T0, 
TN>::internal_apply_visitor(Visitor&) const [with Visitor = 
boost::detail::variant::invoke_visitor<dummy<boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
> >, false>; T0_ = int; TN = {double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> >}]â at 
/usr/include/boost/variant/variant.hpp:2359:43,
    inlined from âtypename Visitor::result_type boost::variant<T0, 
TN>::apply_visitor(Visitor&) const & [with Visitor = dummy<boost::variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > > >; T0_ = int; TN = {double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> 
>}]â at /usr/include/boost/variant/variant.hpp:2405:44,
    inlined from âtypename Visitor::result_type 
boost::apply_visitor(Visitor&, Visitable&&) [with Visitor = dummy<variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > > >; Visitable = const variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
>&]â at /usr/include/boost/variant/detail/apply_visitor_unary.hpp:48:64,
    inlined from âvoid run_boost_test(std::size_t)â at 
test/bench_variant.cpp:98:29:
/usr/include/c++/15/bits/basic_string.h:992:24: error: 
â*(std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> >*)((char*)&temp + offsetof(boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
>,boost::variant<int, double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> > 
>::storage_.boost::aligned_storage<32, 
8>::<unnamed>.boost::detail::aligned_storage::aligned_storage_imp<32, 
8>::data_)).std::__cxx11::basic_string<char>::<anonymous>.std::__cxx11::basic_string<char>::<unnamed
 union>::_M_allocated_capacityâ may be used uninitialized 
[-Werror=maybe-uninitialized]
  992 |             _M_capacity(__str._M_allocated_capacity);
      |             ~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/boost/variant/variant.hpp: In function âvoid 
run_boost_test(std::size_t)â:
/usr/include/boost/variant/variant.hpp:2107:21: note: âtempâ declared here
 2107 |             variant temp(rhs);
      |                     ^~~~
In member function âbool std::__cxx11::basic_string<_CharT, _Traits, 
_Alloc>::_M_is_local() const [with _CharT = char; _Traits = 
std::char_traits<char>; _Alloc = std::allocator<char>]â,
    inlined from âstd::__cxx11::basic_string<_CharT, _Traits, _Alloc>& 
std::__cxx11::basic_string<_CharT, _Traits, 
_Alloc>::operator=(std::__cxx11::basic_string<_CharT, _Traits, _Alloc>&&) [with 
_CharT = char; _Traits = std::char_traits<char>; _Alloc = 
std::allocator<char>]â at /usr/include/c++/15/bits/basic_string.h:961:23,
    inlined from âvoid 
boost::detail::variant::move_storage::internal_visit(T&, int) const [with T = 
std::__cxx11::basic_string<char>]â at 
/usr/include/boost/variant/variant.hpp:597:21,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl_invoke_impl(int, Visitor&, VoidPtrCV, 
T*, mpl_::true_) [with Visitor = move_storage; VoidPtrCV = void*; T = 
std::__cxx11::basic_string<char>]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:117:34,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl_invoke(int, Visitor&, VoidPtrCV, T*, 
NoBackupFlag, int) [with Visitor = move_storage; VoidPtrCV = void*; T = 
std::__cxx11::basic_string<char>; NoBackupFlag = boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
>::has_fallback_type_]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:157:41,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl(int, int, Visitor&, VoidPtrCV, 
mpl_::false_, NoBackupFlag, Which*, step0*) [with Which = mpl_::int_<0>; step0 
= visitation_impl_step<boost::mpl::l_iter<boost::mpl::l_item<mpl_::long_<3>, 
int, boost::mpl::l_item<mpl_::long_<2>, double, 
boost::mpl::l_item<mpl_::long_<1>, std::__cxx11::basic_string<char>, 
boost::mpl::l_end> > > >, boost::mpl::l_iter<boost::mpl::l_end> >; Visitor = 
move_storage; VoidPtrCV = void*; NoBackupFlag = boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
>::has_fallback_type_]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:238:5,
    inlined from âstatic typename Visitor::result_type boost::variant<T0, 
TN>::internal_apply_visitor_impl(int, int, Visitor&, VoidPtrCV) [with Visitor = 
boost::detail::variant::move_storage; VoidPtrCV = void*; T0_ = int; TN = 
{double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> >}]â at /usr/include/boost/variant/variant.hpp:2338:48,
    inlined from âtypename Visitor::result_type boost::variant<T0, 
TN>::internal_apply_visitor(Visitor&) [with Visitor = 
boost::detail::variant::move_storage; T0_ = int; TN = {double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> 
>}]â at /usr/include/boost/variant/variant.hpp:2350:43,
    inlined from âvoid boost::variant<T0, 
TN>::variant_assign(boost::variant<T0, TN>&&) [with T0_ = int; TN = {double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> 
>}]â at /usr/include/boost/variant/variant.hpp:2081:41,
    inlined from âvoid boost::variant<T0, TN>::assign(const T&) [with T = 
double; T0_ = int; TN = {double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> >}]â at 
/usr/include/boost/variant/variant.hpp:2108:27,
    inlined from âvoid boost::variant<T0, TN>::assign(const T&) [with T = 
double; T0_ = int; TN = {double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> >}]â at 
/usr/include/boost/variant/variant.hpp:2095:10,
    inlined from âtypename boost::enable_if<boost::mpl::or_< 
[too-long-redacted] st/variant/variant.hpp:2160:15,
    inlined from âvoid dummy<V>::operator()(T&&) const [with T = const 
double&; V = boost::variant<int, double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> > >]â at 
test/bench_variant.cpp:63:12,
    inlined from âtypename boost::disable_if_c<(MoveSemantics && 
boost::is_same<Value2, Value2>::value), typename Visitor::result_type>::type 
boost::detail::variant::invoke_visitor<Visitor, 
MoveSemantics>::internal_visit(T&&, int) [with T = const double&; Visitor = 
dummy<boost::variant<int, double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> > > >; bool MoveSemantics = 
false]â at /usr/include/boost/variant/variant.hpp:1028:24,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl_invoke_impl(int, Visitor&, VoidPtrCV, 
T*, mpl_::true_) [with Visitor = invoke_visitor<dummy<boost::variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > > >, false>; VoidPtrCV = const void*; T = double]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:117:34,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl_invoke(int, Visitor&, VoidPtrCV, T*, 
NoBackupFlag, int) [with Visitor = invoke_visitor<dummy<boost::variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > > >, false>; VoidPtrCV = const void*; T = double; 
NoBackupFlag = boost::variant<int, double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> > >::has_fallback_type_]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:157:41,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl(int, int, Visitor&, VoidPtrCV, 
mpl_::false_, NoBackupFlag, Which*, step0*) [with Which = mpl_::int_<0>; step0 
= visitation_impl_step<boost::mpl::l_iter<boost::mpl::l_item<mpl_::long_<3>, 
int, boost::mpl::l_item<mpl_::long_<2>, double, 
boost::mpl::l_item<mpl_::long_<1>, std::__cxx11::basic_string<char>, 
boost::mpl::l_end> > > >, boost::mpl::l_iter<boost::mpl::l_end> >; Visitor = 
invoke_visitor<dummy<boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
> >, false>; VoidPtrCV = const void*; NoBackupFlag = boost::variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > >::has_fallback_type_]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:238:5,
    inlined from âstatic typename Visitor::result_type boost::variant<T0, 
TN>::internal_apply_visitor_impl(int, int, Visitor&, VoidPtrCV) [with Visitor = 
boost::detail::variant::invoke_visitor<dummy<boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
> >, false>; VoidPtrCV = const void*; T0_ = int; TN = {double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> 
>}]â at /usr/include/boost/variant/variant.hpp:2338:48,
    inlined from âtypename Visitor::result_type boost::variant<T0, 
TN>::internal_apply_visitor(Visitor&) const [with Visitor = 
boost::detail::variant::invoke_visitor<dummy<boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
> >, false>; T0_ = int; TN = {double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> >}]â at 
/usr/include/boost/variant/variant.hpp:2359:43,
    inlined from âtypename Visitor::result_type boost::variant<T0, 
TN>::apply_visitor(Visitor&) const & [with Visitor = dummy<boost::variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > > >; T0_ = int; TN = {double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> 
>}]â at /usr/include/boost/variant/variant.hpp:2405:44,
    inlined from âtypename Visitor::result_type 
boost::apply_visitor(Visitor&, Visitable&&) [with Visitor = dummy<variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > > >; Visitable = const variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
>&]â at /usr/include/boost/variant/detail/apply_visitor_unary.hpp:48:64,
    inlined from âvoid run_boost_test(std::size_t)â at 
test/bench_variant.cpp:98:29:
/usr/include/c++/15/bits/basic_string.h:282:17: error: â*(const 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> 
>*)((char*)&temp + offsetof(boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
>,boost::variant<int, double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> > 
>::storage_.boost::aligned_storage<32, 
8>::<unnamed>.boost::detail::aligned_storage::aligned_storage_imp<32, 
8>::data_)).std::__cxx11::basic_string<char>::_M_string_lengthâ may be used 
uninitialized [-Werror=maybe-uninitialized]
  282 |             if (_M_string_length > _S_local_capacity)
      |                 ^~~~~~~~~~~~~~~~
/usr/include/boost/variant/variant.hpp: In function âvoid 
run_boost_test(std::size_t)â:
/usr/include/boost/variant/variant.hpp:2107:21: note: âtempâ declared here
 2107 |             variant temp(rhs);
      |                     ^~~~
In member function âbool std::__cxx11::basic_string<_CharT, _Traits, 
_Alloc>::_M_is_local() const [with _CharT = char; _Traits = 
std::char_traits<char>; _Alloc = std::allocator<char>]â,
    inlined from âstd::__cxx11::basic_string<_CharT, _Traits, _Alloc>& 
std::__cxx11::basic_string<_CharT, _Traits, 
_Alloc>::operator=(std::__cxx11::basic_string<_CharT, _Traits, _Alloc>&&) [with 
_CharT = char; _Traits = std::char_traits<char>; _Alloc = 
std::allocator<char>]â at /usr/include/c++/15/bits/basic_string.h:961:23,
    inlined from âvoid 
boost::detail::variant::move_storage::internal_visit(T&, int) const [with T = 
std::__cxx11::basic_string<char>]â at 
/usr/include/boost/variant/variant.hpp:597:21,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl_invoke_impl(int, Visitor&, VoidPtrCV, 
T*, mpl_::true_) [with Visitor = move_storage; VoidPtrCV = void*; T = 
std::__cxx11::basic_string<char>]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:117:34,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl_invoke(int, Visitor&, VoidPtrCV, T*, 
NoBackupFlag, int) [with Visitor = move_storage; VoidPtrCV = void*; T = 
std::__cxx11::basic_string<char>; NoBackupFlag = boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
>::has_fallback_type_]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:157:41,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl(int, int, Visitor&, VoidPtrCV, 
mpl_::false_, NoBackupFlag, Which*, step0*) [with Which = mpl_::int_<0>; step0 
= visitation_impl_step<boost::mpl::l_iter<boost::mpl::l_item<mpl_::long_<3>, 
int, boost::mpl::l_item<mpl_::long_<2>, double, 
boost::mpl::l_item<mpl_::long_<1>, std::__cxx11::basic_string<char>, 
boost::mpl::l_end> > > >, boost::mpl::l_iter<boost::mpl::l_end> >; Visitor = 
move_storage; VoidPtrCV = void*; NoBackupFlag = boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
>::has_fallback_type_]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:238:5,
    inlined from âstatic typename Visitor::result_type boost::variant<T0, 
TN>::internal_apply_visitor_impl(int, int, Visitor&, VoidPtrCV) [with Visitor = 
boost::detail::variant::move_storage; VoidPtrCV = void*; T0_ = int; TN = 
{double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> >}]â at /usr/include/boost/variant/variant.hpp:2338:48,
    inlined from âtypename Visitor::result_type boost::variant<T0, 
TN>::internal_apply_visitor(Visitor&) [with Visitor = 
boost::detail::variant::move_storage; T0_ = int; TN = {double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> 
>}]â at /usr/include/boost/variant/variant.hpp:2350:43,
    inlined from âvoid boost::variant<T0, 
TN>::variant_assign(boost::variant<T0, TN>&&) [with T0_ = int; TN = {double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> 
>}]â at /usr/include/boost/variant/variant.hpp:2081:41,
    inlined from âvoid boost::variant<T0, TN>::assign(const T&) [with T = 
double; T0_ = int; TN = {double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> >}]â at 
/usr/include/boost/variant/variant.hpp:2108:27,
    inlined from âvoid boost::variant<T0, TN>::assign(const T&) [with T = 
double; T0_ = int; TN = {double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> >}]â at 
/usr/include/boost/variant/variant.hpp:2095:10,
    inlined from âtypename boost::enable_if<boost::mpl::or_< 
[too-long-redacted] st/variant/variant.hpp:2160:15,
    inlined from âvoid dummy<V>::operator()(T&&) const [with T = const 
double&; V = boost::variant<int, double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> > >]â at 
test/bench_variant.cpp:63:12,
    inlined from âtypename boost::disable_if_c<(MoveSemantics && 
boost::is_same<Value2, Value2>::value), typename Visitor::result_type>::type 
boost::detail::variant::invoke_visitor<Visitor, 
MoveSemantics>::internal_visit(T&&, int) [with T = const double&; Visitor = 
dummy<boost::variant<int, double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> > > >; bool MoveSemantics = 
false]â at /usr/include/boost/variant/variant.hpp:1028:24,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl_invoke_impl(int, Visitor&, VoidPtrCV, 
T*, mpl_::true_) [with Visitor = invoke_visitor<dummy<boost::variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > > >, false>; VoidPtrCV = const void*; T = double]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:117:34,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl_invoke(int, Visitor&, VoidPtrCV, T*, 
NoBackupFlag, int) [with Visitor = invoke_visitor<dummy<boost::variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > > >, false>; VoidPtrCV = const void*; T = double; 
NoBackupFlag = boost::variant<int, double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> > >::has_fallback_type_]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:157:41,
    inlined from âtypename Visitor::result_type 
boost::detail::variant::visitation_impl(int, int, Visitor&, VoidPtrCV, 
mpl_::false_, NoBackupFlag, Which*, step0*) [with Which = mpl_::int_<0>; step0 
= visitation_impl_step<boost::mpl::l_iter<boost::mpl::l_item<mpl_::long_<3>, 
int, boost::mpl::l_item<mpl_::long_<2>, double, 
boost::mpl::l_item<mpl_::long_<1>, std::__cxx11::basic_string<char>, 
boost::mpl::l_end> > > >, boost::mpl::l_iter<boost::mpl::l_end> >; Visitor = 
invoke_visitor<dummy<boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
> >, false>; VoidPtrCV = const void*; NoBackupFlag = boost::variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > >::has_fallback_type_]â at 
/usr/include/boost/variant/detail/visitation_impl.hpp:238:5,
    inlined from âstatic typename Visitor::result_type boost::variant<T0, 
TN>::internal_apply_visitor_impl(int, int, Visitor&, VoidPtrCV) [with Visitor = 
boost::detail::variant::invoke_visitor<dummy<boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
> >, false>; VoidPtrCV = const void*; T0_ = int; TN = {double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> 
>}]â at /usr/include/boost/variant/variant.hpp:2338:48,
    inlined from âtypename Visitor::result_type boost::variant<T0, 
TN>::internal_apply_visitor(Visitor&) const [with Visitor = 
boost::detail::variant::invoke_visitor<dummy<boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
> >, false>; T0_ = int; TN = {double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> >}]â at 
/usr/include/boost/variant/variant.hpp:2359:43,
    inlined from âtypename Visitor::result_type boost::variant<T0, 
TN>::apply_visitor(Visitor&) const & [with Visitor = dummy<boost::variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > > >; T0_ = int; TN = {double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> 
>}]â at /usr/include/boost/variant/variant.hpp:2405:44,
    inlined from âtypename Visitor::result_type 
boost::apply_visitor(Visitor&, Visitable&&) [with Visitor = dummy<variant<int, 
double, std::__cxx11::basic_string<char, std::char_traits<char>, 
std::allocator<char> > > >; Visitable = const variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
>&]â at /usr/include/boost/variant/detail/apply_visitor_unary.hpp:48:64,
    inlined from âvoid run_boost_test(std::size_t)â at 
test/bench_variant.cpp:98:29:
/usr/include/c++/15/bits/basic_string.h:282:17: error: â*(const 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> 
>*)((char*)&temp + offsetof(boost::variant<int, double, 
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > 
>,boost::variant<int, double, std::__cxx11::basic_string<char, 
std::char_traits<char>, std::allocator<char> > 
>::storage_.boost::aligned_storage<32, 
8>::<unnamed>.boost::detail::aligned_storage::aligned_storage_imp<32, 
8>::data_)).std::__cxx11::basic_string<char>::_M_string_lengthâ may be used 
uninitialized [-Werror=maybe-uninitialized]
  282 |             if (_M_string_length > _S_local_capacity)
      |                 ^~~~~~~~~~~~~~~~
/usr/include/boost/variant/variant.hpp: In function âvoid 
run_boost_test(std::size_t)â:
/usr/include/boost/variant/variant.hpp:2107:21: note: âtempâ declared here
 2107 |             variant temp(rhs);
      |                     ^~~~
cc1plus: all warnings being treated as errors
make[1]: *** [Makefile:66: out/bench-variant] Error 1
make[1]: *** Waiting for unfinished jobs....
make[1]: Leaving directory '/<<PKGBUILDDIR>>'
dh_auto_build: error: make -j2 "INSTALL=install --strip-program=true" returned 
exit code 2
make: *** [debian/rules:6: binary] Error 25
dpkg-buildpackage: error: debian/rules binary subprocess returned exit status 2
--------------------------------------------------------------------------------

--- End Message ---

--- Begin Message ---

Source: mapbox-variant
Source-Version: 1.2.0-4
Done: Bas Couwenberg <[email protected]>

We believe that the bug you reported is fixed in the latest version of
mapbox-variant, which is due to be installed in the Debian FTP archive.

A summary of the changes between this version and the previous one is
attached.

Thank you for reporting the bug, which will now be closed.  If you
have further comments please address them to [email protected],
and the maintainer will reopen the bug report if appropriate.

Debian distribution maintenance software
pp.
Bas Couwenberg <[email protected]> (supplier of updated mapbox-variant 
package)

(This message was generated automatically at their request; if you
believe that there is a problem with it please contact the archive
administrators by mailing [email protected])


-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA512

Format: 1.8
Date: Fri, 05 Sep 2025 21:07:31 +0200
Source: mapbox-variant
Architecture: source
Version: 1.2.0-4
Distribution: unstable
Urgency: medium
Maintainer: Debian GIS Project <[email protected]>
Changed-By: Bas Couwenberg <[email protected]>
Closes: 1114197
Changes:
 mapbox-variant (1.2.0-4) unstable; urgency=medium
 .
   * Bump Standards-Version to 4.7.2, no changes.
   * Use -Wno-error=maybe-uninitialized to fix FTBFS.
     (closes: #1114197)
Checksums-Sha1:
 6d12e860b48eb7793c7588cf58a7f0538a9d582e 2080 mapbox-variant_1.2.0-4.dsc
 0015a1ca9b0cf6528b925ed345f4bae3ef2416f4 193396 
mapbox-variant_1.2.0-4.debian.tar.xz
 d790d58449d50b28c6785ac677a0f5f411399a58 7722 
mapbox-variant_1.2.0-4_amd64.buildinfo
Checksums-Sha256:
 1f1ad25339e76fad2b5b596d009a6077bf54eeedd9223264e67bd1ef1cdfa825 2080 
mapbox-variant_1.2.0-4.dsc
 176c02b9a5649a49ad3c8977d9d4f26bffb8d266a0d9cd528a6566962b6519cc 193396 
mapbox-variant_1.2.0-4.debian.tar.xz
 2579daf6eea92950d1af107576bb46dfa48d1e29141c19e109d815e1b4b458ec 7722 
mapbox-variant_1.2.0-4_amd64.buildinfo
Files:
 755a896a02df1b0804b899e1f60fb328 2080 libdevel optional 
mapbox-variant_1.2.0-4.dsc
 fbc8d7cc094be715a743655fcbf22e98 193396 libdevel optional 
mapbox-variant_1.2.0-4.debian.tar.xz
 1096826354eafa66ac55fea207a1c84d 7722 libdevel optional 
mapbox-variant_1.2.0-4_amd64.buildinfo

-----BEGIN PGP SIGNATURE-----

iQIzBAEBCgAdFiEEgYLeQXBWQI1hRlDRZ1DxCuiNSvEFAmi7NVUACgkQZ1DxCuiN
SvG3jQ//WA/mPi+M4+zfiDz2AXeJAYqXjY/SNoDYaXCqesqHCxT7Y0D1O3pvXKwf
61Av8N26CJ84o4YVq6gPFDGMqv5tVbqP6kopcFcf+C48JdY+37MHacs8Yar4ozL4
S9W41r00gJKptJZhvIwdg59V3P2MvhnIXyFwdTEqqXreMwzWm7NlKRVhQ0bK2O2g
1MJhdbSYjfzI2N17gU75JbZzjWOuLERvWviQk/5sCsqdZpPJ3h2es4ZSmyXG0RhQ
1Bf5D56mxTOfZkO0EJoeWYXomlTiiveJZssXp0/vq2+R5sRRObunzkA0Cv1N31jE
Nht1eTAn0zw0/c1P0Vev5n9agadqseJf+OcOkKky/zaIImP9x0CrAOJVTihupzvc
d652cqH9POr2QKSgX8uSJMMp6AFz8bOjXN8jcvU3Hwk9WrjoEE+TBipHUegM7/Jx
o5aHc+PjuKQBT9qeRC0bpTiI53MpxWXtTgovjAWi+6/3KCjk5u/ZnLiYQ079g7v3
aanI6NraNi1B/Aocot96ojCV23tGTSxY8RU0N530nszOu91hN9AXBaCua4/rTMdF
YdTbwMU96vfbBroBzp30xoh2wY+hN2LVIJBiyEiYmLY8bV0IqP3oIACeSbwaRok/
Kumqt34aKRqvxb9/9Dx1EHkTR0ILWMShhz1/w6nxtkFFKmE/c2M=
=yYKi
-----END PGP SIGNATURE-----

pgp5G4hzCiSbO.pgp
Description: PGP signature

--- End Message ---

Reply via email to