// File: /workspace/github_cpp_makefile_star2_O1/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Generators::GeneratorTracker::close()
void close() override {
                TrackerBase::close();
                // If a generator has a child (it is followed by a section)
                // and none of its children have started, then we must wait
                // until later to start consuming its values.
                // This catches cases where `GENERATE` is placed between two
                // `SECTION`s.
                // **The check for m_children.empty cannot be removed**.
                // doing so would break `GENERATE` _not_ followed by `SECTION`s.
                const bool should_wait_for_child = [&]() {
                    // No children -> nobody to wait for
                    if ( m_children.empty() ) {
                        return false;
                    }
                    // If at least one child started executing, don't wait
                    if ( std::find_if(
                             m_children.begin(),
                             m_children.end(),
                             []( TestCaseTracking::ITrackerPtr tracker ) {
                                 return tracker->hasStarted();
                             } ) != m_children.end() ) {
                        return false;
                    }

                    // No children have started. We need to check if they _can_
                    // start, and thus we should wait for them, or they cannot
                    // start (due to filters), and we shouldn't wait for them
                    auto* parent = m_parent;
                    // This is safe: there is always at least one section
                    // tracker in a test case tracking tree
                    while ( !parent->isSectionTracker() ) {
                        parent = &( parent->parent() );
                    }
                    assert( parent &&
                            "Missing root (test case) level section" );

                    auto const& parentSection =
                        static_cast<SectionTracker&>( *parent );
                    auto const& filters = parentSection.getFilters();
                    // No filters -> no restrictions on running sections
                    if ( filters.empty() ) {
                        return true;
                    }

                    for ( auto const& child : m_children ) {
                        if ( child->isSectionTracker() &&
                             std::find( filters.begin(),
                                        filters.end(),
                                        static_cast<SectionTracker&>( *child )
                                            .trimmedName() ) !=
                                 filters.end() ) {
                            return true;
                        }
                    }
                    return false;
                }();

                // This check is a bit tricky, because m_generator->next()
                // has a side-effect, where it consumes generator's current
                // value, but we do not want to invoke the side-effect if
                // this generator is still waiting for any child to start.
                if ( should_wait_for_child ||
                     ( m_runState == CompletedSuccessfully &&
                       m_generator->next() ) ) {
                    m_children.clear();
                    m_runState = Executing;
                }
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2f7d2
movq 0x48(%rbx), %rdi
movq 0x50(%rbx), %rsi
cmpq %rsi, %rdi
je 0x427d0
callq 0x4ab0c
cmpq 0x50(%rbx), %rax
je 0x427ed
cmpl $0x4, 0x60(%rbx)
jne 0x42871
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
jne 0x42861
jmp 0x42871
movq 0x40(%rbx), %r14
movq (%r14), %rax
movq %r14, %rdi
callq *0x70(%rax)
testb %al, %al
jne 0x4280f
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %rax, %r14
movq (%rax), %rax
jmp 0x427f4
movq 0x68(%r14), %rax
cmpq 0x70(%r14), %rax
je 0x42861
movq 0x48(%rbx), %r15
movq 0x50(%rbx), %r12
cmpq %r12, %r15
setne %r13b
je 0x42857
movq (%r15), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
testb %al, %al
je 0x42851
movq 0x68(%r14), %rdi
movq 0x70(%r14), %rsi
movq (%r15), %rdx
subq $-0x80, %rdx
callq 0x5b656
cmpq 0x70(%r14), %rax
jne 0x42857
addq $0x10, %r15
jmp 0x42821
testb $0x1, %r13b
je 0x427d0
leaq 0x48(%rbx), %rdi
callq 0x4aaca
movl $0x1, 0x60(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq