**Describe the bug**

`sumIf` returns incorrect results in some cases with Nullable arguments.

**How to reproduce**

* Which ClickHouse server version to use
Latest master/arcadia version

* Queries to run that lead to unexpected result
```sql
:) select sumIf(toFloat64OrZero(b), a = 0) as r1, sumIf(cast(b as Float), a = 0) as r2, sum(if(a = 0, toFloat64OrZero(b), 0)) as r3 from (select arrayJoin([1, 2, 3, NULL]) as a, toNullable('10.0') as b)

SELECT
    sumIf(toFloat64OrZero(b), a = 0) AS r1,
    sumIf(CAST(b, 'Float'), a = 0) AS r2,
    sum(if(a = 0, toFloat64OrZero(b), 0)) AS r3
FROM
(
    SELECT
        arrayJoin([1, 2, 3, NULL]) AS a,
        toNullable('10.0') AS b
)

Query id: 2e4e320d-e52a-4514-bc6f-118485558191

┌─r1─┬─r2─┬─r3─┐
│ 10 │  0 │  0 │
└────┴────┴────┘
```
**Expected behavior**

All results are 0.

**Additional context**

It breaks when null values in Nullable column are compared with `assumeNotNull` from this column.
It also only breaks when first argument is Nullable too.


{
        llvm::IRBuilder<> & b = static_cast<llvm::IRBuilder<> &>(builder);
        const auto & nullable_type = arguments_types[0];
        const auto & nullable_value = argument_values[0];
        auto * wrapped_value = b.CreateExtractValue(nullable_value, {0});
        auto * is_null_value = b.CreateExtractValue(nullable_value, {1});
        const auto & predicate_type = arguments_types[argument_values.size() - 1];
        auto * predicate_value = argument_values[argument_values.size() - 1];
        auto * is_predicate_true = nativeBoolCast(b, predicate_type, predicate_value);
        auto * head = b.GetInsertBlock();
        auto * join_block = llvm::BasicBlock::Create(head->getContext(), "join_block", head->getParent());
        auto * if_null = llvm::BasicBlock::Create(head->getContext(), "if_null", head->getParent());
        auto * if_not_null = llvm::BasicBlock::Create(head->getContext(), "if_not_null", head->getParent());
        b.CreateCondBr(b.CreateAnd(b.CreateNot(is_null_value), is_predicate_true), if_not_null, if_null);
        b.SetInsertPoint(if_null);
        b.CreateBr(join_block);
        b.SetInsertPoint(if_not_null);
        if constexpr (result_is_nullable)
            b.CreateStore(llvm::ConstantInt::get(b.getInt8Ty(), 1), aggregate_data_ptr);
        auto * aggregate_data_ptr_with_prefix_size_offset = b.CreateConstInBoundsGEP1_64(nullptr, aggregate_data_ptr, this->prefix_size);
        this->nested_function->compileAdd(b, aggregate_data_ptr_with_prefix_size_offset, { removeNullable(nullable_type) }, { wrapped_value });
        b.CreateBr(join_block);
        b.SetInsertPoint(join_block);
    }
#endif
};
template <bool result_is_nullable, bool serialize_flag, bool null_is_skipped>
class AggregateFunctionIfNullVariadic final