#include <boost/asio.hpp>
#include <boost/asio/experimental/parallel_group.hpp>

namespace asio = boost::asio;

template <typename CompletionToken>
auto async_func(
    asio::any_io_executor exe,
    CompletionToken&& token
) {
    return asio::async_initiate<
        CompletionToken,
        void()
    >(
        asio::co_composed<
            void()
        >(
            [](
                auto /*state*/
            ) -> void {
                co_return {};
            },
           exe
        ),
        token
    );
}

template <typename CompletionToken>
auto caller(
    asio::any_io_executor exe,
    CompletionToken&& token
) {
    return asio::async_initiate<
        CompletionToken,
        void()
    >(
        asio::co_composed<
            void()
        >(
            [](
                auto /*state*/,
                asio::any_io_executor exe
            ) -> void {
                std::string s{"ABC"}; // if remove this line, heap-use-after-free disappeared

                {
                    // parallel_group part1
                    using op_type = decltype(
                        async_func(
                            exe,
                            asio::deferred
                        )
                    );
                    std::vector<op_type> ops;
                    ops.reserve(2);
                    for (std::size_t i = 0; i != 2; ++i) {
                        ops.push_back(async_func(exe, asio::deferred));
                    }
                    // https://www.boost.org/doc/html/boost_asio/reference/experimental__make_parallel_group/overload2.html
                    co_await asio::experimental::make_parallel_group(ops).async_wait(
                        asio::experimental::wait_for_all(),
                        asio::deferred
                    );
                }
                {
                    // parallel_group part2
                    // https://www.boost.org/doc/html/boost_asio/reference/experimental__make_parallel_group/overload1.html
                    co_await asio::experimental::make_parallel_group(
                        async_func(
                            exe,
                            asio::deferred
                        ),
                        async_func(
                            exe,
                            asio::deferred
                        )
                    ).async_wait(
                        asio::experimental::wait_for_all(),
                        asio::deferred
                    );
                }

                co_return {};
            },
            exe
        ),
        token,
        exe
    );
}

asio::awaitable<void> coro_main() {
    auto exe = co_await asio::this_coro::executor;
    co_await caller(exe, asio::deferred);
    co_return;
}

int main() {
    asio::io_context ioc;
    asio::any_io_executor exe{ioc.get_executor()};
    asio::co_spawn(exe, coro_main(), asio::detached);
    ioc.run();
}