minikql - llvm16 compatibility (opaque pointers and some other stuff)

commit_hash:c166e0d029d87d2a10e5adfc3acf20a849670881

74 files changed, 484 insertions, 348 deletions

diff --git a/yql/essentials/minikql/comp_nodes/llvm16/ut/ya.make b/yql/essentials/minikql/comp_nodes/llvm16/ut/ya.make
new file mode 100644
index 0000000000..849503c1ef
--- /dev/null
+++ b/yql/essentials/minikql/comp_nodes/llvm16/ut/ya.make
@@ -0,0 +1,20 @@
+UNITTEST()
+
+PEERDIR(
+    yql/essentials/minikql/codegen/llvm16
+    yql/essentials/minikql/comp_nodes/llvm16
+    yql/essentials/minikql/invoke_builtins/llvm16
+    contrib/libs/llvm16/lib/IR
+    contrib/libs/llvm16/lib/ExecutionEngine/MCJIT
+    contrib/libs/llvm16/lib/Linker
+    contrib/libs/llvm16/lib/Passes
+    contrib/libs/llvm16/lib/Target/X86
+    contrib/libs/llvm16/lib/Target/X86/AsmParser
+    contrib/libs/llvm16/lib/Target/X86/Disassembler
+    contrib/libs/llvm16/lib/Transforms/IPO
+    contrib/libs/llvm16/lib/Transforms/ObjCARC
+)
+
+INCLUDE(../../ut/ya.make.inc)
+
+END()
diff --git a/yql/essentials/minikql/comp_nodes/llvm16/ya.make b/yql/essentials/minikql/comp_nodes/llvm16/ya.make
new file mode 100644
index 0000000000..9b6039fbfd
--- /dev/null
+++ b/yql/essentials/minikql/comp_nodes/llvm16/ya.make
@@ -0,0 +1,23 @@
+LIBRARY()
+
+PEERDIR(
+    yql/essentials/minikql/codegen/llvm16
+    yql/essentials/minikql/invoke_builtins/llvm16
+    contrib/libs/llvm16/lib/IR
+    contrib/libs/llvm16/lib/ExecutionEngine/MCJIT
+    contrib/libs/llvm16/lib/Linker
+    contrib/libs/llvm16/lib/Passes
+    contrib/libs/llvm16/lib/Target/X86
+    contrib/libs/llvm16/lib/Target/X86/AsmParser
+    contrib/libs/llvm16/lib/Target/X86/Disassembler
+    contrib/libs/llvm16/lib/Transforms/IPO
+    contrib/libs/llvm16/lib/Transforms/ObjCARC
+)
+
+INCLUDE(../ya.make.inc)
+
+END()
+
+RECURSE_FOR_TESTS(
+    ut
+)
diff --git a/yql/essentials/minikql/comp_nodes/mkql_aggrcount.cpp b/yql/essentials/minikql/comp_nodes/mkql_aggrcount.cpp
index 0a4cb6c7f3..d9fb8325db 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_aggrcount.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_aggrcount.cpp
@@ -22,10 +22,11 @@ public:
 
 #ifndef MKQL_DISABLE_CODEGEN
     Value* DoGenerateGetValue(const TCodegenContext& ctx, Value* value, BasicBlock*& block) const {
-        const auto check = IsExists(value, block);
+        auto& context = ctx.Codegen.GetContext();
+        const auto check = IsExists(value, block, context);
         if (Node->IsTemporaryValue())
             ValueCleanup(Node->GetRepresentation(), value, ctx, block);
-        return MakeBoolean(check, ctx.Codegen.GetContext(), block);
+        return MakeBoolean(check, context, block);
     }
 #endif
 };
@@ -65,9 +66,10 @@ public:
 
 #ifndef MKQL_DISABLE_CODEGEN
     Value* DoGenerateGetValue(const TCodegenContext& ctx, BasicBlock*& block) const {
+        auto& context = ctx.Codegen.GetContext();
         const auto state = GetNodeValue(State, ctx, block);
         const auto value = GetNodeValue(Arg, ctx, block);
-        const auto check = IsExists(value, block);
+        const auto check = IsExists(value, block, context);
         if (Arg->IsTemporaryValue())
             ValueCleanup(Arg->GetRepresentation(), value, ctx, block);
         const auto zext = new ZExtInst(check, state->getType(), "zext", block);
diff --git a/yql/essentials/minikql/comp_nodes/mkql_apply.cpp b/yql/essentials/minikql/comp_nodes/mkql_apply.cpp
index 97545dfebf..180a38176b 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_apply.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_apply.cpp
@@ -172,7 +172,7 @@ public:
         } else {
             const auto callable = GetNodeValue(CallableNode, ctx, block);
             const auto calleePtr = GetElementPtrInst::CreateInBounds(GetCompContextType(context), ctx.Ctx, {ConstantInt::get(idxType, 0), ConstantInt::get(idxType, 6)}, "callee_ptr", block);
-            const auto previous = new LoadInst(calleePtr->getType()->getPointerElementType(), calleePtr, "previous", block);
+            const auto previous = new LoadInst(PointerType::getUnqual(GetSourcePosType(context)), calleePtr, "previous", block);
             const auto callee = CastInst::Create(Instruction::IntToPtr, ConstantInt::get(Type::getInt64Ty(context), ui64(&Position)), previous->getType(), "callee", block);
             new StoreInst(callee, calleePtr, block);
             CallBoxedValueVirtualMethod<NUdf::TBoxedValueAccessor::EMethod::Run>(pointer, callable, ctx.Codegen, block, ctx.GetBuilder(), args);
diff --git a/yql/essentials/minikql/comp_nodes/mkql_block_agg.cpp b/yql/essentials/minikql/comp_nodes/mkql_block_agg.cpp
index 225c5249ca..fef2712c4f 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_block_agg.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_block_agg.cpp
@@ -532,7 +532,7 @@ protected:
         const auto work = BasicBlock::Create(context, "work", ctx.Func);
         const auto over = BasicBlock::Create(context, "over", ctx.Func);
 
-        BranchInst::Create(make, main, IsInvalid(statePtr, block), block);
+        BranchInst::Create(make, main, IsInvalid(statePtr, block, context), block);
         block = make;
 
         const auto ptrType = PointerType::getUnqual(StructType::get(context));
@@ -562,7 +562,7 @@ protected:
 
         const auto valuesPtr = GetElementPtrInst::CreateInBounds(stateType, stateArg, { stateFields.This(), stateFields.GetPointer() }, "values_ptr", block);
         const auto values = new LoadInst(ptrValuesType, valuesPtr, "values", block);
-        SafeUnRefUnboxed(values, ctx, block);
+        SafeUnRefUnboxedArray(values, arrayType, ctx, block);
 
         const auto getres = GetNodeValues(flow, ctx, block);
         result->addIncoming(ConstantInt::get(statusType, static_cast<i32>(EFetchResult::Yield)), block);
@@ -813,12 +813,12 @@ public:
         const auto state = ctx.HolderFactory.Create<TState>(Width_, FilterColumn_, AggsParams_, ctx);
         return ctx.HolderFactory.Create<TStreamValue>(std::move(state), std::move(Stream_->GetValue(ctx)));
     }
-        
+
 private:
     class TStreamValue : public TComputationValue<TStreamValue> {
     using TBase = TComputationValue<TStreamValue>;
     public:
-        TStreamValue(TMemoryUsageInfo* memInfo, NUdf::TUnboxedValue&& state, NUdf::TUnboxedValue&& stream) 
+        TStreamValue(TMemoryUsageInfo* memInfo, NUdf::TUnboxedValue&& state, NUdf::TUnboxedValue&& stream)
             : TBase(memInfo)
             , State_(state)
             , Stream_(stream)
@@ -833,7 +833,7 @@ private:
 
             if (state.IsFinished_)
                 return NUdf::EFetchStatus::Finish;
-            
+
             while (true) {
                 switch (Stream_.WideFetch(inputFields, inputWidth)) {
                     case NUdf::EFetchStatus::Yield:
@@ -856,7 +856,7 @@ private:
     private:
         NUdf::TUnboxedValue State_;
         NUdf::TUnboxedValue Stream_;
-    };    
+    };
 
 private:
     void RegisterDependencies() const final {
@@ -1026,7 +1026,7 @@ protected:
         const auto fill = BasicBlock::Create(context, "fill", ctx.Func);
         const auto over = BasicBlock::Create(context, "over", ctx.Func);
 
-        BranchInst::Create(make, main, IsInvalid(statePtr, block), block);
+        BranchInst::Create(make, main, IsInvalid(statePtr, block, context), block);
         block = make;
 
         const auto ptrType = PointerType::getUnqual(StructType::get(context));
@@ -1071,7 +1071,7 @@ protected:
 
         const auto valuesPtr = GetElementPtrInst::CreateInBounds(stateType, stateArg, { stateFields.This(), stateFields.GetPointer() }, "values_ptr", block);
         const auto values = new LoadInst(ptrValuesType, valuesPtr, "values", block);
-        SafeUnRefUnboxed(values, ctx, block);
+        SafeUnRefUnboxedArray(values, arrayType, ctx, block);
 
         const auto getres = GetNodeValues(flow, ctx, block);
         result->addIncoming(ConstantInt::get(statusType, static_cast<i32>(EFetchResult::Yield)), block);
@@ -1823,7 +1823,7 @@ private:
     using TBase = TComputationValue<TStreamValue>;
     public:
         TStreamValue(TMemoryUsageInfo* memInfo, const THolderFactory& holderFactory,
-                     NUdf::TUnboxedValue&& state, NUdf::TUnboxedValue&& stream) 
+                     NUdf::TUnboxedValue&& state, NUdf::TUnboxedValue&& stream)
             : TBase(memInfo)
             , State_(state)
             , Stream_(stream)
@@ -1916,7 +1916,7 @@ public:
 };
 
 template <typename TKey, typename TFixedAggState, bool UseSet, bool UseFilter>
-class TBlockCombineHashedWrapper<TKey, TFixedAggState, UseSet, UseFilter, IComputationNode> 
+class TBlockCombineHashedWrapper<TKey, TFixedAggState, UseSet, UseFilter, IComputationNode>
     : public THashedWrapperBaseFromStream<TKey, IBlockAggregatorCombineKeys, TFixedAggState, UseSet, UseFilter, false, false, TBlockCombineHashedWrapper<TKey, TFixedAggState, UseSet, UseFilter, IComputationNode>> {
 public:
     using TSelf = TBlockCombineHashedWrapper<TKey, TFixedAggState, UseSet, UseFilter, IComputationNode>;
@@ -1938,7 +1938,7 @@ template <typename TKey, typename TFixedAggState, bool UseSet, typename TInputNo
 class TBlockMergeFinalizeHashedWrapper {};
 
 template <typename TKey, typename TFixedAggState, bool UseSet>
-class TBlockMergeFinalizeHashedWrapper<TKey, TFixedAggState, UseSet, IComputationWideFlowNode> 
+class TBlockMergeFinalizeHashedWrapper<TKey, TFixedAggState, UseSet, IComputationWideFlowNode>
     : public THashedWrapperBaseFromFlow<TKey, IBlockAggregatorFinalizeKeys, TFixedAggState, UseSet, false, true, false, TBlockMergeFinalizeHashedWrapper<TKey, TFixedAggState, UseSet, IComputationWideFlowNode>> {
 public:
     using TSelf = TBlockMergeFinalizeHashedWrapper<TKey, TFixedAggState, UseSet, IComputationWideFlowNode>;
@@ -1956,7 +1956,7 @@ public:
 };
 
 template <typename TKey, typename TFixedAggState, bool UseSet>
-class TBlockMergeFinalizeHashedWrapper<TKey, TFixedAggState, UseSet, IComputationNode> 
+class TBlockMergeFinalizeHashedWrapper<TKey, TFixedAggState, UseSet, IComputationNode>
     : public THashedWrapperBaseFromStream<TKey, IBlockAggregatorFinalizeKeys, TFixedAggState, UseSet, false, true, false, TBlockMergeFinalizeHashedWrapper<TKey, TFixedAggState, UseSet, IComputationNode>> {
 public:
     using TSelf = TBlockMergeFinalizeHashedWrapper<TKey, TFixedAggState, UseSet, IComputationNode>;
@@ -1977,7 +1977,7 @@ template <typename TKey, typename TFixedAggState, typename TInputNode>
 class TBlockMergeManyFinalizeHashedWrapper {};
 
 template <typename TKey, typename TFixedAggState>
-class TBlockMergeManyFinalizeHashedWrapper<TKey, TFixedAggState, IComputationWideFlowNode> 
+class TBlockMergeManyFinalizeHashedWrapper<TKey, TFixedAggState, IComputationWideFlowNode>
     : public THashedWrapperBaseFromFlow<TKey, IBlockAggregatorFinalizeKeys, TFixedAggState, false, false, true, true, TBlockMergeManyFinalizeHashedWrapper<TKey, TFixedAggState, IComputationWideFlowNode>> {
 public:
     using TSelf = TBlockMergeManyFinalizeHashedWrapper<TKey, TFixedAggState, IComputationWideFlowNode>;
@@ -1996,7 +1996,7 @@ public:
 };
 
 template <typename TKey, typename TFixedAggState>
-class TBlockMergeManyFinalizeHashedWrapper<TKey, TFixedAggState, IComputationNode> 
+class TBlockMergeManyFinalizeHashedWrapper<TKey, TFixedAggState, IComputationNode>
     : public THashedWrapperBaseFromStream<TKey, IBlockAggregatorFinalizeKeys, TFixedAggState, false, false, true, true, TBlockMergeManyFinalizeHashedWrapper<TKey, TFixedAggState, IComputationNode>> {
 public:
     using TSelf = TBlockMergeManyFinalizeHashedWrapper<TKey, TFixedAggState, IComputationNode>;
@@ -2409,7 +2409,7 @@ IComputationNode* WrapBlockCombineHashed(TCallable& callable, const TComputation
 
 IComputationNode* WrapBlockMergeFinalizeHashed(TCallable& callable, const TComputationNodeFactoryContext& ctx) {
     MKQL_ENSURE(callable.GetInputsCount() == 3, "Expected 3 args");
-    
+
     const bool isStream = callable.GetInput(0).GetStaticType()->IsStream();
     MKQL_ENSURE(isStream == callable.GetType()->GetReturnType()->IsStream(), "input and output must be both either flow or stream");
 
diff --git a/yql/essentials/minikql/comp_nodes/mkql_block_compress.cpp b/yql/essentials/minikql/comp_nodes/mkql_block_compress.cpp
index 12a9858ba1..3db1e34a4c 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_block_compress.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_block_compress.cpp
@@ -69,7 +69,7 @@ public:
         const auto result = PHINode::Create(statusType, 3U, "result", over);
         result->addIncoming(ConstantInt::get(statusType, static_cast<i32>(EFetchResult::Finish)), block);
 
-        BranchInst::Create(over, work, IsFinish(statePtr, block), block);
+        BranchInst::Create(over, work, IsFinish(statePtr, block, context), block);
 
         block = work;
 
@@ -350,7 +350,7 @@ public:
         const auto fill = BasicBlock::Create(context, "fill", ctx.Func);
         const auto over = BasicBlock::Create(context, "over", ctx.Func);
 
-        BranchInst::Create(make, main, IsInvalid(statePtr, block), block);
+        BranchInst::Create(make, main, IsInvalid(statePtr, block, context), block);
         block = make;
 
         const auto ptrType = PointerType::getUnqual(StructType::get(context));
diff --git a/yql/essentials/minikql/comp_nodes/mkql_block_skiptake.cpp b/yql/essentials/minikql/comp_nodes/mkql_block_skiptake.cpp
index 2c29ecd4c9..f5671b2635 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_block_skiptake.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_block_skiptake.cpp
@@ -75,7 +75,7 @@ public:
         const auto load = new LoadInst(valueType, statePtr, "load", block);
         const auto state = PHINode::Create(valueType, 2U, "state", main);
         state->addIncoming(load, block);
-        BranchInst::Create(init, main, IsInvalid(load, block), block);
+        BranchInst::Create(init, main, IsInvalid(load, block, context), block);
 
         block = init;
 
@@ -296,7 +296,7 @@ public:
         const auto load = new LoadInst(valueType, statePtr, "load", block);
         const auto state = PHINode::Create(valueType, 2U, "state", main);
         state->addIncoming(load, block);
-        BranchInst::Create(init, main, IsInvalid(load, block), block);
+        BranchInst::Create(init, main, IsInvalid(load, block, context), block);
 
         block = init;
 
diff --git a/yql/essentials/minikql/comp_nodes/mkql_block_top.cpp b/yql/essentials/minikql/comp_nodes/mkql_block_top.cpp
index eca6e2af3e..cab35a232e 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_block_top.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_block_top.cpp
@@ -115,7 +115,7 @@ public:
         const auto fill = BasicBlock::Create(context, "fill", ctx.Func);
         const auto over = BasicBlock::Create(context, "over", ctx.Func);
 
-        BranchInst::Create(make, main, IsInvalid(statePtr, block), block);
+        BranchInst::Create(make, main, IsInvalid(statePtr, block, context), block);
         block = make;
 
         llvm::Value* trunc;
diff --git a/yql/essentials/minikql/comp_nodes/mkql_blocks.cpp b/yql/essentials/minikql/comp_nodes/mkql_blocks.cpp
index 2013b7efd5..f269264fa2 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_blocks.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_blocks.cpp
@@ -149,7 +149,7 @@ public:
         const auto over = BasicBlock::Create(context, "over", ctx.Func);
         const auto second_cond = BasicBlock::Create(context, "second_cond", ctx.Func);
 
-        BranchInst::Create(make, main, IsInvalid(statePtr, block), block);
+        BranchInst::Create(make, main, IsInvalid(statePtr, block, context), block);
         block = make;
 
         const auto ptrType = PointerType::getUnqual(StructType::get(context));
@@ -208,7 +208,7 @@ public:
         BranchInst::Create(second_cond, work, next, block);
 
         block = second_cond;
-        
+
         const auto read_allocated_size = new LoadInst(indexType, allocatedSizePtr, "read_allocated_size", block);
         const auto read_max_allocated_size = new LoadInst(indexType, maxAllocatedSizePtr, "read_max_allocated_size", block);
         const auto next2 = CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_ULE, read_allocated_size, read_max_allocated_size, "next2", block);
@@ -402,7 +402,7 @@ public:
         const auto init = BasicBlock::Create(context, "init", ctx.Func);
         const auto done = BasicBlock::Create(context, "done", ctx.Func);
 
-        BranchInst::Create(make, work, IsInvalid(statePtr, block), block);
+        BranchInst::Create(make, work, IsInvalid(statePtr, block, context), block);
         block = make;
 
         const auto ptrType = PointerType::getUnqual(StructType::get(context));
@@ -427,14 +427,14 @@ public:
         const auto result = PHINode::Create(valueType, 2U, "result", done);
         result->addIncoming(value, block);
 
-        BranchInst::Create(read, done, IsInvalid(value, block), block);
+        BranchInst::Create(read, done, IsInvalid(value, block, context), block);
 
         block = read;
 
         const auto input = GetNodeValue(Flow_, ctx, block);
         result->addIncoming(input, block);
 
-        BranchInst::Create(done, init, IsSpecial(input, block), block);
+        BranchInst::Create(done, init, IsSpecial(input, block, context), block);
 
         block = init;
 
@@ -587,7 +587,7 @@ public:
         const auto work = BasicBlock::Create(context, "work", ctx.Func);
         const auto over = BasicBlock::Create(context, "over", ctx.Func);
 
-        BranchInst::Create(make, main, IsInvalid(statePtr, block), block);
+        BranchInst::Create(make, main, IsInvalid(statePtr, block, context), block);
         block = make;
 
         const auto ptrType = PointerType::getUnqual(StructType::get(context));
@@ -674,7 +674,7 @@ public:
                 const auto index = ConstantInt::get(indexType, idx);
                 const auto pointer = GetElementPtrInst::CreateInBounds(arrayType, values, {  ConstantInt::get(indexType, 0), index }, "pointer", block);
 
-                BranchInst::Create(call, init, HasValue(pointer, block), block);
+                BranchInst::Create(call, init, HasValue(pointer, block, context), block);
 
                 block = init;
 
@@ -1043,7 +1043,7 @@ public:
         const auto fill = BasicBlock::Create(context, "fill", ctx.Func);
         const auto over = BasicBlock::Create(context, "over", ctx.Func);
 
-        BranchInst::Create(make, main, IsInvalid(statePtr, block), block);
+        BranchInst::Create(make, main, IsInvalid(statePtr, block, context), block);
         block = make;
 
         const auto ptrType = PointerType::getUnqual(StructType::get(context));
@@ -1173,7 +1173,7 @@ public:
             }
             s.FillArrays();
         }
-        
+
         const auto sliceSize = s.Slice();
         for (size_t i = 0; i < width; ++i) {
             output[i] = s.Get(sliceSize, HolderFactory_, i);
diff --git a/yql/essentials/minikql/comp_nodes/mkql_chain1_map.cpp b/yql/essentials/minikql/comp_nodes/mkql_chain1_map.cpp
index ef0781aa9c..c12d9917c5 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_chain1_map.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_chain1_map.cpp
@@ -68,7 +68,7 @@ public:
 
         const auto item = GetNodeValue(Flow, ctx, block);
         result->addIncoming(item, block);
-        BranchInst::Create(done, good, IsSpecial(item, block), block);
+        BranchInst::Create(done, good, IsSpecial(item, block, context), block);
 
         block = good;
         codegenItemArg->CreateSetValue(ctx, block, item);
@@ -77,7 +77,7 @@ public:
         const auto next = BasicBlock::Create(context, "next", ctx.Func);
 
         const auto state = new LoadInst(valueType, statePtr, "load", block);
-        BranchInst::Create(init, next, IsInvalid(state, block), block);
+        BranchInst::Create(init, next, IsInvalid(state, block, context), block);
 
         block = init;
         const auto one = GetNodeValue(ComputationNodes.InitItem, ctx, block);
@@ -247,7 +247,6 @@ public:
         ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
         DISubprogramAnnotator annotator(ctx, ctx.Func);
-        
 
         auto args = ctx.Func->arg_begin();
 
@@ -276,7 +275,7 @@ public:
         BranchInst::Create(done, good, icmp, block);
         block = good;
 
-        SafeUnRefUnboxed(valuePtr, ctx, block);
+        SafeUnRefUnboxedOne(valuePtr, ctx, block);
         GetNodeValue(valuePtr, newItem, ctx, block);
 
         const auto nextState = GetNodeValue(newState, ctx, block);
diff --git a/yql/essentials/minikql/comp_nodes/mkql_chain_map.cpp b/yql/essentials/minikql/comp_nodes/mkql_chain_map.cpp
index 2511d45ee9..e0d9ff1f13 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_chain_map.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_chain_map.cpp
@@ -58,7 +58,7 @@ public:
         const auto work = BasicBlock::Create(context, "work", ctx.Func);
 
         const auto state = new LoadInst(valueType, statePtr, "load", block);
-        BranchInst::Create(init, work, IsInvalid(state, block), block);
+        BranchInst::Create(init, work, IsInvalid(state, block, context), block);
 
         block = init;
         new StoreInst(GetTrue(context), statePtr, block);
@@ -74,7 +74,7 @@ public:
 
         const auto item = GetNodeValue(Flow, ctx, block);
         result->addIncoming(item, block);
-        BranchInst::Create(done, good, IsSpecial(item, block), block);
+        BranchInst::Create(done, good, IsSpecial(item, block, context), block);
 
         block = good;
         codegenItemArg->CreateSetValue(ctx, block, item);
@@ -239,7 +239,6 @@ public:
         ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
         DISubprogramAnnotator annotator(ctx, ctx.Func);
-        
 
         auto args = ctx.Func->arg_begin();
 
@@ -258,7 +257,7 @@ public:
         const auto work = BasicBlock::Create(context, "work", ctx.Func);
 
         const auto load = new LoadInst(valueType, initArg, "load", block);
-        BranchInst::Create(work, init, IsInvalid(load, block), block);
+        BranchInst::Create(work, init, IsInvalid(load, block, context), block);
         block = init;
 
         codegenStateArg->CreateSetValue(ctx, block, initArg);
@@ -282,7 +281,7 @@ public:
         BranchInst::Create(done, good, icmp, block);
         block = good;
 
-        SafeUnRefUnboxed(valuePtr, ctx, block);
+        SafeUnRefUnboxedOne(valuePtr, ctx, block);
         GetNodeValue(valuePtr, ComputationNodes.NewItem, ctx, block);
 
         const auto newState = GetNodeValue(ComputationNodes.NewState, ctx, block);
diff --git a/yql/essentials/minikql/comp_nodes/mkql_chopper.cpp b/yql/essentials/minikql/comp_nodes/mkql_chopper.cpp
index eb35832883..f3b5aecf0b 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_chopper.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_chopper.cpp
@@ -130,7 +130,6 @@ private:
         ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
         DISubprogramAnnotator annotator(ctx, ctx.Func);
-        
 
         const auto main = BasicBlock::Create(context, "main", ctx.Func);
         ctx.Ctx = &*ctx.Func->arg_begin();
@@ -163,7 +162,7 @@ private:
 
             const auto item = GetNodeValue(Flow, ctx, block);
 
-            BranchInst::Create(exit, good, IsSpecial(item, block), block);
+            BranchInst::Create(exit, good, IsSpecial(item, block, context), block);
 
             block = good;
 
@@ -217,7 +216,7 @@ public:
 
             const auto item = GetNodeValue(Flow, ctx, block);
             result->addIncoming(item, block);
-            BranchInst::Create(exit, next, IsSpecial(item, block), block);
+            BranchInst::Create(exit, next, IsSpecial(item, block, context), block);
 
             block = next;
 
@@ -241,7 +240,7 @@ public:
             const auto state = new LoadInst(valueType, statePtr, "state", block);
 
             result->addIncoming(item, block);
-            BranchInst::Create(part, exit, IsFinish(item, block), block);
+            BranchInst::Create(part, exit, IsFinish(item, block, context), block);
 
             block = part;
 
@@ -565,7 +564,6 @@ private:
         ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
         DISubprogramAnnotator annotator(ctx, ctx.Func);
-        
 
         auto args = ctx.Func->arg_begin();
 
@@ -592,7 +590,7 @@ private:
             block = load;
 
             new StoreInst(ConstantInt::get(stateType, ui8(EState::Work)), stateArg, block);
-            SafeUnRefUnboxed(valuePtr, ctx, block);
+            SafeUnRefUnboxedOne(valuePtr, ctx, block);
             GetNodeValue(valuePtr, ItemArg, ctx, block);
             ReturnInst::Create(context, ConstantInt::get(statusType, ui32(NUdf::EFetchStatus::Ok)), block);
         }
@@ -624,7 +622,7 @@ private:
 
             block = pass;
 
-            SafeUnRefUnboxed(valuePtr, ctx, block);
+            SafeUnRefUnboxedOne(valuePtr, ctx, block);
             GetNodeValue(valuePtr, ItemArg, ctx, block);
             BranchInst::Create(exit, block);
 
@@ -662,7 +660,6 @@ private:
         ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
         DISubprogramAnnotator annotator(ctx, ctx.Func);
-        
 
         auto args = ctx.Func->arg_begin();
 
@@ -691,7 +688,7 @@ private:
         block = loop;
 
         const auto stream = new LoadInst(valueType, streamArg, "stream", block);
-        BranchInst::Create(next, work, IsEmpty(stream, block), block);
+        BranchInst::Create(next, work, IsEmpty(stream, block, context), block);
 
         {
             const auto good = BasicBlock::Create(context, "good", ctx.Func);
diff --git a/yql/essentials/minikql/comp_nodes/mkql_coalesce.cpp b/yql/essentials/minikql/comp_nodes/mkql_coalesce.cpp
index d88b6d71bb..d86628650e 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_coalesce.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_coalesce.cpp
@@ -37,7 +37,7 @@ public:
 
         const auto result = PHINode::Create(left->getType(), 2, "result", done);
 
-        BranchInst::Create(good, null, IsExists(left, block), block);
+        BranchInst::Create(good, null, IsExists(left, block, context), block);
 
         block = null;
         const auto right = GetNodeValue(this->Right, ctx, block);
diff --git a/yql/essentials/minikql/comp_nodes/mkql_combine.cpp b/yql/essentials/minikql/comp_nodes/mkql_combine.cpp
index 3b1141ba9f..dffe2e1c5a 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_combine.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_combine.cpp
@@ -272,7 +272,7 @@ public:
         const auto main = BasicBlock::Create(context, "main", ctx.Func);
         const auto more = BasicBlock::Create(context, "more", ctx.Func);
 
-        BranchInst::Create(make, main, IsInvalid(statePtr, block), block);
+        BranchInst::Create(make, main, IsInvalid(statePtr, block, context), block);
         block = make;
 
         const auto ptrType = PointerType::getUnqual(StructType::get(context));
@@ -338,8 +338,8 @@ public:
 
             const auto item = GetNodeValue(Flow, ctx, block);
 
-            const auto finsh = IsFinish(item, block);
-            const auto yield = IsYield(item, block);
+            const auto finsh = IsFinish(item, block, context);
+            const auto yield = IsYield(item, block, context);
             const auto special = BinaryOperator::CreateOr(finsh, yield, "special", block);
 
             const auto fin = SelectInst::Create(finsh, ConstantInt::get(statusType, static_cast<ui32>(NUdf::EFetchStatus::Finish)), ConstantInt::get(statusType, static_cast<ui32>(NUdf::EFetchStatus::Ok)), "fin", block);
@@ -370,7 +370,7 @@ public:
             const auto next = BasicBlock::Create(context, "next", ctx.Func);
             const auto test = BasicBlock::Create(context, "test", ctx.Func);
 
-            BranchInst::Create(init, next, IsInvalid(place, block), block);
+            BranchInst::Create(init, next, IsInvalid(place, block, context), block);
 
             block = init;
             GetNodeValue(place, Nodes.InitResultNode, ctx, block);
@@ -421,7 +421,7 @@ public:
             } else if constexpr (StateContainerOpt) {
                 const auto exit = BasicBlock::Create(context, "exit", ctx.Func);
 
-                BranchInst::Create(more, exit, IsEmpty(value, block), block);
+                BranchInst::Create(more, exit, IsEmpty(value, block, context), block);
                 block = exit;
 
                 const auto strip = GetOptionalValue(context, value, block);
@@ -429,7 +429,7 @@ public:
                 BranchInst::Create(over, block);
             } else {
                 result->addIncoming(value, block);
-                BranchInst::Create(more, over, IsEmpty(value, block), block);
+                BranchInst::Create(more, over, IsEmpty(value, block, context), block);
             }
         }
 
@@ -457,7 +457,7 @@ public:
         block = more;
 
         const auto current = new LoadInst(valueType, currentPtr, "current", block);
-        BranchInst::Create(pull, skip, HasValue(current, block), block);
+        BranchInst::Create(pull, skip, HasValue(current, block, context), block);
 
         {
             const auto good = BasicBlock::Create(context, "good", ctx.Func);
@@ -495,7 +495,7 @@ public:
 
             const auto list = DoGenerateGetValue(ctx, statePtr, block);
             result->addIncoming(list, block);
-            BranchInst::Create(over, good, IsSpecial(list, block),  block);
+            BranchInst::Create(over, good, IsSpecial(list, block, context),  block);
 
             block = good;
             if constexpr (StateContainerOpt) {
@@ -738,7 +738,6 @@ private:
         ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
         DISubprogramAnnotator annotator(ctx, ctx.Func);
-        
 
         auto args = ctx.Func->arg_begin();
 
@@ -768,7 +767,7 @@ private:
             const auto skip = BasicBlock::Create(context, "skip", ctx.Func);
 
             const auto current = new LoadInst(valueType, currArg, "current", block);
-            BranchInst::Create(skip, pull, IsEmpty(current, block), block);
+            BranchInst::Create(skip, pull, IsEmpty(current, block, context), block);
 
             block = pull;
 
@@ -867,7 +866,7 @@ private:
             const auto next = BasicBlock::Create(context, "next", ctx.Func);
             const auto test = BasicBlock::Create(context, "test", ctx.Func);
 
-            BranchInst::Create(init, next, IsInvalid(place, block), block);
+            BranchInst::Create(init, next, IsInvalid(place, block, context), block);
 
             block = init;
             GetNodeValue(place, Nodes.InitResultNode, ctx, block);
@@ -923,12 +922,12 @@ private:
                     BranchInst::Create(more, block);
                 }
             } else {
-                SafeUnRefUnboxed(valuePtr, ctx, block);
+                SafeUnRefUnboxedOne(valuePtr, ctx, block);
                 GetNodeValue(valuePtr, Nodes.FinishResultNode, ctx, block);
                 const auto value = new LoadInst(valueType, valuePtr, "value", block);
 
                 const auto exit = BasicBlock::Create(context, "exit", ctx.Func);
-                BranchInst::Create(more, exit, IsEmpty(value, block), block);
+                BranchInst::Create(more, exit, IsEmpty(value, block, context), block);
 
                 block = exit;
 
diff --git a/yql/essentials/minikql/comp_nodes/mkql_condense.cpp b/yql/essentials/minikql/comp_nodes/mkql_condense.cpp
index 74896f5876..f7c2623273 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_condense.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_condense.cpp
@@ -140,7 +140,7 @@ public:
             const auto reset = GetNodeValue(Switch, ctx, block);
             if constexpr (Interruptable) {
                 const auto next = BasicBlock::Create(context, "next", ctx.Func);
-                BranchInst::Create(stop, next, IsEmpty(reset, block), block);
+                BranchInst::Create(stop, next, IsEmpty(reset, block, context), block);
                 block = next;
             }
 
@@ -362,7 +362,6 @@ private:
         ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
         DISubprogramAnnotator annotator(ctx, ctx.Func);
-        
 
         auto args = ctx.Func->arg_begin();
 
@@ -460,7 +459,7 @@ private:
             block = swap;
 
             new StoreInst(ConstantInt::get(state->getType(), static_cast<ui8>(ESqueezeState::NeedInit)), statePtr, block);
-            SafeUnRefUnboxed(valuePtr, ctx, block);
+            SafeUnRefUnboxedOne(valuePtr, ctx, block);
             const auto state = codegenStateArg->CreateGetValue(ctx, block);
             new StoreInst(state, valuePtr, block);
             ValueAddRef(State.State->GetRepresentation(), valuePtr, ctx, block);
@@ -474,7 +473,7 @@ private:
 
         block = stop;
         new StoreInst(ConstantInt::get(state->getType(), static_cast<ui8>(ESqueezeState::Finished)), statePtr, block);
-        SafeUnRefUnboxed(valuePtr, ctx, block);
+        SafeUnRefUnboxedOne(valuePtr, ctx, block);
         const auto result = codegenStateArg->CreateGetValue(ctx, block);
         new StoreInst(result, valuePtr, block);
         ValueAddRef(State.State->GetRepresentation(), valuePtr, ctx, block);
diff --git a/yql/essentials/minikql/comp_nodes/mkql_condense1.cpp b/yql/essentials/minikql/comp_nodes/mkql_condense1.cpp
index afaa628947..1cf679ed07 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_condense1.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_condense1.cpp
@@ -117,7 +117,7 @@ public:
 
         block = frst;
 
-        const auto invalid = IsInvalid(state, block);
+        const auto invalid = IsInvalid(state, block, context);
         const auto empty = PHINode::Create(invalid->getType(), 3U, "empty", work);
         empty->addIncoming(invalid, block);
         BranchInst::Create(work, block);
@@ -151,7 +151,7 @@ public:
             const auto reset = GetNodeValue(Switch, ctx, block);
             if constexpr (Interruptable) {
                 const auto pass = BasicBlock::Create(context, "pass", ctx.Func);
-                BranchInst::Create(stop, pass, IsEmpty(reset, block), block);
+                BranchInst::Create(stop, pass, IsEmpty(reset, block, context), block);
                 block = pass;
             }
 
@@ -380,7 +380,6 @@ private:
         ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
         DISubprogramAnnotator annotator(ctx, ctx.Func);
-        
 
         auto args = ctx.Func->arg_begin();
 
@@ -480,7 +479,7 @@ private:
 
             block = swap;
             new StoreInst(ConstantInt::get(state1->getType(), static_cast<ui8>(ESqueezeState::NeedInit)), statePtr, block);
-            SafeUnRefUnboxed(valuePtr, ctx, block);
+            SafeUnRefUnboxedOne(valuePtr, ctx, block);
             const auto state = codegenStateArg->CreateGetValue(ctx, block);
             new StoreInst(state, valuePtr, block);
             ValueAddRef(State.State->GetRepresentation(), valuePtr, ctx, block);
@@ -509,7 +508,7 @@ private:
 
         block = fill;
 
-        SafeUnRefUnboxed(valuePtr, ctx, block);
+        SafeUnRefUnboxedOne(valuePtr, ctx, block);
         const auto result = codegenStateArg->CreateGetValue(ctx, block);
         new StoreInst(result, valuePtr, block);
         ValueAddRef(State.State->GetRepresentation(), valuePtr, ctx, block);
diff --git a/yql/essentials/minikql/comp_nodes/mkql_decimal_div.cpp b/yql/essentials/minikql/comp_nodes/mkql_decimal_div.cpp
index 8ab255a80b..394ddbc4f5 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_decimal_div.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_decimal_div.cpp
@@ -69,7 +69,7 @@ public:
             const auto result = PHINode::Create(valType, 2, "result", done);
             result->addIncoming(test, block);
 
-            BranchInst::Create(done, good, IsEmpty(test, block), block);
+            BranchInst::Create(done, good, IsEmpty(test, block, context), block);
 
             block = good;
 
@@ -191,7 +191,7 @@ public:
             const auto result = PHINode::Create(valType, 2, "result", done);
             result->addIncoming(test, block);
 
-            BranchInst::Create(done, good, IsEmpty(test, block), block);
+            BranchInst::Create(done, good, IsEmpty(test, block, context), block);
 
             block = good;
 
diff --git a/yql/essentials/minikql/comp_nodes/mkql_decimal_mod.cpp b/yql/essentials/minikql/comp_nodes/mkql_decimal_mod.cpp
index f9d51058c2..9703e413b7 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_decimal_mod.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_decimal_mod.cpp
@@ -53,7 +53,7 @@ public:
                 IsLeftOptional ? left : right;
 
             result->addIncoming(zero, block);
-            BranchInst::Create(done, good, IsEmpty(test, block), block);
+            BranchInst::Create(done, good, IsEmpty(test, block, context), block);
 
             block = good;
 
@@ -156,7 +156,7 @@ public:
                 IsLeftOptional ? left : right;
 
             result->addIncoming(zero, block);
-            BranchInst::Create(done, good, IsEmpty(test, block), block);
+            BranchInst::Create(done, good, IsEmpty(test, block, context), block);
 
             block = good;
 
diff --git a/yql/essentials/minikql/comp_nodes/mkql_decimal_mul.cpp b/yql/essentials/minikql/comp_nodes/mkql_decimal_mul.cpp
index 22b879a7e0..a92f8fa879 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_decimal_mul.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_decimal_mul.cpp
@@ -76,7 +76,7 @@ public:
             const auto result = PHINode::Create(valType, 2, "result", done);
             result->addIncoming(test, block);
 
-            BranchInst::Create(done, good, IsEmpty(test, block), block);
+            BranchInst::Create(done, good, IsEmpty(test, block, context), block);
 
             block = good;
 
@@ -229,7 +229,7 @@ public:
             const auto result = PHINode::Create(valType, 2, "result", done);
             result->addIncoming(test, block);
 
-            BranchInst::Create(done, good, IsEmpty(test, block), block);
+            BranchInst::Create(done, good, IsEmpty(test, block, context), block);
 
             block = good;
 
diff --git a/yql/essentials/minikql/comp_nodes/mkql_dictitems.cpp b/yql/essentials/minikql/comp_nodes/mkql_dictitems.cpp
index 620e1e8b6a..54d839e9c7 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_dictitems.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_dictitems.cpp
@@ -168,7 +168,6 @@ private:
         ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
         DISubprogramAnnotator annotator(ctx, ctx.Func);
-        
 
         auto args = ctx.Func->arg_begin();
 
@@ -196,7 +195,7 @@ private:
         BranchInst::Create(good, done, status, block);
         block = good;
 
-        SafeUnRefUnboxed(valuePtr, ctx, block);
+        SafeUnRefUnboxedOne(valuePtr, ctx, block);
 
         const auto itemsType = PointerType::getUnqual(pairType);
         const auto itemsPtr = new AllocaInst(itemsType, 0U, "items_ptr", block);
diff --git a/yql/essentials/minikql/comp_nodes/mkql_discard.cpp b/yql/essentials/minikql/comp_nodes/mkql_discard.cpp
index 758f9affbd..1fbbf6ac61 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_discard.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_discard.cpp
@@ -36,7 +36,7 @@ public:
 
         block = loop;
         const auto item = GetNodeValue(Flow, ctx, block);
-        BranchInst::Create(exit, skip, IsSpecial(item, block), block);
+        BranchInst::Create(exit, skip, IsSpecial(item, block, context), block);
 
         block = skip;
         ValueCleanup(Flow->GetRepresentation(), item, ctx, block);
@@ -176,7 +176,6 @@ private:
         ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
         DISubprogramAnnotator annotator(ctx, ctx.Func);
-        
 
         auto args = ctx.Func->arg_begin();
 
diff --git a/yql/essentials/minikql/comp_nodes/mkql_element.cpp b/yql/essentials/minikql/comp_nodes/mkql_element.cpp
index ec9f399f5c..58ab35d803 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_element.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_element.cpp
@@ -38,7 +38,7 @@ public:
 
             const auto result = PHINode::Create(array->getType(), 2U, "result", done);
             result->addIncoming(ConstantInt::get(array->getType(), 0ULL), block);
-            BranchInst::Create(done, good, IsEmpty(array, block), block);
+            BranchInst::Create(done, good, IsEmpty(array, block, context), block);
 
             block = good;
             const auto elements = CallBoxedValueVirtualMethod<NUdf::TBoxedValueAccessor::EMethod::GetElements>(elementsType, array, ctx.Codegen, block);
@@ -102,7 +102,7 @@ public:
             const auto zero = BasicBlock::Create(context, "zero", ctx.Func);
             const auto exit = BasicBlock::Create(context, "exit", ctx.Func);
 
-            BranchInst::Create(zero, good, IsEmpty(array, block), block);
+            BranchInst::Create(zero, good, IsEmpty(array, block, context), block);
 
             block = zero;
             new StoreInst(ConstantInt::get(array->getType(), 0ULL), pointer, block);
diff --git a/yql/essentials/minikql/comp_nodes/mkql_exists.cpp b/yql/essentials/minikql/comp_nodes/mkql_exists.cpp
index 9a90aa9546..7dac8c6386 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_exists.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_exists.cpp
@@ -20,10 +20,11 @@ public:
 
 #ifndef MKQL_DISABLE_CODEGEN
     Value* DoGenerateGetValue(const TCodegenContext& ctx, Value* value, BasicBlock*& block) const {
-        const auto check = IsExists(value, block);
+        auto& context = ctx.Codegen.GetContext();
+        const auto check = IsExists(value, block, context);
         if (Node->IsTemporaryValue())
             ValueCleanup(Node->GetRepresentation(), value, ctx, block);
-        return MakeBoolean(check, ctx.Codegen.GetContext(), block);
+        return MakeBoolean(check, context, block);
     }
 #endif
 };
diff --git a/yql/essentials/minikql/comp_nodes/mkql_extend.cpp b/yql/essentials/minikql/comp_nodes/mkql_extend.cpp
index 3afdef9f8b..75033de49d 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_extend.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_extend.cpp
@@ -113,7 +113,7 @@ public:
         const auto over = BasicBlock::Create(context, "over", ctx.Func);
         const auto done = BasicBlock::Create(context, "done", ctx.Func);
 
-        BranchInst::Create(make, main, IsInvalid(statePtr, block), block);
+        BranchInst::Create(make, main, IsInvalid(statePtr, block, context), block);
         block = make;
 
         const auto ptrType = PointerType::getUnqual(StructType::get(context));
@@ -259,7 +259,7 @@ public:
         const auto over = BasicBlock::Create(context, "over", ctx.Func);
         const auto done = BasicBlock::Create(context, "done", ctx.Func);
 
-        BranchInst::Create(make, main, IsInvalid(statePtr, block), block);
+        BranchInst::Create(make, main, IsInvalid(statePtr, block, context), block);
         block = make;
 
         const auto ptrType = PointerType::getUnqual(StructType::get(context));
@@ -379,7 +379,7 @@ public:
         const auto done = BasicBlock::Create(context, "done", ctx.Func);
 
         const auto load = new LoadInst(valueType, statePtr, "load", block);
-        const auto start = SelectInst::Create(IsInvalid(load, block), ConstantInt::get(indexType, 0ULL), GetterFor<ui64>(load, context, block), "start", block);
+        const auto start = SelectInst::Create(IsInvalid(load, block, context), ConstantInt::get(indexType, 0ULL), GetterFor<ui64>(load, context, block), "start", block);
         const auto index = PHINode::Create(indexType, 2U, "index", main);
         index->addIncoming(start, block);
 
@@ -479,7 +479,7 @@ public:
         const auto indexType = Type::getInt64Ty(context);
 
         const auto load = new LoadInst(valueType, statePtr, "load", block);
-        const auto state = SelectInst::Create(IsInvalid(load, block), ConstantInt::get(indexType, 0ULL), GetterFor<ui64>(load, context, block), "index", block);
+        const auto state = SelectInst::Create(IsInvalid(load, block, context), ConstantInt::get(indexType, 0ULL), GetterFor<ui64>(load, context, block), "index", block);
 
         const auto main = BasicBlock::Create(context, "main", ctx.Func);
         const auto next = BasicBlock::Create(context, "next", ctx.Func);
@@ -503,7 +503,7 @@ public:
             block = flow;
             const auto item = GetNodeValue(Flows_[i], ctx, block);
             result->addIncoming(item, block);
-            BranchInst::Create(next, done, IsFinish(item, block), block);
+            BranchInst::Create(next, done, IsFinish(item, block, context), block);
         }
 
         block = next;
diff --git a/yql/essentials/minikql/comp_nodes/mkql_filter.cpp b/yql/essentials/minikql/comp_nodes/mkql_filter.cpp
index 2d7a73c00a..5e8993db57 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_filter.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_filter.cpp
@@ -39,7 +39,7 @@ public:
 
         block = loop;
         const auto item = GetNodeValue(Flow, ctx, block);
-        BranchInst::Create(exit, good, IsSpecial(item, block), block);
+        BranchInst::Create(exit, good, IsSpecial(item, block, context), block);
 
         block = good;
         codegenItem->CreateSetValue(ctx, block, item);
@@ -107,7 +107,7 @@ public:
         const auto valueType = Type::getInt128Ty(context);
         const auto result = PHINode::Create(valueType, 3U, "result", exit);
 
-        BranchInst::Create(init, test, IsInvalid(statePtr, block), block);
+        BranchInst::Create(init, test, IsInvalid(statePtr, block, context), block);
 
         block = init;
 
@@ -124,7 +124,7 @@ public:
         block = loop;
         const auto item = GetNodeValue(Flow, ctx, block);
         result->addIncoming(item, block);
-        BranchInst::Create(exit, step, IsSpecial(item, block), block);
+        BranchInst::Create(exit, step, IsSpecial(item, block, context), block);
 
         block = step;
         codegenItem->CreateSetValue(ctx, block, item);
@@ -289,7 +289,6 @@ protected:
         ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
         DISubprogramAnnotator annotator(ctx, ctx.Func);
-        
 
         auto args = ctx.Func->arg_begin();
 
@@ -330,7 +329,7 @@ protected:
         BranchInst::Create(pass, loop, boolPred, block);
         block = pass;
 
-        SafeUnRefUnboxed(valuePtr, ctx, block);
+        SafeUnRefUnboxedOne(valuePtr, ctx, block);
         new StoreInst(item, valuePtr, block);
         ValueAddRef(Item->GetRepresentation(), valuePtr, ctx, block);
         BranchInst::Create(done, block);
@@ -498,7 +497,6 @@ protected:
         ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
         DISubprogramAnnotator annotator(ctx, ctx.Func);
-        
 
         auto args = ctx.Func->arg_begin();
 
@@ -553,7 +551,7 @@ protected:
         const auto decr = BinaryOperator::CreateSub(limit, ConstantInt::get(limit->getType(), 1ULL), "decr", block);
         new StoreInst(decr, limitArg, block);
 
-        SafeUnRefUnboxed(valuePtr, ctx, block);
+        SafeUnRefUnboxedOne(valuePtr, ctx, block);
         new StoreInst(item, valuePtr, block);
         ValueAddRef(Item->GetRepresentation(), valuePtr, ctx, block);
         BranchInst::Create(done, block);
diff --git a/yql/essentials/minikql/comp_nodes/mkql_flatmap.cpp b/yql/essentials/minikql/comp_nodes/mkql_flatmap.cpp
index a8ada682d7..dc1d9a7472 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_flatmap.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_flatmap.cpp
@@ -67,7 +67,7 @@ public:
 
         const auto item = GetNodeValue(Flow, ctx, block);
         result->addIncoming(item, block);
-        BranchInst::Create(exit, next, IsSpecial(item, block), block);
+        BranchInst::Create(exit, next, IsSpecial(item, block, context), block);
 
         block = next;
 
@@ -160,9 +160,9 @@ public:
         block = init;
 
         const auto item = GetNodeValue(Flow, ctx, block);
-        const auto outres = SelectInst::Create(IsFinish(item, block), ConstantInt::get(resultType, i32(EFetchResult::Finish)), ConstantInt::get(resultType, i32(EFetchResult::Yield)), "outres", block);
+        const auto outres = SelectInst::Create(IsFinish(item, block, context), ConstantInt::get(resultType, i32(EFetchResult::Finish)), ConstantInt::get(resultType, i32(EFetchResult::Yield)), "outres", block);
         result->addIncoming(outres, block);
-        BranchInst::Create(exit, next, IsSpecial(item, block), block);
+        BranchInst::Create(exit, next, IsSpecial(item, block, context), block);
 
         block = next;
 
@@ -277,7 +277,7 @@ public:
 
         const auto output = GetNodeValue(Output, ctx, block);
         result->addIncoming(output, block);
-        BranchInst::Create(next, exit, IsFinish(output, block), block);
+        BranchInst::Create(next, exit, IsFinish(output, block, context), block);
 
         block = done;
 
@@ -598,13 +598,13 @@ public:
         const auto result = PHINode::Create(item->getType(), 2, "result", exit);
 
         result->addIncoming(item, block);
-        BranchInst::Create(exit, work, IsSpecial(item, block), block);
+        BranchInst::Create(exit, work, IsSpecial(item, block, context), block);
 
         block = work;
         codegenItem->CreateSetValue(ctx, block, item);
         const auto value = GetNodeValue(NewItem, ctx, block);
         result->addIncoming(!IsMultiRowPerItem && ResultContainerOpt ? GetOptionalValue(context, value, block) : value, block);
-        BranchInst::Create(loop, exit, IsEmpty(value, block), block);
+        BranchInst::Create(loop, exit, IsEmpty(value, block, context), block);
 
         block = exit;
         return result;
@@ -630,7 +630,7 @@ public:
         block = more;
 
         const auto current = new LoadInst(valueType, currentPtr, "current", block);
-        BranchInst::Create(pull, skip, HasValue(current, block), block);
+        BranchInst::Create(pull, skip, HasValue(current, block, context), block);
 
         {
             const auto good = BasicBlock::Create(context, "good", ctx.Func);
@@ -668,7 +668,7 @@ public:
 
             const auto list = DoGenerateGetValue(ctx, block);
             result->addIncoming(list, block);
-            BranchInst::Create(over, good, IsSpecial(list, block),  block);
+            BranchInst::Create(over, good, IsSpecial(list, block, context),  block);
 
             block = good;
             if constexpr (ResultContainerOpt) {
@@ -803,7 +803,7 @@ public:
         }
 
         result->addIncoming(!IsMultiRowPerItem && ResultContainerOpt ? GetOptionalValue(context, value, block) : value, block);
-        BranchInst::Create(loop, exit, IsEmpty(value, block), block);
+        BranchInst::Create(loop, exit, IsEmpty(value, block, context), block);
 
         block = exit;
         return result;
@@ -829,7 +829,7 @@ public:
         block = more;
 
         const auto current = new LoadInst(valueType, currentPtr, "current", block);
-        BranchInst::Create(pull, skip, HasValue(current, block), block);
+        BranchInst::Create(pull, skip, HasValue(current, block, context), block);
 
         {
             const auto good = BasicBlock::Create(context, "good", ctx.Func);
@@ -867,7 +867,7 @@ public:
 
             const auto list = DoGenerateGetValue(ctx, block);
             result->addIncoming(list, block);
-            BranchInst::Create(over, good, IsSpecial(list, block),  block);
+            BranchInst::Create(over, good, IsSpecial(list, block, context),  block);
 
             block = good;
             if constexpr (ResultContainerOpt) {
@@ -1179,7 +1179,6 @@ protected:
         ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
         DISubprogramAnnotator annotator(ctx, ctx.Func);
-        
 
         auto args = ctx.Func->arg_begin();
 
@@ -1215,11 +1214,11 @@ protected:
 
         const auto resItem = GetNodeValue(NewItem, ctx, block);
 
-        BranchInst::Create(loop, pass, IsEmpty(resItem, block), block);
+        BranchInst::Create(loop, pass, IsEmpty(resItem, block, context), block);
 
         block = pass;
 
-        SafeUnRefUnboxed(valuePtr, ctx, block);
+        SafeUnRefUnboxedOne(valuePtr, ctx, block);
         const auto getOpt = GetOptionalValue(context, resItem, block);
         new StoreInst(getOpt, valuePtr, block);
         ValueAddRef(NewItem->GetRepresentation(), valuePtr, ctx, block);
@@ -1253,7 +1252,6 @@ protected:
         ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
         DISubprogramAnnotator annotator(ctx, ctx.Func);
-        
 
         auto args = ctx.Func->arg_begin();
 
@@ -1545,7 +1543,7 @@ public:
                 const auto plus = BinaryOperator::CreateAdd(idx, plusSize, "plus", block);
                 const auto load = new LoadInst(list->getType(), dst, "load", block);
                 new StoreInst(GetOptionalValue(context, load, block), dst, block);
-                const auto move = SelectInst::Create(IsExists(load, block), plus, idx, "move", block);
+                const auto move = SelectInst::Create(IsExists(load, block, context), plus, idx, "move", block);
                 idx->addIncoming(move, block);
             }
 
@@ -1572,7 +1570,8 @@ public:
                 const auto bytes = BinaryOperator::CreateShl(idx, ConstantInt::get(idx->getType(), 4), "bytes", block);
 
                 const auto fnType = FunctionType::get(Type::getVoidTy(context), {pType, pType, bytes->getType(), Type::getInt1Ty(context)}, false);
-                const auto func = ctx.Codegen.GetModule().getOrInsertFunction("llvm.memcpy.p0i8.p0i8.i64", fnType);
+                const auto memcpyName = (LLVM_VERSION_MAJOR < 16) ? "llvm.memcpy.p0i8.p0i8.i64" : "llvm.memcpy.p0.p0.i64";
+                const auto func = ctx.Codegen.GetModule().getOrInsertFunction(memcpyName, fnType);
                 CallInst::Create(func, {pdst, psrc, bytes, ConstantInt::getFalse(context)}, "", block);
             } else {
                 const auto factory = ctx.GetFactory();
diff --git a/yql/essentials/minikql/comp_nodes/mkql_flow.cpp b/yql/essentials/minikql/comp_nodes/mkql_flow.cpp
index f195a8991f..761e5f5510 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_flow.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_flow.cpp
@@ -45,7 +45,7 @@ public:
         const auto state = PHINode::Create(load->getType(), 2U, "state", main);
         state->addIncoming(load, block);
 
-        BranchInst::Create(init, main, IsInvalid(load, block), block);
+        BranchInst::Create(init, main, IsInvalid(load, block, context), block);
 
         block = init;
 
@@ -142,7 +142,7 @@ public:
         const auto result = PHINode::Create(valueType, 2U, "state", done);
 
         result->addIncoming(load, block);
-        BranchInst::Create(done, main, IsFinish(load, block), block);
+        BranchInst::Create(done, main, IsFinish(load, block, context), block);
 
         block = main;
 
@@ -151,7 +151,7 @@ public:
 
         const auto optional = GetNodeValue(Optional, ctx, block);
         const auto value = IsItemOptional ? GetOptionalValue(context, optional, block) : optional;
-        const auto output = SelectInst::Create(IsEmpty(optional, block), finish, value, "output", block);
+        const auto output = SelectInst::Create(IsEmpty(optional, block, context), finish, value, "output", block);
 
         result->addIncoming(output, block);
         BranchInst::Create(done, block);
@@ -256,7 +256,6 @@ private:
         ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
         DISubprogramAnnotator annotator(ctx, ctx.Func);
-        
 
         auto args = ctx.Func->arg_begin();
 
@@ -266,13 +265,13 @@ private:
         const auto main = BasicBlock::Create(context, "main", ctx.Func);
         auto block = main;
 
-        SafeUnRefUnboxed(valuePtr, ctx, block);
+        SafeUnRefUnboxedOne(valuePtr, ctx, block);
         GetNodeValue(valuePtr, Flow, ctx, block);
 
         const auto value = new LoadInst(valueType, valuePtr, "value", block);
 
-        const auto second = SelectInst::Create(IsYield(value, block), ConstantInt::get(statusType, static_cast<ui32>(NUdf::EFetchStatus::Yield)), ConstantInt::get(statusType, static_cast<ui32>(NUdf::EFetchStatus::Ok)), "second", block);
-        const auto first = SelectInst::Create(IsFinish(value, block), ConstantInt::get(statusType, static_cast<ui32>(NUdf::EFetchStatus::Finish)), second, "second", block);
+        const auto second = SelectInst::Create(IsYield(value, block, context), ConstantInt::get(statusType, static_cast<ui32>(NUdf::EFetchStatus::Yield)), ConstantInt::get(statusType, static_cast<ui32>(NUdf::EFetchStatus::Ok)), "second", block);
+        const auto first = SelectInst::Create(IsFinish(value, block, context), ConstantInt::get(statusType, static_cast<ui32>(NUdf::EFetchStatus::Finish)), second, "second", block);
 
         ReturnInst::Create(context, first, block);
         return ctx.Func;
@@ -330,7 +329,7 @@ public:
         const auto state = PHINode::Create(load->getType(), 2U, "state", main);
         state->addIncoming(load, block);
 
-        BranchInst::Create(init, main, IsInvalid(load, block), block);
+        BranchInst::Create(init, main, IsInvalid(load, block, context), block);
 
         block = init;
 
@@ -484,7 +483,6 @@ private:
         ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
         DISubprogramAnnotator annotator(ctx, ctx.Func);
-        
 
         auto args = ctx.Func->arg_begin();
 
@@ -507,7 +505,7 @@ private:
         std::vector<Value*> pointers(Representations.size());
         for (auto i = 0U; i < pointers.size(); ++i) {
             pointers[i] = GetElementPtrInst::CreateInBounds(valueType, valuesPtr, {ConstantInt::get(indexType, i)}, (TString("ptr_") += ToString(i)).c_str(), block);
-            SafeUnRefUnboxed(pointers[i], ctx, block);
+            SafeUnRefUnboxedOne(pointers[i], ctx, block);
         }
 
         const auto getres = GetNodeValues(WideFlow, ctx, block);
diff --git a/yql/essentials/minikql/comp_nodes/mkql_grace_join.cpp b/yql/essentials/minikql/comp_nodes/mkql_grace_join.cpp
index 871321786b..0a511e61ad 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_grace_join.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_grace_join.cpp
@@ -1126,7 +1126,7 @@ class TGraceJoinWrapper : public TStatefulWideFlowCodegeneratorNode<TGraceJoinWr
         const auto make = BasicBlock::Create(context, "make", ctx.Func);
         const auto main = BasicBlock::Create(context, "main", ctx.Func);
 
-        BranchInst::Create(make, main, IsInvalid(statePtr, block), block);
+        BranchInst::Create(make, main, IsInvalid(statePtr, block, context), block);
         block = make;
 
         const auto ptrType = PointerType::getUnqual(StructType::get(context));
diff --git a/yql/essentials/minikql/comp_nodes/mkql_guess.cpp b/yql/essentials/minikql/comp_nodes/mkql_guess.cpp
index 85a550b3b7..2dd0cd3a56 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_guess.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_guess.cpp
@@ -50,7 +50,7 @@ public:
         if constexpr (IsOptional) {
             const auto good = BasicBlock::Create(context, "good", ctx.Func);
 
-            BranchInst::Create(none, good, IsEmpty(var, block), block);
+            BranchInst::Create(none, good, IsEmpty(var, block, context), block);
 
             block = good;
         }
diff --git a/yql/essentials/minikql/comp_nodes/mkql_hasitems.cpp b/yql/essentials/minikql/comp_nodes/mkql_hasitems.cpp
index 978e9d025f..0f0021431f 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_hasitems.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_hasitems.cpp
@@ -38,7 +38,7 @@ public:
             const auto result = PHINode::Create(collection->getType(), 2U, "result", done);
 
             result->addIncoming(collection, block);
-            BranchInst::Create(done, good, IsEmpty(collection, block), block);
+            BranchInst::Create(done, good, IsEmpty(collection, block, context), block);
 
             block = good;
 
diff --git a/yql/essentials/minikql/comp_nodes/mkql_if.cpp b/yql/essentials/minikql/comp_nodes/mkql_if.cpp
index 6b4f1b0633..68439d9cc3 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_if.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_if.cpp
@@ -41,7 +41,7 @@ public:
         if (IsOptional) {
             result->addIncoming(value, block);
             const auto good = BasicBlock::Create(context, "good", ctx.Func);
-            BranchInst::Create(done, good, IsEmpty(value, block), block);
+            BranchInst::Create(done, good, IsEmpty(value, block, context), block);
 
             block = good;
         }
@@ -112,7 +112,7 @@ public:
         const auto elsb = BasicBlock::Create(context, "else", ctx.Func);
         const auto done = BasicBlock::Create(context, "done", ctx.Func);
 
-        BranchInst::Create(init, test, IsInvalid(statePtr, block), block);
+        BranchInst::Create(init, test, IsInvalid(statePtr, block, context), block);
 
         block = init;
 
@@ -129,7 +129,7 @@ public:
         if (IsOptional) {
             result->addIncoming(state, block);
             const auto good = BasicBlock::Create(context, "good", ctx.Func);
-            BranchInst::Create(done, good, IsEmpty(state, block), block);
+            BranchInst::Create(done, good, IsEmpty(state, block, context), block);
 
             block = good;
         }
@@ -194,7 +194,7 @@ public:
         const auto elsb = BasicBlock::Create(context, "else", ctx.Func);
         const auto done = BasicBlock::Create(context, "done", ctx.Func);
 
-        BranchInst::Create(init, test, IsInvalid(statePtr, block), block);
+        BranchInst::Create(init, test, IsInvalid(statePtr, block, context), block);
 
         block = init;
 
diff --git a/yql/essentials/minikql/comp_nodes/mkql_ifpresent.cpp b/yql/essentials/minikql/comp_nodes/mkql_ifpresent.cpp
index 0b93288d59..8c9d668539 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_ifpresent.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_ifpresent.cpp
@@ -54,7 +54,7 @@ public:
         block = slow;
 
         const auto value = GetNodeValue(Optional, ctx, block);
-        BranchInst::Create(pres, miss, IsExists(value, block), block);
+        BranchInst::Create(pres, miss, IsExists(value, block, context), block);
 
         block = pres;
         codegenItem->CreateSetValue(ctx, block, IsMultiOptional ? GetOptionalValue(context, value, block) : value);
@@ -136,7 +136,7 @@ public:
         block = slow;
 
         const auto value = GetNodeValue(Optional, ctx, block);
-        BranchInst::Create(pres, miss, IsExists(value, block), block);
+        BranchInst::Create(pres, miss, IsExists(value, block, context), block);
 
         block = pres;
         codegenItem->CreateSetValue(ctx, block, IsMultiOptional ? GetOptionalValue(context, value, block) : value);
@@ -218,7 +218,7 @@ public:
         block = init;
 
         const auto value = GetNodeValue(Optional, ctx, block);
-        BranchInst::Create(good, miss, IsExists(value, block), block);
+        BranchInst::Create(good, miss, IsExists(value, block, context), block);
 
         block = good;
 
diff --git a/yql/essentials/minikql/comp_nodes/mkql_invoke.cpp b/yql/essentials/minikql/comp_nodes/mkql_invoke.cpp
index aa9f8b7e7b..4408ada57f 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_invoke.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_invoke.cpp
@@ -34,7 +34,7 @@ protected:
             const auto result = PHINode::Create(arg->getType(), 2U, "result", done);
 
             result->addIncoming(arg, block);
-            BranchInst::Create(good, done, IsExists(arg, block), block);
+            BranchInst::Create(good, done, IsExists(arg, block, context), block);
 
             block = good;
             const auto out = reinterpret_cast<TGeneratorPtr>(Descriptor.Generator)(&arg, ctx, block);
diff --git a/yql/essentials/minikql/comp_nodes/mkql_iterator.cpp b/yql/essentials/minikql/comp_nodes/mkql_iterator.cpp
index 03f177df0e..dcd9d351cf 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_iterator.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_iterator.cpp
@@ -210,7 +210,6 @@ private:
         ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
         DISubprogramAnnotator annotator(ctx, ctx.Func);
-        
 
         auto args = ctx.Func->arg_begin();
 
@@ -220,7 +219,7 @@ private:
         const auto main = BasicBlock::Create(context, "main", ctx.Func);
         auto block = main;
 
-        SafeUnRefUnboxed(valuePtr, ctx, block);
+        SafeUnRefUnboxedOne(valuePtr, ctx, block);
         GetNodeValue(valuePtr, Flow, ctx, block);
 
         const auto value = new LoadInst(valueType, valuePtr, "value", block);
@@ -228,7 +227,7 @@ private:
         const auto kill = BasicBlock::Create(context, "kill", ctx.Func);
         const auto good = BasicBlock::Create(context, "good", ctx.Func);
 
-        BranchInst::Create(kill, good, IsYield(value, block), block);
+        BranchInst::Create(kill, good, IsYield(value, block, context), block);
 
         block = kill;
         const auto doThrow = ConstantInt::get(Type::getInt64Ty(context), GetMethodPtr(&TFlowForwardListWrapper::Throw));
diff --git a/yql/essentials/minikql/comp_nodes/mkql_join.cpp b/yql/essentials/minikql/comp_nodes/mkql_join.cpp
index 364a7af8bb..2825ba54c3 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_join.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_join.cpp
@@ -1201,7 +1201,7 @@ public:
         const auto make = BasicBlock::Create(context, "make", ctx.Func);
         const auto main = BasicBlock::Create(context, "main", ctx.Func);
 
-        BranchInst::Create(make, main, IsInvalid(statePtr, block), block);
+        BranchInst::Create(make, main, IsInvalid(statePtr, block, context), block);
 
         block = make;
 
@@ -1311,7 +1311,6 @@ private:
         ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
         DISubprogramAnnotator annotator(ctx, ctx.Func);
-        
 
         auto args = ctx.Func->arg_begin();
 
diff --git a/yql/essentials/minikql/comp_nodes/mkql_lazy_list.cpp b/yql/essentials/minikql/comp_nodes/mkql_lazy_list.cpp
index 9e6ec251e3..f7d0405558 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_lazy_list.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_lazy_list.cpp
@@ -46,7 +46,7 @@ public:
 
         if constexpr (IsOptional) {
             const auto test = BasicBlock::Create(context, "test", ctx.Func);
-            BranchInst::Create(done, test, IsEmpty(list, block), block);
+            BranchInst::Create(done, test, IsEmpty(list, block, context), block);
 
             block = test;
             lazy->addIncoming(list, block);
diff --git a/yql/essentials/minikql/comp_nodes/mkql_length.cpp b/yql/essentials/minikql/comp_nodes/mkql_length.cpp
index f99f7f5199..bba0378bb6 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_length.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_length.cpp
@@ -38,7 +38,7 @@ public:
             const auto result = PHINode::Create(collection->getType(), 2U, "result", done);
 
             result->addIncoming(collection, block);
-            BranchInst::Create(done, good, IsEmpty(collection, block), block);
+            BranchInst::Create(done, good, IsEmpty(collection, block, context), block);
             block = good;
 
             const auto length = CallBoxedValueVirtualMethod<IsDict ? NUdf::TBoxedValueAccessor::EMethod::GetDictLength : NUdf::TBoxedValueAccessor::EMethod::GetListLength>(Type::getInt64Ty(context), collection, ctx.Codegen, block);
diff --git a/yql/essentials/minikql/comp_nodes/mkql_logical.cpp b/yql/essentials/minikql/comp_nodes/mkql_logical.cpp
index 48633ca720..e747929c0e 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_logical.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_logical.cpp
@@ -262,9 +262,9 @@ public:
 
 #ifndef MKQL_DISABLE_CODEGEN
     Value* DoGenerateGetValue(const TCodegenContext& ctx, Value* arg, BasicBlock*& block) const {
-        Y_UNUSED(ctx);
+        auto& context = ctx.Codegen.GetContext();
         const auto xorr = BinaryOperator::CreateXor(arg, ConstantInt::get(arg->getType(), 1), "xor", block);
-        const auto result = IsOptional ? SelectInst::Create(IsExists(arg, block), xorr, arg, "sel", block) : static_cast<Value*>(xorr);
+        const auto result = IsOptional ? SelectInst::Create(IsExists(arg, block, context), xorr, arg, "sel", block) : static_cast<Value*>(xorr);
         return result;
     }
 #endif
diff --git a/yql/essentials/minikql/comp_nodes/mkql_map.cpp b/yql/essentials/minikql/comp_nodes/mkql_map.cpp
index 287ec0ecc8..690b68228b 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_map.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_map.cpp
@@ -41,7 +41,7 @@ public:
         const auto result = PHINode::Create(item->getType(), 2, "result", pass);
         result->addIncoming(item, block);
 
-        BranchInst::Create(pass, work, IsSpecial(item, block), block);
+        BranchInst::Create(pass, work, IsSpecial(item, block, context), block);
 
         block = work;
         codegenItem->CreateSetValue(ctx, block, item);
@@ -206,7 +206,6 @@ protected:
         ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
         DISubprogramAnnotator annotator(ctx, ctx.Func);
-        
 
         auto args = ctx.Func->arg_begin();
 
@@ -236,7 +235,7 @@ protected:
         BranchInst::Create(done, good, icmp, block);
         block = good;
 
-        SafeUnRefUnboxed(valuePtr, ctx, block);
+        SafeUnRefUnboxedOne(valuePtr, ctx, block);
         GetNodeValue(valuePtr, NewItem, ctx, block);
 
         BranchInst::Create(done, block);
diff --git a/yql/essentials/minikql/comp_nodes/mkql_map_join.cpp b/yql/essentials/minikql/comp_nodes/mkql_map_join.cpp
index fa8dced983..05de9fafc6 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_map_join.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_map_join.cpp
@@ -47,13 +47,13 @@ protected:
         return check;
     }
 
-    Value* GenMakeKeysTuple(Value* keysPtr, const ICodegeneratorInlineWideNode::TGettersList& getters, Value* itemsPtr, const TCodegenContext& ctx, BasicBlock*& block) const {
+    Value* GenMakeKeysTuple(Value* keysPtr, const ICodegeneratorInlineWideNode::TGettersList& getters, Value* itemsPtr, Type* keysType, const TCodegenContext& ctx, BasicBlock*& block) const {
         auto& context = ctx.Codegen.GetContext();
         const auto idxType = Type::getInt32Ty(context);
         const auto zero = ConstantInt::get(Type::getInt128Ty(context), 0);
 
         const auto keys = KeyTuple.GenNewArray(LeftKeyColumns.size(), itemsPtr, ctx, block);
-        const auto items = new LoadInst(itemsPtr->getType()->getPointerElementType(), itemsPtr, "items", block);
+        const auto items = new LoadInst(PointerType::getUnqual(keysType), itemsPtr, "items", block);
 
         const auto done = BasicBlock::Create(context, "done", ctx.Func);
         const auto result = PHINode::Create(Type::getInt1Ty(context), (LeftKeyColumns.size() + 1U) << 1U , "result", done);
@@ -61,7 +61,7 @@ protected:
         const auto keyType = AS_TYPE(TTupleType, DictType->GetKeyType());
         for (ui32 i = 0; i < LeftKeyColumns.size(); ++i) {
             const auto index = ConstantInt::get(idxType, i);
-            const auto ptr = GetElementPtrInst::CreateInBounds(items->getType()->getPointerElementType(), items, {ConstantInt::get(idxType, 0), index}, (TString("ptr_") += ToString(i)).c_str(), block);
+            const auto ptr = GetElementPtrInst::CreateInBounds(keysType, items, {ConstantInt::get(idxType, 0), index}, (TString("ptr_") += ToString(i)).c_str(), block);
             const auto elem = getters[LeftKeyColumns[i]](ctx, block);
             const auto converter = reinterpret_cast<TGeneratorPtr>(LeftKeyConverters[i].Generator);
             const auto conv = converter ? converter(reinterpret_cast<Value *const *>(&elem), ctx, block) : elem;
@@ -88,7 +88,10 @@ protected:
 
     void GenFillLeftStruct(const std::vector<Value*>& pointers, ICodegeneratorInlineWideNode::TGettersList& output) const {
         for (auto i = 0U; i < pointers.size(); ++i) {
-            output[LeftRenames[(i << 1U) + 1U]] = [p = pointers[i]](const TCodegenContext&, BasicBlock*& block) { return new LoadInst(p->getType()->getPointerElementType(), p, "value", block); };
+            output[LeftRenames[(i << 1U) + 1U]] = [p = pointers[i]](const TCodegenContext& ctx, BasicBlock*& block) {
+                auto& context = ctx.Codegen.GetContext();
+                return new LoadInst(Type::getInt128Ty(context), p, "value", block);
+            };
         }
     }
 
@@ -344,7 +347,7 @@ public:
         block = next;
 
         const auto none = IsTuple ?
-            this->GenMakeKeysTuple(keysPtr, current.second, kitmsPtr, ctx, block):
+            this->GenMakeKeysTuple(keysPtr, current.second, kitmsPtr, keysType, ctx, block):
             this->GenMakeKeysTuple(keysPtr, current.second, ctx, block);
 
         ICodegeneratorInlineWideNode::TGettersList getters(this->OutputRepresentations.size());
@@ -528,7 +531,7 @@ public:
 
         ICodegeneratorInlineWideNode::TGettersList getters(this->OutputRepresentations.size());
 
-        BranchInst::Create(hasi, part, HasValue(subiter, block), block);
+        BranchInst::Create(hasi, part, HasValue(subiter, block, context), block);
 
         block = part;
 
@@ -585,7 +588,7 @@ public:
         block = next;
 
         const auto none = IsTuple ?
-            this->GenMakeKeysTuple(keysPtr, current.second, kitmsPtr, ctx, block):
+            this->GenMakeKeysTuple(keysPtr, current.second, kitmsPtr, keysType, ctx, block):
             this->GenMakeKeysTuple(keysPtr, current.second, ctx, block);
 
         if constexpr (RightRequired)
@@ -720,7 +723,7 @@ protected:
         }
     }
 #ifndef MKQL_DISABLE_CODEGEN
-    void GenFillLeftStruct(Value* left, Value* items, const TCodegenContext& ctx, BasicBlock*& block) const {
+    void GenFillLeftStruct(Value* left, Value* items, Type* arrayType, const TCodegenContext& ctx, BasicBlock*& block) const {
         auto& context = ctx.Codegen.GetContext();
         const auto idxType = Type::getInt32Ty(context);
         const auto valType = Type::getInt128Ty(context);
@@ -742,7 +745,7 @@ protected:
                 const auto oldIndex = ConstantInt::get(idxType, oldI);
                 const auto newIndex = ConstantInt::get(idxType, newI);
                 const auto oldPtr = GetElementPtrInst::CreateInBounds(valType, elements, {oldIndex}, "old", block);
-                const auto newPtr = GetElementPtrInst::CreateInBounds(items->getType()->getPointerElementType(), items, {ConstantInt::get(idxType, 0), newIndex}, "new", block);
+                const auto newPtr = GetElementPtrInst::CreateInBounds(arrayType, items, {ConstantInt::get(idxType, 0), newIndex}, "new", block);
                 const auto item = new LoadInst(valType, oldPtr, "item", block);
                 new StoreInst(item, newPtr, block);
                 ValueAddRef(OutputRepresentations[newI], newPtr, ctx, block);
@@ -756,7 +759,7 @@ protected:
                 const auto newI = LeftRenames[i++];
                 const auto oldIndex = ConstantInt::get(idxType, oldI);
                 const auto newIndex = ConstantInt::get(idxType, newI);
-                const auto item = GetElementPtrInst::CreateInBounds(items->getType()->getPointerElementType(), items, {ConstantInt::get(idxType, 0), newIndex}, "item", block);
+                const auto item = GetElementPtrInst::CreateInBounds(arrayType, items, {ConstantInt::get(idxType, 0), newIndex}, "item", block);
                 CallBoxedValueVirtualMethod<NUdf::TBoxedValueAccessor::EMethod::GetElement>(item, left, ctx.Codegen, block, oldIndex);
             }
             BranchInst::Create(done, block);
@@ -764,7 +767,7 @@ protected:
         block = done;
     }
 
-    void GenFillRightStruct(Value* right, Value* items, const TCodegenContext& ctx, BasicBlock*& block) const {
+    void GenFillRightStruct(Value* right, Value* items, Type* arrayType, const TCodegenContext& ctx, BasicBlock*& block) const {
         auto& context = ctx.Codegen.GetContext();
         const auto idxType = Type::getInt32Ty(context);
         const auto valType = Type::getInt128Ty(context);
@@ -786,7 +789,7 @@ protected:
                 const auto oldIndex = ConstantInt::get(idxType, oldI);
                 const auto newIndex = ConstantInt::get(idxType, newI);
                 const auto oldPtr = GetElementPtrInst::CreateInBounds(valType, elements, {oldIndex}, "old", block);
-                const auto newPtr = GetElementPtrInst::CreateInBounds(items->getType()->getPointerElementType(), items, {ConstantInt::get(idxType, 0), newIndex}, "new", block);
+                const auto newPtr = GetElementPtrInst::CreateInBounds(arrayType, items, {ConstantInt::get(idxType, 0), newIndex}, "new", block);
                 const auto elem = new LoadInst(valType, oldPtr, "elem", block);
                 new StoreInst(elem, newPtr, block);
                 ValueAddRef(OutputRepresentations[newI], newPtr, ctx, block);
@@ -800,7 +803,7 @@ protected:
                 const auto newI = RightRenames[i++];
                 const auto oldIndex = ConstantInt::get(idxType, oldI);
                 const auto newIndex = ConstantInt::get(idxType, newI);
-                const auto item = GetElementPtrInst::CreateInBounds(items->getType()->getPointerElementType(), items, {ConstantInt::get(idxType, 0), newIndex}, "item", block);
+                const auto item = GetElementPtrInst::CreateInBounds(arrayType, items, {ConstantInt::get(idxType, 0), newIndex}, "item", block);
                 CallBoxedValueVirtualMethod<NUdf::TBoxedValueAccessor::EMethod::GetElement>(item, right, ctx.Codegen, block, oldIndex);
             }
             BranchInst::Create(done, block);
@@ -816,26 +819,26 @@ protected:
         const auto index = ConstantInt::get(idxType, LeftKeyColumns.front());
         CallBoxedValueVirtualMethod<NUdf::TBoxedValueAccessor::EMethod::GetElement>(keysPtr, current, ctx.Codegen, block, index);
         if (const auto converter = reinterpret_cast<TGeneratorPtr>(LeftKeyConverters.front().Generator)) {
-            Value *const elem = new LoadInst(keysPtr->getType()->getPointerElementType(), keysPtr, "elem", block);
+            Value *const elem = new LoadInst(Type::getInt128Ty(context), keysPtr, "elem", block);
             const auto conv = converter(&elem, ctx, block);
             new StoreInst(conv, keysPtr, block);
             const auto check = CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_EQ, conv, zero, "check", block);
             return check;
         } else {
-            const auto keys = new LoadInst(keysPtr->getType()->getPointerElementType(), keysPtr, "keys", block);
+            const auto keys = new LoadInst(Type::getInt128Ty(context), keysPtr, "keys", block);
             const auto check = CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_EQ, keys, zero, "check", block);
             return check;
         }
     }
 
-    Value* GenMakeKeysTuple(Value* keysPtr, Value* current, Value* itemsPtr, const TCodegenContext& ctx, BasicBlock*& block) const {
+    Value* GenMakeKeysTuple(Value* keysPtr, Value* current, Value* itemsPtr, Type* keysType, const TCodegenContext& ctx, BasicBlock*& block) const {
         auto& context = ctx.Codegen.GetContext();
         const auto idxType = Type::getInt32Ty(context);
         const auto valueType = Type::getInt128Ty(context);
         const auto zero = ConstantInt::get(valueType, 0);
 
         const auto keys = KeyTuple.GenNewArray(LeftKeyColumns.size(), itemsPtr, ctx, block);
-        const auto items = new LoadInst(itemsPtr->getType()->getPointerElementType(), itemsPtr, "items", block);
+        const auto items = new LoadInst(PointerType::getUnqual(keysType), itemsPtr, "items", block);
 
         const auto ptrType = PointerType::getUnqual(valueType);
         const auto elements = CallBoxedValueVirtualMethod<NUdf::TBoxedValueAccessor::EMethod::GetElements>(ptrType, current, ctx.Codegen, block);
@@ -856,7 +859,7 @@ protected:
                 const auto oldIndex = ConstantInt::get(idxType, LeftKeyColumns[i]);
                 const auto newIndex = ConstantInt::get(idxType, i);
                 const auto oldPtr = GetElementPtrInst::CreateInBounds(valueType, elements, {oldIndex}, "old", block);
-                const auto newPtr = GetElementPtrInst::CreateInBounds(items->getType()->getPointerElementType(), items, {ConstantInt::get(idxType, 0), newIndex}, "new", block);
+                const auto newPtr = GetElementPtrInst::CreateInBounds(keysType, items, {ConstantInt::get(idxType, 0), newIndex}, "new", block);
                 const auto elem = new LoadInst(valueType, oldPtr, "elem", block);
                 const auto converter = reinterpret_cast<TGeneratorPtr>(LeftKeyConverters[i].Generator);
                 const auto conv = converter ? converter(reinterpret_cast<Value *const *>(&elem), ctx, block) : elem;
@@ -880,7 +883,7 @@ protected:
             block = slow;
 
             for (ui32 i = 0; i < LeftKeyColumns.size(); ++i) {
-                const auto item = GetElementPtrInst::CreateInBounds(items->getType()->getPointerElementType(), items, {ConstantInt::get(idxType, 0), ConstantInt::get(idxType, i)}, "item", block);
+                const auto item = GetElementPtrInst::CreateInBounds(keysType, items, {ConstantInt::get(idxType, 0), ConstantInt::get(idxType, i)}, "item", block);
                 const auto index = ConstantInt::get(idxType, LeftKeyColumns[i]);
                 CallBoxedValueVirtualMethod<NUdf::TBoxedValueAccessor::EMethod::GetElement>(item, current, ctx.Codegen, block, index);
 
@@ -1065,11 +1068,11 @@ public:
         result->addIncoming(current, block);
 
         const auto next = BasicBlock::Create(context, "next", ctx.Func);
-        BranchInst::Create(stop, next, IsSpecial(current, block), block);
+        BranchInst::Create(stop, next, IsSpecial(current, block, context), block);
         block = next;
 
         const auto none = IsTuple ?
-            this->GenMakeKeysTuple(keysPtr, current, kitmsPtr, ctx, block):
+            this->GenMakeKeysTuple(keysPtr, current, kitmsPtr, keysType, ctx, block):
             this->GenMakeKeysTuple(keysPtr, current, ctx, block);
 
         const auto skip = BasicBlock::Create(context, "skip", ctx.Func);
@@ -1116,8 +1119,8 @@ public:
                 const auto out = this->ResStruct.GenNewArray(this->OutputRepresentations.size(), itemsPtr, ctx, block);
                 const auto items = new LoadInst(itemsType, itemsPtr, "items", block);
 
-                this->GenFillLeftStruct(current, items, ctx, block);
-                this->GenFillRightStruct(lookup, items, ctx, block);
+                this->GenFillLeftStruct(current, items, arrayType, ctx, block);
+                this->GenFillRightStruct(lookup, items, arrayType, ctx, block);
 
                 UnRefBoxed(lookup, ctx, block);
                 ValueCleanup(static_cast<const IComputationNode*>(this)->GetRepresentation(), current, ctx, block);
@@ -1137,7 +1140,7 @@ public:
             const auto out = this->ResStruct.GenNewArray(this->OutputRepresentations.size(), itemsPtr, ctx, block);
             const auto items = new LoadInst(itemsType, itemsPtr, "items", block);
 
-            this->GenFillLeftStruct(current, items, ctx, block);
+            this->GenFillLeftStruct(current, items, arrayType, ctx, block);
 
             ValueCleanup(static_cast<const IComputationNode*>(this)->GetRepresentation(), current, ctx, block);
 
@@ -1191,7 +1194,7 @@ public:
         const auto exit = BasicBlock::Create(context, "exit", ctx.Func);
         const auto result = PHINode::Create(valueType, 3U, "result", exit);
 
-        BranchInst::Create(hasi, part, HasValue(subiter, block), block);
+        BranchInst::Create(hasi, part, HasValue(subiter, block, context), block);
 
         block = hasi;
         const auto curr = new LoadInst(valueType, currentPtr, "curr", block);
@@ -1205,8 +1208,8 @@ public:
             const auto items = new LoadInst(itemsType, itemsPtr, "items", block);
             const auto item = new LoadInst(valueType, itemPtr, "item", block);
 
-            this->GenFillLeftStruct(curr, items, ctx, block);
-            this->GenFillRightStruct(item, items, ctx, block);
+            this->GenFillLeftStruct(curr, items, arrayType, ctx, block);
+            this->GenFillRightStruct(item, items, arrayType, ctx, block);
 
             UnRefBoxed(item, ctx, block);
 
@@ -1230,7 +1233,7 @@ public:
         block = loop;
         GetNodeValue(currentPtr, this->Stream, ctx, block);
         const auto current = new LoadInst(valueType, currentPtr, "current", block);
-        BranchInst::Create(stop, next, IsSpecial(current, block), block);
+        BranchInst::Create(stop, next, IsSpecial(current, block, context), block);
 
         block = stop;
 
@@ -1242,7 +1245,7 @@ public:
 
         block = next;
         const auto none = IsTuple ?
-            this->GenMakeKeysTuple(keysPtr, current, kitmsPtr, ctx, block):
+            this->GenMakeKeysTuple(keysPtr, current, kitmsPtr, keysType, ctx, block):
             this->GenMakeKeysTuple(keysPtr, current, ctx, block);
 
         const auto step = BasicBlock::Create(context, "step", ctx.Func);
@@ -1277,7 +1280,7 @@ public:
             const auto out = this->ResStruct.GenNewArray(this->OutputRepresentations.size(), itemsPtr, ctx, block);
             const auto items = new LoadInst(itemsType, itemsPtr, "items", block);
 
-            this->GenFillLeftStruct(current, items, ctx, block);
+            this->GenFillLeftStruct(current, items, arrayType, ctx, block);
             UnRefBoxed(current, ctx, block);
             new StoreInst(zero, currentPtr, block);
 
@@ -1550,7 +1553,6 @@ private:
         ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
         DISubprogramAnnotator annotator(ctx, ctx.Func);
-        
 
         auto args = ctx.Func->arg_begin();
 
@@ -1596,7 +1598,7 @@ private:
 
         const auto current = new LoadInst(valueType, itemPtr, "current", block);
         const auto none = IsTuple ?
-            this->GenMakeKeysTuple(keysPtr, current, kitmsPtr, ctx, block):
+            this->GenMakeKeysTuple(keysPtr, current, kitmsPtr, keysType, ctx, block):
             this->GenMakeKeysTuple(keysPtr, current, ctx, block);
 
         const auto skip = BasicBlock::Create(context, "skip", ctx.Func);
@@ -1643,10 +1645,10 @@ private:
                 const auto result = this->ResStruct.GenNewArray(this->OutputRepresentations.size(), itemsPtr, ctx, block);
                 const auto items = new LoadInst(itemsType, itemsPtr, "items", block);
 
-                this->GenFillLeftStruct(current, items, ctx, block);
-                this->GenFillRightStruct(lookup, items, ctx, block);
+                this->GenFillLeftStruct(current, items, arrayType, ctx, block);
+                this->GenFillRightStruct(lookup, items, arrayType, ctx, block);
 
-                SafeUnRefUnboxed(valuePtr, ctx, block);
+                SafeUnRefUnboxedOne(valuePtr, ctx, block);
                 AddRefBoxed(result, ctx, block);
                 new StoreInst(result, valuePtr, block);
 
@@ -1667,9 +1669,9 @@ private:
             const auto result = this->ResStruct.GenNewArray(this->OutputRepresentations.size(), itemsPtr, ctx, block);
             const auto items = new LoadInst(itemsType, itemsPtr, "items", block);
 
-            this->GenFillLeftStruct(current, items, ctx, block);
+            this->GenFillLeftStruct(current, items, arrayType, ctx, block);
 
-            SafeUnRefUnboxed(valuePtr, ctx, block);
+            SafeUnRefUnboxedOne(valuePtr, ctx, block);
             AddRefBoxed(result, ctx, block);
             new StoreInst(result, valuePtr, block);
 
@@ -1708,7 +1710,6 @@ private:
         ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
         DISubprogramAnnotator annotator(ctx, ctx.Func);
-        
 
         auto args = ctx.Func->arg_begin();
 
@@ -1775,10 +1776,10 @@ private:
             const auto curr = new LoadInst(valueType, currentArg, "curr", block);
             const auto item = new LoadInst(valueType, itemPtr, "item", block);
 
-            this->GenFillLeftStruct(curr, items, ctx, block);
-            this->GenFillRightStruct(item, items, ctx, block);
+            this->GenFillLeftStruct(curr, items, arrayType, ctx, block);
+            this->GenFillRightStruct(item, items, arrayType, ctx, block);
 
-            SafeUnRefUnboxed(valuePtr, ctx, block);
+            SafeUnRefUnboxedOne(valuePtr, ctx, block);
             AddRefBoxed(result, ctx, block);
             new StoreInst(result, valuePtr, block);
 
@@ -1804,7 +1805,7 @@ private:
             const auto current = new LoadInst(valueType, currentArg, "current", block);
 
             const auto none = IsTuple ?
-                this->GenMakeKeysTuple(keysPtr, current, kitmsPtr, ctx, block):
+                this->GenMakeKeysTuple(keysPtr, current, kitmsPtr, keysType, ctx, block):
                 this->GenMakeKeysTuple(keysPtr, current, ctx, block);
 
             const auto step = BasicBlock::Create(context, "step", ctx.Func);
@@ -1834,9 +1835,9 @@ private:
                 const auto result = this->ResStruct.GenNewArray(this->OutputRepresentations.size(), itemsPtr, ctx, block);
                 const auto items = new LoadInst(itemsType, itemsPtr, "items", block);
 
-                this->GenFillLeftStruct(current, items, ctx, block);
+                this->GenFillLeftStruct(current, items, arrayType, ctx, block);
 
-                SafeUnRefUnboxed(valuePtr, ctx, block);
+                SafeUnRefUnboxedOne(valuePtr, ctx, block);
                 AddRefBoxed(result, ctx, block);
                 new StoreInst(result, valuePtr, block);
 
diff --git a/yql/essentials/minikql/comp_nodes/mkql_multimap.cpp b/yql/essentials/minikql/comp_nodes/mkql_multimap.cpp
index c4b1126020..c9fad3198f 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_multimap.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_multimap.cpp
@@ -74,7 +74,7 @@ public:
             const auto item = GetNodeValue(Flow, ctx, block);
             result->addIncoming(item, block);
 
-            BranchInst::Create(pass, work, IsSpecial(item, block), block);
+            BranchInst::Create(pass, work, IsSpecial(item, block, context), block);
 
             block = work;
 
@@ -344,7 +344,6 @@ private:
         ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
         DISubprogramAnnotator annotator(ctx, ctx.Func);
-        
 
         auto args = ctx.Func->arg_begin();
 
@@ -359,7 +358,7 @@ private:
         const auto container = codegen.GetEffectiveTarget() == NYql::NCodegen::ETarget::Windows ?
             new LoadInst(valueType, containerArg, "load_container", false, block) : static_cast<Value*>(containerArg);
 
-        const auto position = new LoadInst(positionArg->getType()->getPointerElementType(), positionArg, "position", false, block);
+        const auto position = new LoadInst(positionType, positionArg, "position", false, block);
 
         const auto zero = BasicBlock::Create(context, "zero", ctx.Func);
         const auto good = BasicBlock::Create(context, "good", ctx.Func);
@@ -373,7 +372,7 @@ private:
 
             block = part;
 
-            SafeUnRefUnboxed(valuePtr, ctx, block);
+            SafeUnRefUnboxedOne(valuePtr, ctx, block);
             GetNodeValue(valuePtr, NewItems[i], ctx, block);
             const auto next = ++i;
             new StoreInst(ConstantInt::get(positionType, NewItems.size() <= next ? 0 : next), positionArg, block);
@@ -388,7 +387,7 @@ private:
         BranchInst::Create(good, done, status, block);
         block = good;
 
-        SafeUnRefUnboxed(valuePtr, ctx, block);
+        SafeUnRefUnboxedOne(valuePtr, ctx, block);
         GetNodeValue(valuePtr, NewItems.front(), ctx, block);
         new StoreInst(ConstantInt::get(positionType, 1), positionArg, block);
 
diff --git a/yql/essentials/minikql/comp_nodes/mkql_size.cpp b/yql/essentials/minikql/comp_nodes/mkql_size.cpp
index 6ea1f40f42..14d945d734 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_size.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_size.cpp
@@ -26,10 +26,10 @@ public:
 
 #ifndef MKQL_DISABLE_CODEGEN
     Value* DoGenerateGetValue(const TCodegenContext& ctx, Value* value, BasicBlock*& block) const {
-        Y_UNUSED(ctx);
+        auto& context = ctx.Codegen.GetContext();
         const uint64_t init[] = {Size, 0x100000000000000ULL};
         const auto size = ConstantInt::get(value->getType(), APInt(128, 2, init));
-        return SelectInst::Create(IsEmpty(value, block), value, size, "size", block);
+        return SelectInst::Create(IsEmpty(value, block, context), value, size, "size", block);
     }
 #endif
 };
diff --git a/yql/essentials/minikql/comp_nodes/mkql_skip.cpp b/yql/essentials/minikql/comp_nodes/mkql_skip.cpp
index b1a60f181b..ad9b43ebac 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_skip.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_skip.cpp
@@ -48,7 +48,7 @@ public:
         const auto load = new LoadInst(valueType, statePtr, "load", block);
         const auto state = PHINode::Create(valueType, 2U, "state", main);
         state->addIncoming(load, block);
-        BranchInst::Create(init, main, IsInvalid(load, block), block);
+        BranchInst::Create(init, main, IsInvalid(load, block, context), block);
 
         block = init;
 
@@ -79,7 +79,7 @@ public:
 
         block = work;
         const auto item = GetNodeValue(Flow, ctx, block);
-        BranchInst::Create(pass, good, IsSpecial(item, block), block);
+        BranchInst::Create(pass, good, IsSpecial(item, block, context), block);
 
         block = pass;
         result->addIncoming(item, block);
diff --git a/yql/essentials/minikql/comp_nodes/mkql_squeeze_to_list.cpp b/yql/essentials/minikql/comp_nodes/mkql_squeeze_to_list.cpp
index 742a6b8050..9a3e257c2c 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_squeeze_to_list.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_squeeze_to_list.cpp
@@ -96,11 +96,11 @@ public:
         const auto make = BasicBlock::Create(context, "make", ctx.Func);
         const auto main = BasicBlock::Create(context, "main", ctx.Func);
 
-        BranchInst::Create(make, main, IsInvalid(statePtr, block), block);
+        BranchInst::Create(make, main, IsInvalid(statePtr, block, context), block);
         block = make;
 
         const auto value = GetNodeValue(Limit, ctx, block);
-        const auto limit = SelectInst::Create(IsExists(value, block), GetterFor<ui64>(value, context, block), ConstantInt::get(Type::getInt64Ty(context), std::numeric_limits<ui64>::max()), "limit", block);
+        const auto limit = SelectInst::Create(IsExists(value, block, context), GetterFor<ui64>(value, context, block), ConstantInt::get(Type::getInt64Ty(context), std::numeric_limits<ui64>::max()), "limit", block);
 
         const auto ptrType = PointerType::getUnqual(StructType::get(context));
         const auto self = CastInst::Create(Instruction::IntToPtr, ConstantInt::get(Type::getInt64Ty(context), uintptr_t(this)), ptrType, "self", block);
@@ -125,7 +125,7 @@ public:
 
         result->addIncoming(GetFinish(context), block);
 
-        BranchInst::Create(over, more, IsFinish(state, block), block);
+        BranchInst::Create(over, more, IsFinish(state, block, context), block);
 
         block = more;
 
diff --git a/yql/essentials/minikql/comp_nodes/mkql_switch.cpp b/yql/essentials/minikql/comp_nodes/mkql_switch.cpp
index b13dd029b0..1dab916ca8 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_switch.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_switch.cpp
@@ -292,7 +292,6 @@ private:
         ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
         DISubprogramAnnotator annotator(ctx, ctx.Func);
-        
 
         const auto main = BasicBlock::Create(context, "main", ctx.Func);
         ctx.Ctx = &*ctx.Func->arg_begin();
@@ -393,7 +392,7 @@ public:
         const auto exit = BasicBlock::Create(context, "exit", ctx.Func);
         const auto result = PHINode::Create(valueType, Handlers.size() + 2U, "result", exit);
 
-        BranchInst::Create(make, main, IsInvalid(statePtr, block), block);
+        BranchInst::Create(make, main, IsInvalid(statePtr, block, context), block);
         block = make;
 
         const auto ptrType = PointerType::getUnqual(StructType::get(context));
@@ -457,8 +456,8 @@ public:
 
             const auto item = GetNodeValue(Flow, ctx, block);
 
-            const auto finsh = IsFinish(item, block);
-            const auto yield = IsYield(item, block);
+            const auto finsh = IsFinish(item, block, context);
+            const auto yield = IsYield(item, block, context);
             const auto special = BinaryOperator::CreateOr(finsh, yield, "special", block);
 
             const auto fin = SelectInst::Create(finsh, ConstantInt::get(statusType, static_cast<ui32>(NUdf::EFetchStatus::Finish)), ConstantInt::get(statusType, static_cast<ui32>(NUdf::EFetchStatus::Ok)), "fin", block);
@@ -512,7 +511,7 @@ public:
 
                 if (const auto offset = Handlers[i].ResultVariantOffset) {
                     const auto good = BasicBlock::Create(context, (TString("good_") += ToString(i)).c_str(), ctx.Func);
-                    BranchInst::Create(next, good, IsSpecial(output, block), block);
+                    BranchInst::Create(next, good, IsSpecial(output, block, context), block);
                     block = good;
 
                     const auto unpack = Handlers[i].IsOutputVariant ? GetVariantParts(output, ctx, block) : std::make_pair(ConstantInt::get(indexType, 0), output);
@@ -522,7 +521,7 @@ public:
                     BranchInst::Create(exit, block);
                 } else {
                     result->addIncoming(output, block);
-                    BranchInst::Create(next, exit, IsSpecial(output, block), block);
+                    BranchInst::Create(next, exit, IsSpecial(output, block, context), block);
                 }
             }
 
@@ -826,7 +825,6 @@ private:
         ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
         DISubprogramAnnotator annotator(ctx, ctx.Func);
-        
 
         auto args = ctx.Func->arg_begin();
 
diff --git a/yql/essentials/minikql/comp_nodes/mkql_take.cpp b/yql/essentials/minikql/comp_nodes/mkql_take.cpp
index 2ee99ed62c..3e19ee2932 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_take.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_take.cpp
@@ -44,7 +44,7 @@ public:
         const auto state = PHINode::Create(load->getType(), 2U, "state", main);
         state->addIncoming(load, block);
 
-        BranchInst::Create(init, main, IsInvalid(load, block), block);
+        BranchInst::Create(init, main, IsInvalid(load, block, context), block);
 
         block = init;
 
@@ -71,7 +71,7 @@ public:
         block = work;
         const auto item = GetNodeValue(Flow, ctx, block);
         result->addIncoming(item, block);
-        BranchInst::Create(done, good, IsSpecial(item, block), block);
+        BranchInst::Create(done, good, IsSpecial(item, block, context), block);
 
         block = good;
         result->addIncoming(item, block);
@@ -131,7 +131,7 @@ public:
         const auto state = PHINode::Create(load->getType(), 2U, "state", main);
         state->addIncoming(load, block);
 
-        BranchInst::Create(init, main, IsInvalid(load, block), block);
+        BranchInst::Create(init, main, IsInvalid(load, block, context), block);
 
         block = init;
 
diff --git a/yql/essentials/minikql/comp_nodes/mkql_timezone.cpp b/yql/essentials/minikql/comp_nodes/mkql_timezone.cpp
index 3dd00cd7b4..7bcdd30d56 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_timezone.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_timezone.cpp
@@ -116,7 +116,7 @@ public:
         if (IsOptional1) {
             result->addIncoming(value, block);
             const auto good = BasicBlock::Create(context, "good", ctx.Func);
-            BranchInst::Create(done, good, IsEmpty(value, block), block);
+            BranchInst::Create(done, good, IsEmpty(value, block, context), block);
 
             block = good;
         }
@@ -125,7 +125,7 @@ public:
         const auto id = GetterFor<ui16>(tz, context, block);
 
         const auto big = CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_UGE, id, ConstantInt::get(id->getType(), TimezonesCount), "big", block);
-        auto test = IsOptional2 ? BinaryOperator::CreateOr(IsEmpty(tz, block), big, "test", block) : static_cast<Value*>(big);
+        auto test = IsOptional2 ? BinaryOperator::CreateOr(IsEmpty(tz, block, context), big, "test", block) : static_cast<Value*>(big);
 
         for (const auto black : BlackList) {
             const auto& str = ToString(black);
diff --git a/yql/essentials/minikql/comp_nodes/mkql_tobytes.cpp b/yql/essentials/minikql/comp_nodes/mkql_tobytes.cpp
index 825e8386a4..ff3a3e09c2 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_tobytes.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_tobytes.cpp
@@ -27,13 +27,14 @@ public:
     }
 #ifndef MKQL_DISABLE_CODEGEN
     Value* DoGenerateGetValue(const TCodegenContext& ctx, Value* value, BasicBlock*& block) const {
+        auto& context = ctx.Codegen.GetContext();
         const uint64_t one[] = {0ULL, sizeof(Type) << 48ULL};
         const auto size = ConstantInt::get(value->getType(), APInt(128, 2, one));
         const uint64_t two[] = {0xFFFFFFFFFFFFFFFFULL, 0xFF00FFFFFFFFFFFFULL};
         const auto mask = ConstantInt::get(value->getType(), APInt(128, 2, two));
         const auto result = BinaryOperator::CreateOr(BinaryOperator::CreateAnd(value, mask, "and", block), size, "or", block);
         if constexpr (IsOptional)
-            return SelectInst::Create(IsExists(value, block), result, GetEmpty(ctx.Codegen.GetContext()), "select", block);
+            return SelectInst::Create(IsExists(value, block, context), result, GetEmpty(context), "select", block);
         return result;
     }
 #endif
diff --git a/yql/essentials/minikql/comp_nodes/mkql_todict.cpp b/yql/essentials/minikql/comp_nodes/mkql_todict.cpp
index af4d937855..0ac6b83a11 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_todict.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_todict.cpp
@@ -1021,7 +1021,7 @@ public:
         const auto make = BasicBlock::Create(context, "make", ctx.Func);
         const auto main = BasicBlock::Create(context, "main", ctx.Func);
 
-        BranchInst::Create(make, main, IsInvalid(statePtr, block), block);
+        BranchInst::Create(make, main, IsInvalid(statePtr, block, context), block);
         block = make;
 
         const auto ptrType = PointerType::getUnqual(StructType::get(context));
@@ -1047,7 +1047,7 @@ public:
 
         result->addIncoming(GetFinish(context), block);
 
-        BranchInst::Create(over, more, IsFinish(state, block), block);
+        BranchInst::Create(over, more, IsFinish(state, block, context), block);
 
         block = more;
 
@@ -1212,7 +1212,7 @@ public:
         const auto make = BasicBlock::Create(context, "make", ctx.Func);
         const auto main = BasicBlock::Create(context, "main", ctx.Func);
 
-        BranchInst::Create(make, main, IsInvalid(statePtr, block), block);
+        BranchInst::Create(make, main, IsInvalid(statePtr, block, context), block);
         block = make;
 
         const auto ptrType = PointerType::getUnqual(StructType::get(context));
@@ -1238,7 +1238,7 @@ public:
 
         result->addIncoming(GetFinish(context), block);
 
-        BranchInst::Create(over, more, IsFinish(state, block), block);
+        BranchInst::Create(over, more, IsFinish(state, block, context), block);
 
         block = more;
 
@@ -1535,7 +1535,7 @@ public:
         const auto make = BasicBlock::Create(context, "make", ctx.Func);
         const auto main = BasicBlock::Create(context, "main", ctx.Func);
 
-        BranchInst::Create(make, main, IsInvalid(statePtr, block), block);
+        BranchInst::Create(make, main, IsInvalid(statePtr, block, context), block);
         block = make;
 
         const auto ptrType = PointerType::getUnqual(StructType::get(context));
@@ -1561,7 +1561,7 @@ public:
 
         result->addIncoming(GetFinish(context), block);
 
-        BranchInst::Create(over, more, IsFinish(state, block), block);
+        BranchInst::Create(over, more, IsFinish(state, block, context), block);
 
         block = more;
 
@@ -1734,7 +1734,7 @@ public:
         const auto make = BasicBlock::Create(context, "make", ctx.Func);
         const auto main = BasicBlock::Create(context, "main", ctx.Func);
 
-        BranchInst::Create(make, main, IsInvalid(statePtr, block), block);
+        BranchInst::Create(make, main, IsInvalid(statePtr, block, context), block);
         block = make;
 
         const auto ptrType = PointerType::getUnqual(StructType::get(context));
@@ -1760,7 +1760,7 @@ public:
 
         result->addIncoming(GetFinish(context), block);
 
-        BranchInst::Create(over, more, IsFinish(state, block), block);
+        BranchInst::Create(over, more, IsFinish(state, block, context), block);
 
         block = more;
 
diff --git a/yql/essentials/minikql/comp_nodes/mkql_udf.cpp b/yql/essentials/minikql/comp_nodes/mkql_udf.cpp
index 432b155380..9240dad141 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_udf.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_udf.cpp
@@ -156,7 +156,7 @@ public:
         const auto ptrType = PointerType::getUnqual(StructType::get(context));
         const auto self = CastInst::Create(Instruction::IntToPtr, ConstantInt::get(Type::getInt64Ty(context), uintptr_t(this)), ptrType, "self", block);
 
-        BranchInst::Create(main, make, HasValue(udfPtr, block), block);
+        BranchInst::Create(main, make, HasValue(udfPtr, block, context), block);
 
         block = make;
 
diff --git a/yql/essentials/minikql/comp_nodes/mkql_unwrap.cpp b/yql/essentials/minikql/comp_nodes/mkql_unwrap.cpp
index 73c4e73ac6..74425bb7a0 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_unwrap.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_unwrap.cpp
@@ -34,7 +34,7 @@ public:
         const auto kill = BasicBlock::Create(context, "kill", ctx.Func);
         const auto good = BasicBlock::Create(context, "good", ctx.Func);
 
-        BranchInst::Create(kill, good, IsEmpty(value, block), block);
+        BranchInst::Create(kill, good, IsEmpty(value, block, context), block);
 
         block = kill;
         const auto doFunc = ConstantInt::get(Type::getInt64Ty(context), GetMethodPtr(&TUnwrapWrapper::Throw));
diff --git a/yql/essentials/minikql/comp_nodes/mkql_varitem.cpp b/yql/essentials/minikql/comp_nodes/mkql_varitem.cpp
index f454c3d58f..e5693c5896 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_varitem.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_varitem.cpp
@@ -43,7 +43,7 @@ public:
             const auto good = BasicBlock::Create(context, "good", ctx.Func);
             const auto none = BasicBlock::Create(context, "none", ctx.Func);
 
-            BranchInst::Create(none, good, IsEmpty(var, block), block);
+            BranchInst::Create(none, good, IsEmpty(var, block, context), block);
 
             block = none;
             new StoreInst(var, pointer, block);
diff --git a/yql/essentials/minikql/comp_nodes/mkql_visitall.cpp b/yql/essentials/minikql/comp_nodes/mkql_visitall.cpp
index 7a6c9c6ab8..64a3142f7a 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_visitall.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_visitall.cpp
@@ -104,7 +104,7 @@ public:
         const auto valueType = Type::getInt128Ty(context);
         const auto result = PHINode::Create(valueType, NewNodes.size() + 2U, "result", done);
 
-        BranchInst::Create(init, work, IsInvalid(statePtr, block), block);
+        BranchInst::Create(init, work, IsInvalid(statePtr, block, context), block);
 
         {
             block = init;
@@ -199,7 +199,7 @@ public:
         const auto resultType = Type::getInt32Ty(context);
         const auto result = PHINode::Create(resultType, NewNodes.size() + 2U, "result", done);
 
-        BranchInst::Create(init, work, IsInvalid(statePtr, block), block);
+        BranchInst::Create(init, work, IsInvalid(statePtr, block, context), block);
 
         {
             block = init;
diff --git a/yql/essentials/minikql/comp_nodes/mkql_way.cpp b/yql/essentials/minikql/comp_nodes/mkql_way.cpp
index 5a3546f494..b27fb920c3 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_way.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_way.cpp
@@ -50,7 +50,7 @@ public:
 
         if (IsOptional) {
             const auto good = BasicBlock::Create(context, "good", ctx.Func);
-            BranchInst::Create(done, good, IsEmpty(var, block), block);
+            BranchInst::Create(done, good, IsEmpty(var, block, context), block);
             result->addIncoming(zero, block);
 
             block = good;
diff --git a/yql/essentials/minikql/comp_nodes/mkql_while.cpp b/yql/essentials/minikql/comp_nodes/mkql_while.cpp
index b3544378e3..907af8f625 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_while.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_while.cpp
@@ -70,7 +70,7 @@ public:
         block = work;
         const auto item = GetNodeValue(Flow, ctx, block);
         result->addIncoming(item, block);
-        BranchInst::Create(done, good, IsSpecial(item, block), block);
+        BranchInst::Create(done, good, IsSpecial(item, block, context), block);
 
         block = good;
         codegenItem->CreateSetValue(ctx, block, item);
@@ -324,7 +324,6 @@ protected:
         ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
         DISubprogramAnnotator annotator(ctx, ctx.Func);
-        
 
         auto args = ctx.Func->arg_begin();
 
@@ -390,7 +389,7 @@ protected:
 
         block = pass;
 
-        SafeUnRefUnboxed(valuePtr, ctx, block);
+        SafeUnRefUnboxedOne(valuePtr, ctx, block);
         new StoreInst(item, valuePtr, block);
         ValueAddRef(Item->GetRepresentation(), valuePtr, ctx, block);
         BranchInst::Create(done, block);
diff --git a/yql/essentials/minikql/comp_nodes/mkql_wide_chain_map.cpp b/yql/essentials/minikql/comp_nodes/mkql_wide_chain_map.cpp
index f11627a8d5..60c952d01a 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_wide_chain_map.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_wide_chain_map.cpp
@@ -67,7 +67,7 @@ public:
         const auto init = BasicBlock::Create(context, "init", ctx.Func);
         const auto next = BasicBlock::Create(context, "next", ctx.Func);
 
-        const auto flag = IsInvalid(statePtr, block);
+        const auto flag = IsInvalid(statePtr, block, context);
         new StoreInst(flag, flagPtr, block);
         BranchInst::Create(init, next, flag, block);
 
diff --git a/yql/essentials/minikql/comp_nodes/mkql_wide_combine.cpp b/yql/essentials/minikql/comp_nodes/mkql_wide_combine.cpp
index 1407d63cdc..b755ab1551 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_wide_combine.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_wide_combine.cpp
@@ -1078,7 +1078,7 @@ public:
         const auto main = BasicBlock::Create(context, "main", ctx.Func);
         const auto more = BasicBlock::Create(context, "more", ctx.Func);
 
-        BranchInst::Create(make, main, IsInvalid(statePtr, block), block);
+        BranchInst::Create(make, main, IsInvalid(statePtr, block, context), block);
         block = make;
 
         const auto ptrType = PointerType::getUnqual(StructType::get(context));
@@ -1542,7 +1542,7 @@ public:
         const auto main = BasicBlock::Create(context, "main", ctx.Func);
         const auto more = BasicBlock::Create(context, "more", ctx.Func);
 
-        BranchInst::Create(make, main, IsInvalid(statePtr, block), block);
+        BranchInst::Create(make, main, IsInvalid(statePtr, block, context), block);
         block = make;
 
         const auto ptrType = PointerType::getUnqual(StructType::get(context));
diff --git a/yql/essentials/minikql/comp_nodes/mkql_wide_condense.cpp b/yql/essentials/minikql/comp_nodes/mkql_wide_condense.cpp
index b3ad763a03..621ac45fce 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_wide_condense.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_wide_condense.cpp
@@ -176,7 +176,7 @@ public:
 
         if constexpr (Interruptable) {
             const auto pass = BasicBlock::Create(context, "pass", ctx.Func);
-            BranchInst::Create(stop, next, IsEmpty(reset, block), block);
+            BranchInst::Create(stop, next, IsEmpty(reset, block, context), block);
             block = pass;
         }
 
diff --git a/yql/essentials/minikql/comp_nodes/mkql_wide_filter.cpp b/yql/essentials/minikql/comp_nodes/mkql_wide_filter.cpp
index 3eeea9b8df..6aa8cce73a 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_wide_filter.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_wide_filter.cpp
@@ -179,11 +179,11 @@ public:
         auto decr = BasicBlock::Create(context, "decr", ctx.Func);
         auto maybeResultVal = PHINode::Create(TMaybeFetchResult::LLVMType(context), 4, "maybe_res", pass);
 
-        auto stateVal = new LoadInst(statePtrVal->getType()->getPointerElementType(), statePtrVal, "state", block);
+        auto stateVal = new LoadInst(Type::getInt128Ty(context), statePtrVal, "state", block);
         auto needFetchCond = CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_NE, GetFalse(context), stateVal, "need_fetch", block);
         maybeResultVal->addIncoming(TMaybeFetchResult(EFetchResult::Finish).LLVMConst(context), block);
         BranchInst::Create(fetch, pass, needFetchCond, block);
-        
+
         block = fetch;
         auto [fetchResVal, fetchGetters] = fetchGenerator(ctx, block);
         auto passCond = CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_NE, ConstantInt::get(fetchResVal->getType(), static_cast<i32>(EFetchResult::One)), fetchResVal, "not_one", block);
@@ -262,11 +262,11 @@ public:
         auto check = BasicBlock::Create(context, "check", ctx.Func);
         auto maybeResultVal = PHINode::Create(TMaybeFetchResult::LLVMType(context), 3, "maybe_res", pass);
 
-        auto stateVal = new LoadInst(statePtrVal->getType()->getPointerElementType(), statePtrVal, "state", block);
+        auto stateVal = new LoadInst(Type::getInt128Ty(context), statePtrVal, "state", block);
         auto needFetchCond = CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_NE, GetTrue(context), stateVal, "need_fetch", block);
         maybeResultVal->addIncoming(TMaybeFetchResult(EFetchResult::Finish).LLVMConst(context), block);
         BranchInst::Create(fetch, pass, needFetchCond, block);
-        
+
         block = fetch;
         auto [fetchResVal, fetchGetters] = fetchGenerator(ctx, block);
         auto passCond = CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_NE, ConstantInt::get(fetchResVal->getType(), static_cast<i32>(EFetchResult::One)), fetchResVal, "not_one", block);
@@ -338,7 +338,7 @@ public:
         auto maybeResultVal = PHINode::Create(TMaybeFetchResult::LLVMType(context), 3, "maybe_res", pass);
 
         auto [fetchResVal, fetchGetters] = fetchGenerator(ctx, block);
-        auto stateVal = new LoadInst(statePtrVal->getType()->getPointerElementType(), statePtrVal, "state", block);
+        auto stateVal = new LoadInst(Type::getInt128Ty(context), statePtrVal, "state", block);
         auto needCheckCond = CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_NE, GetTrue(context), stateVal, "need_check", block);
         auto oneCond = CmpInst::Create(Instruction::ICmp, CmpInst::ICMP_EQ, ConstantInt::get(fetchResVal->getType(), static_cast<i32>(EFetchResult::One)), fetchResVal, "one", block);
         auto willCheckCond = BinaryOperator::Create(Instruction::And, needCheckCond, oneCond, "will_check", block);
@@ -356,7 +356,7 @@ public:
         BranchInst::Create(pass, block);
 
         block = pass;
-        
+
         return {maybeResultVal, std::move(fetchGetters)};
     }
 #endif
diff --git a/yql/essentials/minikql/comp_nodes/mkql_wide_map.cpp b/yql/essentials/minikql/comp_nodes/mkql_wide_map.cpp
index abdca41cac..f45d73a7c8 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_wide_map.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_wide_map.cpp
@@ -40,7 +40,7 @@ public:
         const auto item = GetNodeValue(Flow, ctx, block);
 
         const auto resultType = Type::getInt32Ty(context);
-        const auto outres = SelectInst::Create(IsYield(item, block), ConstantInt::get(resultType, 0), ConstantInt::get(resultType, -1), "outres", block);
+        const auto outres = SelectInst::Create(IsYield(item, block, context), ConstantInt::get(resultType, 0), ConstantInt::get(resultType, -1), "outres", block);
 
         const auto work = BasicBlock::Create(context, "work", ctx.Func);
         const auto pass = BasicBlock::Create(context, "pass", ctx.Func);
@@ -48,7 +48,7 @@ public:
 
         result->addIncoming(outres, block);
 
-        BranchInst::Create(pass, work, IsSpecial(item, block), block);
+        BranchInst::Create(pass, work, IsSpecial(item, block, context), block);
 
         block = work;
         codegenItem->CreateSetValue(ctx, block, item);
diff --git a/yql/essentials/minikql/comp_nodes/mkql_wide_top_sort.cpp b/yql/essentials/minikql/comp_nodes/mkql_wide_top_sort.cpp
index 80f640f038..ada394d9c7 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_wide_top_sort.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_wide_top_sort.cpp
@@ -436,7 +436,7 @@ public:
         const auto main = BasicBlock::Create(context, "main", ctx.Func);
         const auto more = BasicBlock::Create(context, "more", ctx.Func);
 
-        annotate(BranchInst::Create(make, main, IsInvalid(statePtr, block), block));
+        annotate(BranchInst::Create(make, main, IsInvalid(statePtr, block, context), block));
         block = make;
 
         const auto count = GetNodeValue(Count, ctx, block);
@@ -959,7 +959,7 @@ public:
         const auto main = BasicBlock::Create(context, "main", ctx.Func);
         const auto more = BasicBlock::Create(context, "more", ctx.Func);
 
-        annotate(BranchInst::Create(make, main, IsInvalid(statePtr, block), block));
+        annotate(BranchInst::Create(make, main, IsInvalid(statePtr, block, context), block));
         block = make;
 
         const auto arrayType = ArrayType::get(Type::getInt1Ty(context), Directions.size());
diff --git a/yql/essentials/minikql/comp_nodes/mkql_withcontext.cpp b/yql/essentials/minikql/comp_nodes/mkql_withcontext.cpp
index 99beb2db55..163f76e38c 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_withcontext.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_withcontext.cpp
@@ -116,7 +116,7 @@ public:
         const auto make = BasicBlock::Create(context, "make", ctx.Func);
         const auto main = BasicBlock::Create(context, "main", ctx.Func);
 
-        BranchInst::Create(main, make, HasValue(statePtr, block), block);
+        BranchInst::Create(main, make, HasValue(statePtr, block, context), block);
         block = make;
 
         const auto ptrType = PointerType::getUnqual(StructType::get(context));
@@ -139,7 +139,7 @@ public:
         CallInst::Create(attachFuncType, attachFuncPtr, { stateArg }, "", block);
 
         const auto value = GetNodeValue(Flow, ctx, block);
-        const auto finish = IsFinish(value, block);
+        const auto finish = IsFinish(value, block, context);
 
         const auto detachFunc = ConstantInt::get(Type::getInt64Ty(context), GetMethodPtr(&TState::Detach));
         const auto detachFuncType = FunctionType::get(Type::getVoidTy(context), { statePtrType, finish->getType() }, false);
@@ -198,7 +198,7 @@ public:
         const auto good = BasicBlock::Create(context, "good", ctx.Func);
         const auto exit = BasicBlock::Create(context, "exit", ctx.Func);
 
-        BranchInst::Create(main, make, HasValue(statePtr, block), block);
+        BranchInst::Create(main, make, HasValue(statePtr, block, context), block);
         block = make;
 
         const auto ptrType = PointerType::getUnqual(StructType::get(context));
diff --git a/yql/essentials/minikql/comp_nodes/ya.make b/yql/essentials/minikql/comp_nodes/ya.make
index fa7a96b61a..0993674158 100644
--- a/yql/essentials/minikql/comp_nodes/ya.make
+++ b/yql/essentials/minikql/comp_nodes/ya.make
@@ -12,9 +12,11 @@ END()
 
 RECURSE(
     llvm14
+    llvm16
     no_llvm
 )
 
 RECURSE_FOR_TESTS(
     llvm14/ut
+    llvm16/ut
 )
diff --git a/yql/essentials/minikql/computation/llvm16/ut/ya.make b/yql/essentials/minikql/computation/llvm16/ut/ya.make
new file mode 100644
index 0000000000..a72c060701
--- /dev/null
+++ b/yql/essentials/minikql/computation/llvm16/ut/ya.make
@@ -0,0 +1,20 @@
+UNITTEST()
+
+PEERDIR(
+    yql/essentials/minikql/codegen/llvm16
+    yql/essentials/minikql/computation/llvm16
+    yql/essentials/minikql/comp_nodes/llvm16
+    contrib/libs/llvm16/lib/IR
+    contrib/libs/llvm16/lib/ExecutionEngine/MCJIT
+    contrib/libs/llvm16/lib/Linker
+    contrib/libs/llvm16/lib/Passes
+    contrib/libs/llvm16/lib/Target/X86
+    contrib/libs/llvm16/lib/Target/X86/AsmParser
+    contrib/libs/llvm16/lib/Target/X86/Disassembler
+    contrib/libs/llvm16/lib/Transforms/IPO
+    contrib/libs/llvm16/lib/Transforms/ObjCARC
+)
+
+INCLUDE(../../ut/ya.make.inc)
+
+END()
diff --git a/yql/essentials/minikql/computation/llvm16/ya.make b/yql/essentials/minikql/computation/llvm16/ya.make
new file mode 100644
index 0000000000..98e800970f
--- /dev/null
+++ b/yql/essentials/minikql/computation/llvm16/ya.make
@@ -0,0 +1,22 @@
+LIBRARY()
+
+PEERDIR(
+    yql/essentials/minikql/codegen/llvm16
+    contrib/libs/llvm16/lib/IR
+    contrib/libs/llvm16/lib/ExecutionEngine/MCJIT
+    contrib/libs/llvm16/lib/Linker
+    contrib/libs/llvm16/lib/Passes
+    contrib/libs/llvm16/lib/Target/X86
+    contrib/libs/llvm16/lib/Target/X86/AsmParser
+    contrib/libs/llvm16/lib/Target/X86/Disassembler
+    contrib/libs/llvm16/lib/Transforms/IPO
+    contrib/libs/llvm16/lib/Transforms/ObjCARC
+)
+
+INCLUDE(../ya.make.inc)
+
+END()
+
+RECURSE_FOR_TESTS(
+    ut
+)
diff --git a/yql/essentials/minikql/computation/mkql_computation_node_codegen.cpp b/yql/essentials/minikql/computation/mkql_computation_node_codegen.cpp
index 113e9da8dc..7379efe3f5 100644
--- a/yql/essentials/minikql/computation/mkql_computation_node_codegen.cpp
+++ b/yql/essentials/minikql/computation/mkql_computation_node_codegen.cpp
@@ -25,19 +25,30 @@ constexpr bool EnableStaticRefcount = true;
 
 using namespace llvm;
 
-Type* GetCompContextType(LLVMContext &context) {
-    const auto ptrValueType = PointerType::getUnqual(Type::getInt128Ty(context));
-    const auto structPtrType = PointerType::getUnqual(StructType::get(context));
+Type* GetStringRefType(LLVMContext &context) {
     const auto stringRefType = StructType::get(context, {
         Type::getInt8PtrTy(context),
         Type::getInt32Ty(context),
         Type::getInt32Ty(context)
     });
+
+    return stringRefType;
+}
+
+Type* GetSourcePosType(LLVMContext &context) {
     const auto sourcePosType = StructType::get(context, {
         Type::getInt32Ty(context),
         Type::getInt32Ty(context),
-        stringRefType
+        GetStringRefType(context)
     });
+
+    return sourcePosType;
+}
+
+Type* GetCompContextType(LLVMContext &context) {
+    const auto ptrValueType = PointerType::getUnqual(Type::getInt128Ty(context));
+    const auto structPtrType = PointerType::getUnqual(StructType::get(context));
+    const auto sourcePosType = GetSourcePosType(context);
     return StructType::get(context, {
         structPtrType,              // factory
         structPtrType,              // stats
@@ -139,7 +150,6 @@ Function* GenerateCompareFunction(NYql::NCodegen::ICodegen& codegen, const TStri
     ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
     DISubprogramAnnotator annotator(ctx, ctx.Func);
-    
 
     auto args = ctx.Func->arg_begin();
 
@@ -151,9 +161,11 @@ Function* GenerateCompareFunction(NYql::NCodegen::ICodegen& codegen, const TStri
 
     const auto lv = &*++args;
     const auto rv = &*++args;
+    const auto lvType = funcType->getParamType(1);
+    const auto rvType = funcType->getParamType(2);
 
-    codegenLeft->SetValueBuilder([lv](const TCodegenContext&) { return lv; });
-    codegenRight->SetValueBuilder([rv](const TCodegenContext&) { return rv; });
+    codegenLeft->SetValueBuilder([lv, lvType](const TCodegenContext&) { return std::make_pair(lv, lvType); });
+    codegenRight->SetValueBuilder([rv, rvType](const TCodegenContext&) { return std::make_pair(rv, rvType); });
 
     codegenLeft->CreateInvalidate(ctx, block);
     codegenRight->CreateInvalidate(ctx, block);
@@ -205,25 +217,25 @@ Value* GetMarkFromUnboxed(Value* value, const TCodegenContext& ctx, BasicBlock*
 }
 
 template<bool BoxedOrString>
-Value* GetPointerFromUnboxed(Value* value, const TCodegenContext& ctx, BasicBlock* block) {
+std::pair<Value*,Type*> GetPointerFromUnboxed(Value* value, const TCodegenContext& ctx, BasicBlock* block) {
     auto& context = ctx.Codegen.GetContext();
 
     const auto type32 = Type::getInt32Ty(context);
     const auto type64 = Type::getInt64Ty(context);
-    const auto type = PointerType::getUnqual(BoxedOrString ?
+    const auto elemType = BoxedOrString ?
         StructType::get(context, {PointerType::getUnqual(StructType::get(context)), type32, Type::getInt16Ty(context)}):
-        StructType::get(context, {type32, type32, type32, type32})
-    );
+        StructType::get(context, {type32, type32, type32, type32});
+    const auto type = PointerType::getUnqual(elemType);
     if (value->getType()->isPointerTy()) {
         const auto strType = StructType::get(context, {type, type64});
         const auto cast = CastInst::Create(Instruction::BitCast, value, PointerType::getUnqual(strType), "cast", block);
         const auto ptr = GetElementPtrInst::CreateInBounds(strType, cast, {ConstantInt::get(type32, 0), ConstantInt::get(type32, 0)}, "ptr", block);
         const auto pointer = new LoadInst(type, ptr, "pointer", block);
-        return pointer;
+        return {pointer, elemType};
     } else {
         const auto half = CastInst::Create(Instruction::Trunc, value, type64, "half", block);
         const auto pointer = CastInst::Create(Instruction::IntToPtr, half, type, "pointer", block);
-        return pointer;
+        return {pointer, elemType};
     }
 }
 
@@ -291,8 +303,8 @@ Value* GenEqualsFunction<true>(NUdf::EDataSlot slot, Value* lv, Value* rv, TCode
 
     const auto res = PHINode::Create(Type::getInt1Ty(context), 2U, "result", done);
 
-    const auto le = IsEmpty(lv, block);
-    const auto re = IsEmpty(rv, block);
+    const auto le = IsEmpty(lv, block, context);
+    const auto re = IsEmpty(rv, block, context);
 
     const auto any = BinaryOperator::CreateOr(le, re, "or", block);
 
@@ -422,8 +434,8 @@ Value* GenCompareFunction<true>(NUdf::EDataSlot slot, Value* lv, Value* rv, TCod
     const auto resultType = Type::getInt32Ty(context);
     const auto res = PHINode::Create(resultType, 3U, "result", done);
 
-    const auto le = IsEmpty(lv, block);
-    const auto re = IsEmpty(rv, block);
+    const auto le = IsEmpty(lv, block, context);
+    const auto re = IsEmpty(rv, block, context);
 
     const auto any = BinaryOperator::CreateOr(le, re, "or", block);
 
@@ -556,7 +568,7 @@ Value* GenHashFunction<true>(NUdf::EDataSlot slot, Value* value, TCodegenContext
 
     const auto res = PHINode::Create(Type::getInt64Ty(context), 2U, "result", done);
 
-    BranchInst::Create(tiny, test, IsEmpty(value, block), block);
+    BranchInst::Create(tiny, test, IsEmpty(value, block, context), block);
 
     block = tiny;
 
@@ -577,8 +589,8 @@ Value* GenHashFunction(NUdf::EDataSlot slot, bool isOptional, Value* value, TCod
     return isOptional ? GenHashFunction<true>(slot, value, ctx, block) : GenHashFunction<false>(slot, value, ctx, block);
 }
 
-Value* LoadIfPointer(Value* value, BasicBlock* block) {
-    return value->getType()->isPointerTy() ? new LoadInst(value->getType()->getPointerElementType(), value, "load_value", block) : value;
+Value* LoadIfPointer(Value* value, Type* itemType, BasicBlock* block) {
+    return value->getType()->isPointerTy() ? new LoadInst(itemType, value, "load_value", block) : value;
 }
 
 }
@@ -602,15 +614,14 @@ Function* GenerateEqualsFunction(NYql::NCodegen::ICodegen& codegen, const TStrin
     ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
     DISubprogramAnnotator annotator(ctx, ctx.Func);
-    
 
     auto args = ctx.Func->arg_begin();
 
     const auto main = BasicBlock::Create(context, "main", ctx.Func);
     auto block = main;
 
-    const auto lv = LoadIfPointer(&*args, block);
-    const auto rv = LoadIfPointer(&*++args, block);
+    const auto lv = LoadIfPointer(&*args, funcType->getParamType(0), block);
+    const auto rv = LoadIfPointer(&*++args, funcType->getParamType(1), block);
 
     if (isTuple) {
         if (types.empty()) {
@@ -734,12 +745,11 @@ Function* GenerateHashFunction(NYql::NCodegen::ICodegen& codegen, const TString&
     ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
     DISubprogramAnnotator annotator(ctx, ctx.Func);
-    
 
     const auto main = BasicBlock::Create(context, "main", ctx.Func);
     auto block = main;
 
-    const auto arg = LoadIfPointer(&*ctx.Func->arg_begin(), block);
+    const auto arg = LoadIfPointer(&*ctx.Func->arg_begin(), funcType->getParamType(0), block);
 
     if (isTuple) {
         if (types.empty()) {
@@ -825,7 +835,6 @@ Function* GenerateEqualsFunction(NYql::NCodegen::ICodegen& codegen, const TStrin
     ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
     DISubprogramAnnotator annotator(ctx, ctx.Func);
-    
 
     auto args = ctx.Func->arg_begin();
 
@@ -887,7 +896,6 @@ Function* GenerateHashFunction(NYql::NCodegen::ICodegen& codegen, const TString&
     ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
     DISubprogramAnnotator annotator(ctx, ctx.Func);
-    
 
     const auto main = BasicBlock::Create(context, "main", ctx.Func);
     auto block = main;
@@ -941,7 +949,6 @@ Function* GenerateCompareFunction(NYql::NCodegen::ICodegen& codegen, const TStri
     ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
     DISubprogramAnnotator annotator(ctx, ctx.Func);
-    
 
     auto args = ctx.Func->arg_begin();
 
@@ -1070,7 +1077,6 @@ Function* TExternalCodegeneratorRootNode::GenerateGetValue(NYql::NCodegen::ICode
     ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
     DISubprogramAnnotator annotator(ctx, ctx.Func);
-    
 
     auto args = ctx.Func->arg_begin();
     if (codegen.GetEffectiveTarget() == NYql::NCodegen::ETarget::Windows) {
@@ -1112,7 +1118,6 @@ Function* TExternalCodegeneratorRootNode::GenerateSetValue(NYql::NCodegen::ICode
     ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
     DISubprogramAnnotator annotator(ctx, ctx.Func);
-    
 
     auto args = ctx.Func->arg_begin();
 
@@ -1123,7 +1128,7 @@ Function* TExternalCodegeneratorRootNode::GenerateSetValue(NYql::NCodegen::ICode
     const auto valueArg = &*++args;
 
     if (codegen.GetEffectiveTarget() == NYql::NCodegen::ETarget::Windows) {
-        const auto value = new LoadInst(valueArg->getType()->getPointerElementType(), valueArg, "load_value", main);
+        const auto value = new LoadInst(valueArg->getType(), valueArg, "load_value", main);
         CreateSetValue(ctx, main, value);
     } else {
         CreateSetValue(ctx, main, valueArg);
@@ -1134,13 +1139,13 @@ Function* TExternalCodegeneratorRootNode::GenerateSetValue(NYql::NCodegen::ICode
 
 Value* TExternalCodegeneratorNode::CreateGetValue(const TCodegenContext& ctx, BasicBlock*& block) const {
     if (ValueGetterBuilder) {
-        llvm::Function * ValueGetter = ValueGetterBuilder(ctx);
-        return CallInst::Create(ValueGetter, {ctx.Ctx}, "getter", block);
+        llvm::Function* valueGetter = ValueGetterBuilder(ctx);
+        return CallInst::Create(valueGetter, {ctx.Ctx}, "getter", block);
     }
 
     if (ValueBuilder) {
-        llvm::Value * TemporaryValue = ValueBuilder(ctx);
-        return LoadIfPointer(TemporaryValue, block);
+        auto [temporaryValue, itemType] = ValueBuilder(ctx);
+        return LoadIfPointer(temporaryValue, itemType, block);
     }
 
     MKQL_ENSURE(!Getter, "Wrong LLVM function generation order.");
@@ -1327,43 +1332,51 @@ ConstantInt* GetConstant(ui64 value, LLVMContext &context) {
     return ConstantInt::get(context, APInt(128, 2, init));
 }
 
-Value* IsExists(Value* value, BasicBlock* block) {
-    const auto v = LoadIfPointer(value, block);
+Value* IsExists(Value* value, BasicBlock* block, LLVMContext &context) {
+    auto itemType = Type::getInt128Ty(context);
+    const auto v = LoadIfPointer(value, itemType, block);
     return CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_NE, v, ConstantInt::get(v->getType(), 0ULL), "exists", block);
 }
 
-Value* IsEmpty(Value* value, BasicBlock* block) {
-    const auto v = LoadIfPointer(value, block);
+Value* IsEmpty(Value* value, BasicBlock* block, LLVMContext &context) {
+    auto itemType = Type::getInt128Ty(context);
+    const auto v = LoadIfPointer(value, itemType, block);
     return CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_EQ, v, ConstantInt::get(v->getType(), 0ULL), "empty", block);
 }
 
-Value* IsInvalid(Value* value, BasicBlock* block) {
-    const auto v = LoadIfPointer(value, block);
+Value* IsInvalid(Value* value, BasicBlock* block, LLVMContext &context) {
+    auto itemType = Type::getInt128Ty(context);
+    const auto v = LoadIfPointer(value, itemType, block);
     return CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_EQ, v, ConstantInt::get(v->getType(), InvalidData), "invalid", block);
 }
 
-Value* IsValid(Value* value, BasicBlock* block) {
-    const auto v = LoadIfPointer(value, block);
+Value* IsValid(Value* value, BasicBlock* block, LLVMContext &context) {
+    auto itemType = Type::getInt128Ty(context);
+    const auto v = LoadIfPointer(value, itemType, block);
     return CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_NE, v, ConstantInt::get(v->getType(), InvalidData), "valid", block);
 }
 
-Value* IsFinish(Value* value, BasicBlock* block) {
-    const auto v = LoadIfPointer(value, block);
+Value* IsFinish(Value* value, BasicBlock* block, LLVMContext &context) {
+    auto itemType = Type::getInt128Ty(context);
+    const auto v = LoadIfPointer(value, itemType, block);
     return CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_EQ, v, ConstantInt::get(v->getType(), FinishData), "finish", block);
 }
 
-Value* IsYield(Value* value, BasicBlock* block) {
-    const auto v = LoadIfPointer(value, block);
+Value* IsYield(Value* value, BasicBlock* block, LLVMContext &context) {
+    auto itemType = Type::getInt128Ty(context);
+    const auto v = LoadIfPointer(value, itemType, block);
     return CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_EQ, v, ConstantInt::get(v->getType(), YieldData), "yield", block);
 }
 
-Value* IsSpecial(Value* value, BasicBlock* block) {
-    const auto v = LoadIfPointer(value, block);
-    return BinaryOperator::CreateOr(IsFinish(v, block), IsYield(v, block), "special", block);
+Value* IsSpecial(Value* value, BasicBlock* block, LLVMContext &context) {
+    auto itemType = Type::getInt128Ty(context);
+    const auto v = LoadIfPointer(value, itemType, block);
+    return BinaryOperator::CreateOr(IsFinish(v, block, context), IsYield(v, block, context), "special", block);
 }
 
-Value* HasValue(Value* value, BasicBlock* block) {
-    const auto v = LoadIfPointer(value, block);
+Value* HasValue(Value* value, BasicBlock* block, LLVMContext &context) {
+    auto itemType = Type::getInt128Ty(context);
+    const auto v = LoadIfPointer(value, itemType, block);
     return CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_UGT, v, ConstantInt::get(v->getType(), InvalidData), "has", block);
 }
 
@@ -1423,7 +1436,7 @@ template<> Type* GetTypeFor<double>(LLVMContext &context) { return Type::getDoub
 
 void AddRefBoxed(Value* value, const TCodegenContext& ctx, BasicBlock*& block) {
     auto& context = ctx.Codegen.GetContext();
-    const auto load = value->getType()->isPointerTy() ? new LoadInst(value->getType()->getPointerElementType(), value, "load", block) : value;
+    const auto load = value->getType()->isPointerTy() ? new LoadInst(value->getType(), value, "load", block) : value;
     const auto half = CastInst::Create(Instruction::Trunc, load, Type::getInt64Ty(context), "half", block);
     const auto counterType = Type::getInt32Ty(context);
     const auto type = StructType::get(context, {PointerType::getUnqual(StructType::get(context)), counterType, Type::getInt16Ty(context)});
@@ -1455,7 +1468,7 @@ void AddRefBoxed(Value* value, const TCodegenContext& ctx, BasicBlock*& block) {
 
 void UnRefBoxed(Value* value, const TCodegenContext& ctx, BasicBlock*& block) {
     auto& context = ctx.Codegen.GetContext();
-    const auto load = value->getType()->isPointerTy() ? new LoadInst(value->getType()->getPointerElementType(), value, "load", block) : value;
+    const auto load = value->getType()->isPointerTy() ? new LoadInst(value->getType(), value, "load", block) : value;
     const auto half = CastInst::Create(Instruction::Trunc, load, Type::getInt64Ty(context), "half", block);
     const auto counterType = Type::getInt32Ty(context);
     const auto type = StructType::get(context, {PointerType::getUnqual(StructType::get(context)), counterType, Type::getInt16Ty(context)});
@@ -1498,7 +1511,7 @@ void UnRefBoxed(Value* value, const TCodegenContext& ctx, BasicBlock*& block) {
 
 void CleanupBoxed(Value* value, const TCodegenContext& ctx, BasicBlock*& block) {
     auto& context = ctx.Codegen.GetContext();
-    const auto load = value->getType()->isPointerTy() ? new LoadInst(value->getType()->getPointerElementType(), value, "load", block) : value;
+    const auto load = value->getType()->isPointerTy() ? new LoadInst(value->getType(), value, "load", block) : value;
     const auto half = CastInst::Create(Instruction::Trunc, load, Type::getInt64Ty(context), "half", block);
     const auto counterType = Type::getInt32Ty(context);
     const auto type = StructType::get(context, {PointerType::getUnqual(StructType::get(context)), counterType, Type::getInt16Ty(context)});
@@ -1549,8 +1562,8 @@ void ChangeRefUnboxed(Value* value, const TCodegenContext& ctx, BasicBlock*& blo
     {
         block = strb;
 
-        const auto strptr = GetPointerFromUnboxed<false>(value, ctx, block);
-        const auto elemptr = GetElementPtrInst::CreateInBounds(strptr->getType()->getPointerElementType(), strptr, {ConstantInt::get(type32, 0), ConstantInt::get(type32, 1)}, "elemptr", block);
+        const auto [strptr, strtype] = GetPointerFromUnboxed<false>(value, ctx, block);
+        const auto elemptr = GetElementPtrInst::CreateInBounds(strtype, strptr, {ConstantInt::get(type32, 0), ConstantInt::get(type32, 1)}, "elemptr", block);
         refsptr->addIncoming(elemptr, block);
         BranchInst::Create(doit, block);
     }
@@ -1558,8 +1571,8 @@ void ChangeRefUnboxed(Value* value, const TCodegenContext& ctx, BasicBlock*& blo
     {
         block = boxb;
 
-        const auto boxptr = GetPointerFromUnboxed<true>(value, ctx, block);;
-        const auto elemptr = GetElementPtrInst::CreateInBounds(boxptr->getType()->getPointerElementType(), boxptr, {ConstantInt::get(type32, 0), ConstantInt::get(type32, 1)}, "elemptr", block);
+        const auto [boxptr, boxtype] = GetPointerFromUnboxed<true>(value, ctx, block);
+        const auto elemptr = GetElementPtrInst::CreateInBounds(boxtype, boxptr, {ConstantInt::get(type32, 0), ConstantInt::get(type32, 1)}, "elemptr", block);
         refsptr->addIncoming(elemptr, block);
         BranchInst::Create(doit, block);
     }
@@ -1606,8 +1619,8 @@ void CheckRefUnboxed(Value* value, const TCodegenContext& ctx, BasicBlock*& bloc
     {
         block = strb;
 
-        const auto strptr = GetPointerFromUnboxed<false>(value, ctx, block);
-        const auto refptr = GetElementPtrInst::CreateInBounds(strptr->getType()->getPointerElementType(), strptr, {ConstantInt::get(type32, 0), ConstantInt::get(type32, 1)}, "refptr", block);
+        const auto [strptr, strtype] = GetPointerFromUnboxed<false>(value, ctx, block);
+        const auto refptr = GetElementPtrInst::CreateInBounds(strtype, strptr, {ConstantInt::get(type32, 0), ConstantInt::get(type32, 1)}, "refptr", block);
         const auto refs = new LoadInst(type32, refptr, "refs", block);
 
 #if UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 4)
@@ -1647,8 +1660,8 @@ void CheckRefUnboxed(Value* value, const TCodegenContext& ctx, BasicBlock*& bloc
     {
         block = boxb;
 
-        const auto boxptr = GetPointerFromUnboxed<true>(value, ctx, block);;
-        const auto refptr = GetElementPtrInst::CreateInBounds(boxptr->getType()->getPointerElementType(), boxptr, {ConstantInt::get(type32, 0), ConstantInt::get(type32, 1)}, "cntptr", block);
+        const auto [boxptr, boxtype] = GetPointerFromUnboxed<true>(value, ctx, block);;
+        const auto refptr = GetElementPtrInst::CreateInBounds(boxtype, boxptr, {ConstantInt::get(type32, 0), ConstantInt::get(type32, 1)}, "cntptr", block);
         const auto refs = new LoadInst(type32, refptr, "refs", block);
 
 #if UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 4)
@@ -1743,20 +1756,22 @@ void CleanupUnboxed(Value* value, const TCodegenContext& ctx, BasicBlock*& block
 }
 #endif
 
-void SafeUnRefUnboxed(Value* pointer, const TCodegenContext& ctx, BasicBlock*& block) {
-    if (const auto itemType = pointer->getType()->getPointerElementType(); itemType->isArrayTy()) {
-        const auto indexType = Type::getInt64Ty(ctx.Codegen.GetContext());
-        Value* zeros = UndefValue::get(itemType);
-        for (ui32 idx = 0U; idx < itemType->getArrayNumElements(); ++idx) {
-            const auto item = GetElementPtrInst::CreateInBounds(itemType, pointer, {  ConstantInt::get(indexType, 0), ConstantInt::get(indexType, idx) }, (TString("item_") += ToString(idx)).c_str(), block);
-            UnRefUnboxed(item, ctx, block);
-            zeros = InsertValueInst::Create(zeros, ConstantInt::get(itemType->getArrayElementType(), 0), {idx}, (TString("zero_") += ToString(idx)).c_str(), block);
-        }
-        new StoreInst(zeros, pointer, block);
-    } else {
-        UnRefUnboxed(pointer, ctx, block);
-        new StoreInst(ConstantInt::get(itemType, 0), pointer, block);
+void SafeUnRefUnboxedOne(Value* pointer, const TCodegenContext& ctx, BasicBlock*& block) {
+    auto itemType = Type::getInt128Ty(ctx.Codegen.GetContext());
+    UnRefUnboxed(pointer, ctx, block);
+    new StoreInst(ConstantInt::get(itemType, 0), pointer, block);
+}
+
+void SafeUnRefUnboxedArray(Value* pointer, ArrayType* arrayType, const TCodegenContext& ctx, BasicBlock*& block) {
+    auto itemType = arrayType->getElementType();
+    const auto indexType = Type::getInt64Ty(ctx.Codegen.GetContext());
+    Value* zeros = UndefValue::get(itemType);
+    for (ui32 idx = 0U; idx < arrayType->getNumElements(); ++idx) {
+        const auto item = GetElementPtrInst::CreateInBounds(itemType, pointer, { ConstantInt::get(indexType, 0), ConstantInt::get(indexType, idx) }, (TString("item_") += ToString(idx)).c_str(), block);
+        UnRefUnboxed(item, ctx, block);
+        zeros = InsertValueInst::Create(zeros, ConstantInt::get(itemType->getArrayElementType(), 0), {idx}, (TString("zero_") += ToString(idx)).c_str(), block);
     }
+    new StoreInst(zeros, pointer, block);
 }
 
 void ValueAddRef(EValueRepresentation kind, Value* pointer, const TCodegenContext& ctx, BasicBlock*& block) {
@@ -2358,7 +2373,7 @@ Y_NO_INLINE Value* TPairStateFlowCodegeneratorNodeBase::CreateGetValueImpl(
     }
 }
 
-Y_NO_INLINE Value* TBinaryCodegeneratorNodeBase::CreateGetValueImpl(const IComputationNode* node, 
+Y_NO_INLINE Value* TBinaryCodegeneratorNodeBase::CreateGetValueImpl(const IComputationNode* node,
     const TCodegenContext& ctx, BasicBlock*& block) const {
     const auto value = DoGenerateGetValue(ctx, block);
     if (value->getType()->isPointerTy()) {
@@ -2401,7 +2416,6 @@ Function* TMutableCodegeneratorNodeBase::GenerateInternalGetValue(const TString&
     ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
     DISubprogramAnnotator annotator(ctx, ctx.Func);
-    
 
     auto main = BasicBlock::Create(context, "main", ctx.Func);
     ctx.Ctx = &*ctx.Func->arg_begin();
@@ -2509,7 +2523,6 @@ Function* TMutableCodegeneratorPtrNodeBase::GenerateInternalGetValue(const TStri
     ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
     DISubprogramAnnotator annotator(ctx, ctx.Func);
-    
 
     auto main = BasicBlock::Create(context, "main", ctx.Func);
     ctx.Ctx = &*ctx.Func->arg_begin();
@@ -2562,7 +2575,6 @@ Y_NO_INLINE Function* TCodegeneratorRootNodeBase::GenerateGetValueImpl(
     ctx.Func = cast<Function>(module.getOrInsertFunction(name.c_str(), funcType).getCallee());
 
     DISubprogramAnnotator annotator(ctx, ctx.Func);
-    
 
     auto args = ctx.Func->arg_begin();
     if (codegen.GetEffectiveTarget() == NYql::NCodegen::ETarget::Windows) {
diff --git a/yql/essentials/minikql/computation/mkql_computation_node_codegen.h.txt b/yql/essentials/minikql/computation/mkql_computation_node_codegen.h.txt
index 66ca06ccd2..ebd63455eb 100644
--- a/yql/essentials/minikql/computation/mkql_computation_node_codegen.h.txt
+++ b/yql/essentials/minikql/computation/mkql_computation_node_codegen.h.txt
@@ -92,6 +92,8 @@ using NYql::GetMethodIndex;
 using namespace llvm;
 
 Type* GetCompContextType(LLVMContext &context);
+Type* GetStringRefType(LLVMContext &context);
+Type* GetSourcePosType(LLVMContext &context);
 
 class DISubprogramAnnotator;
 
@@ -158,7 +160,7 @@ public:
     virtual Value* CreateSwapValue(const TCodegenContext& ctx, BasicBlock*& block, Value* value) const = 0;
     virtual void CreateInvalidate(const TCodegenContext& ctx, BasicBlock*& block) const = 0;
 
-    using TValueBuilder = std::function<llvm::Value * (const TCodegenContext &)>;
+    using TValueBuilder = std::function<std::pair<llvm::Value*,llvm::Type*> (const TCodegenContext &)>;
     virtual void SetValueBuilder(TValueBuilder valueBuilder) = 0;
 
     using TValueGetterBuilder = std::function<llvm::Function * (const TCodegenContext &)>;
@@ -233,7 +235,8 @@ void AddRefBoxed(Value* value, const TCodegenContext& ctx, BasicBlock*& block);
 void UnRefBoxed(Value* value, const TCodegenContext& ctx, BasicBlock*& block);
 void CleanupBoxed(Value* value, const TCodegenContext& ctx, BasicBlock*& block);
 
-void SafeUnRefUnboxed(Value* pointer, const TCodegenContext& ctx, BasicBlock*& block);
+void SafeUnRefUnboxedOne(Value* pointer, const TCodegenContext& ctx, BasicBlock*& block);
+void SafeUnRefUnboxedArray(Value* pointer, ArrayType* arrayType, const TCodegenContext& ctx, BasicBlock*& block);
 
 void ValueAddRef(EValueRepresentation kind, Value* pointer, const TCodegenContext& ctx, BasicBlock*& block);
 void ValueUnRef(EValueRepresentation kind, Value* pointer, const TCodegenContext& ctx, BasicBlock*& block);
@@ -1195,14 +1198,14 @@ ConstantInt* GetYield(LLVMContext &context);
 
 ConstantInt* GetConstant(ui64 value, LLVMContext &context);
 
-Value* IsExists(Value* value, BasicBlock* block);
-Value* IsEmpty(Value* value, BasicBlock* block);
-Value* IsInvalid(Value* value, BasicBlock* block);
-Value* IsValid(Value* value, BasicBlock* block);
-Value* IsFinish(Value* value, BasicBlock* block);
-Value* IsYield(Value* value, BasicBlock* block);
-Value* IsSpecial(Value* value, BasicBlock* block);
-Value* HasValue(Value* value, BasicBlock* block);
+Value* IsExists(Value* value, BasicBlock* block, LLVMContext &context);
+Value* IsEmpty(Value* value, BasicBlock* block, LLVMContext &context);
+Value* IsInvalid(Value* value, BasicBlock* block, LLVMContext &context);
+Value* IsValid(Value* value, BasicBlock* block, LLVMContext &context);
+Value* IsFinish(Value* value, BasicBlock* block, LLVMContext &context);
+Value* IsYield(Value* value, BasicBlock* block, LLVMContext &context);
+Value* IsSpecial(Value* value, BasicBlock* block, LLVMContext &context);
+Value* HasValue(Value* value, BasicBlock* block, LLVMContext &context);
 
 Value* GenNewArray(const TCodegenContext& ctx, Value* size, Value* items, BasicBlock* block);
 
diff --git a/yql/essentials/minikql/computation/mkql_simple_codegen.cpp b/yql/essentials/minikql/computation/mkql_simple_codegen.cpp
index 4f8f4daefb..3703465fa7 100644
--- a/yql/essentials/minikql/computation/mkql_simple_codegen.cpp
+++ b/yql/essentials/minikql/computation/mkql_simple_codegen.cpp
@@ -45,7 +45,7 @@ ICodegeneratorInlineWideNode::TGenerateResult TSimpleStatefulWideFlowCodegenerat
     auto block = genToBlock; // >>> start of main code chunk
 
     const auto stateVal = new LoadInst(valueType, statePtrVal, "state", block);
-    BranchInst::Create(init, loop, IsInvalid(stateVal, block), block);
+    BranchInst::Create(init, loop, IsInvalid(stateVal, block, context), block);
 
     block = init; // state initialization block:
 
@@ -146,4 +146,4 @@ ICodegeneratorInlineWideNode::TGenerateResult TSimpleStatefulWideFlowCodegenerat
 #endif
 
 }
-}
\ No newline at end of file
+}
diff --git a/yql/essentials/minikql/computation/ya.make b/yql/essentials/minikql/computation/ya.make
index 4374567135..c6f1fc58c2 100644
--- a/yql/essentials/minikql/computation/ya.make
+++ b/yql/essentials/minikql/computation/ya.make
@@ -33,9 +33,11 @@ END()
 
 RECURSE(
     llvm14
+    llvm16
     no_llvm
 )
 
 RECURSE_FOR_TESTS(
     llvm14/ut
+    llvm16/ut
 )
diff --git a/yql/essentials/minikql/invoke_builtins/llvm16/ut/ya.make b/yql/essentials/minikql/invoke_builtins/llvm16/ut/ya.make
new file mode 100644
index 0000000000..21a25f0c09
--- /dev/null
+++ b/yql/essentials/minikql/invoke_builtins/llvm16/ut/ya.make
@@ -0,0 +1,22 @@
+UNITTEST()
+
+SRCDIR(yql/essentials/minikql/invoke_builtins/llvm16)
+
+PEERDIR(
+    yql/essentials/minikql/codegen/llvm16
+    yql/essentials/minikql/invoke_builtins/llvm16
+    yql/essentials/minikql/computation/llvm16
+    contrib/libs/llvm16/lib/IR
+    contrib/libs/llvm16/lib/ExecutionEngine/MCJIT
+    contrib/libs/llvm16/lib/Linker
+    contrib/libs/llvm16/lib/Passes
+    contrib/libs/llvm16/lib/Target/X86
+    contrib/libs/llvm16/lib/Target/X86/AsmParser
+    contrib/libs/llvm16/lib/Target/X86/Disassembler
+    contrib/libs/llvm16/lib/Transforms/IPO
+    contrib/libs/llvm16/lib/Transforms/ObjCARC
+)
+
+INCLUDE(../../ut/ya.make.inc)
+
+END()
diff --git a/yql/essentials/minikql/invoke_builtins/llvm16/ya.make b/yql/essentials/minikql/invoke_builtins/llvm16/ya.make
new file mode 100644
index 0000000000..c0e76bea4c
--- /dev/null
+++ b/yql/essentials/minikql/invoke_builtins/llvm16/ya.make
@@ -0,0 +1,25 @@
+LIBRARY()
+
+PEERDIR(
+    yql/essentials/minikql/codegen/llvm16
+    yql/essentials/minikql/computation/llvm16
+    contrib/libs/llvm16/lib/IR
+    contrib/libs/llvm16/lib/ExecutionEngine/MCJIT
+    contrib/libs/llvm16/lib/Linker
+    contrib/libs/llvm16/lib/Passes
+    contrib/libs/llvm16/lib/Target/X86
+    contrib/libs/llvm16/lib/Target/X86/AsmParser
+    contrib/libs/llvm16/lib/Target/X86/Disassembler
+    contrib/libs/llvm16/lib/Transforms/IPO
+    contrib/libs/llvm16/lib/Transforms/ObjCARC
+)
+
+INCLUDE(../ya.make.inc)
+
+PROVIDES(mkql_invoke_builtins)
+
+END()
+
+RECURSE_FOR_TESTS(
+    ut
+)
diff --git a/yql/essentials/minikql/invoke_builtins/mkql_builtins_find.cpp b/yql/essentials/minikql/invoke_builtins/mkql_builtins_find.cpp
index b085f6b93f..1224ecfc59 100644
--- a/yql/essentials/minikql/invoke_builtins/mkql_builtins_find.cpp
+++ b/yql/essentials/minikql/invoke_builtins/mkql_builtins_find.cpp
@@ -29,7 +29,7 @@ struct TFind {
         const auto doFunc = ConstantInt::get(Type::getInt64Ty(context), GetMethodPtr(Find<Reverse>));
         const auto pos = PosOptional ?
             SelectInst::Create(
-                IsEmpty(p, block),
+                IsEmpty(p, block, context),
                 ConstantInt::get(GetTypeFor<std::string_view::size_type>(context), DefaultPos),
                 StaticCast<ui32, std::string_view::size_type>(GetterFor<ui32>(p, context, block), context, block),
             "pos", block):
diff --git a/yql/essentials/minikql/invoke_builtins/mkql_builtins_substring.cpp b/yql/essentials/minikql/invoke_builtins/mkql_builtins_substring.cpp
index 7fd1d27eb1..2b292f6b36 100644
--- a/yql/essentials/minikql/invoke_builtins/mkql_builtins_substring.cpp
+++ b/yql/essentials/minikql/invoke_builtins/mkql_builtins_substring.cpp
@@ -23,14 +23,14 @@ struct TSubString {
         const auto doFunc = ConstantInt::get(Type::getInt64Ty(context), GetMethodPtr(SubString));
         const auto start = StartOptional ?
             SelectInst::Create(
-                IsEmpty(st, block),
+                IsEmpty(st, block, context),
                 ConstantInt::get(GetTypeFor<ui32>(context), std::numeric_limits<ui32>::min()),
                 GetterFor<ui32>(st, context, block), "start", block
             ):
             GetterFor<ui32>(st, context, block);
         const auto count = CountOptional ?
             SelectInst::Create(
-                IsEmpty(cn, block),
+                IsEmpty(cn, block, context),
                 ConstantInt::get(GetTypeFor<ui32>(context), std::numeric_limits<ui32>::max()),
                 GetterFor<ui32>(cn, context, block), "count", block
             ):
diff --git a/yql/essentials/minikql/invoke_builtins/ya.make b/yql/essentials/minikql/invoke_builtins/ya.make
index 846c6063f7..db814660ff 100644
--- a/yql/essentials/minikql/invoke_builtins/ya.make
+++ b/yql/essentials/minikql/invoke_builtins/ya.make
@@ -11,9 +11,11 @@ END()
 
 RECURSE(
     llvm14
+    llvm16
     no_llvm
 )
 
 RECURSE_FOR_TESTS(
     llvm14/ut
+    llvm16/ut
 )