```
../contrib/libcxx/include/vector:1449: _LIBCPP_ASSERT '__n < size()' failed. vector[] index out of bounds Received signal 6 Received signal Aborted (6)
```

https://s3.amazonaws.com/clickhouse-test-reports/39973/24ee3e022df7e970b5925fea657bec3ad7303702/fuzzer_astfuzzerdebug//report.html

size_t num_args = func.numArguments();
            for (size_t i = 0; i < num_args; ++i)
            {
                traverseAST(func.getArgumentAt(i), context, block_with_constants);
                /** The first part of the condition is for the correct support of `and` and `or` functions of arbitrary arity
                  * - in this case `n - 1` elements are added (where `n` is the number of arguments).
                  */
                if (i != 0 || element.function == RPNElement::FUNCTION_NOT)
                    rpn.emplace_back(element);
            }
            return;
        }
    }
    if (!tryParseAtomFromAST(node, context, block_with_constants, element))
    {
        element.function = RPNElement::FUNCTION_UNKNOWN;
    }
    rpn.emplace_back(std::move(element));
}
/** The key functional expression constraint may be inferred from a plain column in the expression.
  * For example, if the key contains `toStartOfHour(Timestamp)` and query contains `WHERE Timestamp >= now()`,
  * it can be assumed that if `toStartOfHour()` is monotonic on [now(), inf), the `toStartOfHour(Timestamp) >= toStartOfHour(now())`
  * condition also holds, so the index may be used to select only parts satisfying this condition.
  *
  * To check the assumption, we'd need to assert that the inverse function to this transformation is also monotonic, however the
  * inversion isn't exported (or even viable for not strictly monotonic functions such as `toStartOfHour()`).
  * Instead, we can qualify only functions that do not transform the range (for example rounding),
  * which while not strictly monotonic, are monotonic everywhere on the input range.
  */
bool KeyCondition::transformConstantWithValidFunctions(