According to my reading of the source code, it seems that strict = true, will return Event INDEX directly.
such as the event sequence is `A->B->C->B->D` and conditional sequence is`A->B->C->D`, returns 2 (not 3 or 4) when searching the second B.
But if the conditional sequence is`A->B->C`, it will return directly to 3 when searching `C`.
This makes me feel confused to `strict`.

```CPP
        for (const auto & pair : data.events_list)
        {
            const T & timestamp = pair.first;
            const auto & event_idx = pair.second - 1;
            if (strict_order && event_idx == -1)
            {
                if (first_event)
                    break;
                else
                    continue;
            }
            else if (event_idx == 0)
            {
                events_timestamp[0] = std::make_pair(timestamp, timestamp);
                first_event = true;
            }
            else if (strict && events_timestamp[event_idx].has_value())
            {
                return event_idx + 1;//example1 return here
            }
            else if (strict_order && first_event && !events_timestamp[event_idx - 1].has_value())
            {
                for (size_t event = 0; event < events_timestamp.size(); ++event)
                {
                    if (!events_timestamp[event].has_value())
                        return event;
                }
            }
            else if (events_timestamp[event_idx - 1].has_value())
            {
                auto first_timestamp = events_timestamp[event_idx - 1]->first;
                bool time_matched = timestamp <= first_timestamp + window;
                if (strict_increase)
                    time_matched = time_matched && events_timestamp[event_idx - 1]->second < timestamp;
                if (time_matched)
                {
                    events_timestamp[event_idx] = std::make_pair(first_timestamp, timestamp);
                    if (event_idx + 1 == events_size)
                        return events_size;//example2 return here
                }
            }
        }
```
I see a `strict` design purpose in https://github.com/ClickHouse/ClickHouse/pull/6548.
I think the answer in the first example should be 3 instead of 2. Is this a bug? 
: public IAggregateFunctionDataHelper<Data, AggregateFunctionWindowFunnel<T, Data>>
{
private:
    UInt64 window;
    UInt8 events_size;
    
    bool strict;
    
    
    bool strict_order;
    
    bool strict_increase;
    
    
    
    
    UInt8 getEventLevel(Data & data) const