diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index bb040a7d53..7cf419c0e3 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -51,7 +51,7 @@ jobs:
       - name: ccache  # This should always come after the actions/checkout step.
         uses: hendrikmuhs/ccache-action@v1.2
         with:
-          key: ${{ github.job }}-${{ matrix.os }}-${{ matrix.build }}
+          key: ${{ github.job }}-${{ matrix.os }}-llvm${{ matrix.llvm-version }}-${{ matrix.build }}
 
       - name: Install Phasar Dependencies
         shell: bash
diff --git a/.github/workflows/deploy-docs.yml b/.github/workflows/deploy-docs.yml
index f17f92e0e4..600be9314a 100644
--- a/.github/workflows/deploy-docs.yml
+++ b/.github/workflows/deploy-docs.yml
@@ -8,6 +8,7 @@ permissions:
   contents: write
 jobs:
   build-and-deploy:
+    if: github.repository == 'secure-software-engineering/phasar'
     runs-on: ubuntu-24.04
     strategy:
       fail-fast: true
diff --git a/BreakingChanges.md b/BreakingChanges.md
index 31cccf68cc..08d3388003 100644
--- a/BreakingChanges.md
+++ b/BreakingChanges.md
@@ -2,6 +2,8 @@
 
 ## development HEAD
 
+- The function `HelperAnalyses::getAliasInfo()` no longer returns a `LLVMAliasSet &`, but a `LLVMAliasInfoRef`.
+- The location of the library summary `FunctionDataFlowFacts` and `LLVMFunctionDataFlowFacts` has moved to `phasar/Utils/` and `phasar/PhasarLLVM/Utils`, respectively.
 - `IDESolver::initialize()` does no longer return a `bool`. Now, you are always allowed to call `next()` at least once.
 - `IntraMonoProblem` and `InterMonoProblem`, and all reference-implementations of these problems do not receive a TypeHierarchy-pointer anymore in the ctor.
 - Requiring C++20 instead of C++17
diff --git a/CMakeLists.txt b/CMakeLists.txt
index c6a7b1c9f4..1610e9ad57 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -410,7 +410,7 @@ if (PHASAR_ENABLE_WARNINGS)
   if (MSVC)
     string(APPEND CMAKE_CXX_FLAGS " /W4")
   else()
-    string(APPEND CMAKE_CXX_FLAGS " -Wall -Wextra -Wno-unused-parameter")
+    string(APPEND CMAKE_CXX_FLAGS " -Wall -Wextra -Wno-unused-parameter -Werror=return-type")
   endif()
 endif (PHASAR_ENABLE_WARNINGS)
 
diff --git a/include/phasar/ControlFlow/CallGraphBase.h b/include/phasar/ControlFlow/CallGraphBase.h
index 796a31c286..2d39581e3c 100644
--- a/include/phasar/ControlFlow/CallGraphBase.h
+++ b/include/phasar/ControlFlow/CallGraphBase.h
@@ -12,8 +12,14 @@
 
 #include "phasar/Utils/ByRef.h"
 #include "phasar/Utils/CRTPUtils.h"
+#include "phasar/Utils/Compressor.h"
+#include "phasar/Utils/GraphTraits.h"
+#include "phasar/Utils/IotaIterator.h"
+#include "phasar/Utils/NonNullPtr.h"
 #include "phasar/Utils/TypeTraits.h"
 
+#include "llvm/ADT/STLExtras.h"
+
 #include <concepts>
 #include <type_traits>
 
@@ -127,6 +133,92 @@ template <typename Derived> class CallGraphBase : public CRTPBase<Derived> {
 
   [[nodiscard]] constexpr bool empty() const noexcept { return size() == 0; }
 };
+
+/// A view over a call-graph that implements psr::GraphTraits on the
+/// getCallersOf() relation.
+/// Useful to compute CG-SCCs.
+template <typename CallGraphTy, typename DB> class ReverseCGGraph {
+  static constexpr bool NeedsMapping = !IdType<typename CallGraphTy::f_t>;
+
+  enum class FunctionIdImpl : uint32_t {};
+
+public:
+  using FunctionId = std::conditional_t<NeedsMapping, FunctionIdImpl,
+                                        typename CallGraphTy::f_t>;
+
+  constexpr ReverseCGGraph(
+      NonNullPtr<const CallGraphTy> CGView, NonNullPtr<const DB> IRDB,
+      Compressor<typename CallGraphTy::f_t, FunctionId> FC) noexcept
+    requires(NeedsMapping)
+      : CGView(CGView), IRDB(IRDB), FC(std::move(FC)) {}
+
+  constexpr ReverseCGGraph(NonNullPtr<const CallGraphTy> CGView,
+                           NonNullPtr<const DB> IRDB) noexcept
+      : CGView(CGView), IRDB(IRDB) {
+    FC.reserve(CGView->getNumVertexFunctions());
+    for (const auto &Fun : CGView->getAllVertexFunctions()) {
+      FC.insert(Fun);
+    }
+  }
+
+  NonNullPtr<const CallGraphTy> CGView;
+  NonNullPtr<const DB> IRDB;
+  [[no_unique_address]] std::conditional_t<
+      NeedsMapping, Compressor<typename CallGraphTy::f_t, FunctionId>,
+      NoneCompressor> FC{};
+};
+
+template <typename CallGraphTy, typename DB>
+ReverseCGGraph(NonNullPtr<const CallGraphTy>, NonNullPtr<const DB>)
+    -> ReverseCGGraph<CallGraphTy, DB>;
+template <typename CallGraphTy, typename DB>
+ReverseCGGraph(const CallGraphTy *, const DB *)
+    -> ReverseCGGraph<CallGraphTy, DB>;
+
+template <typename CallGraphTy, typename DB>
+struct GraphTraits<ReverseCGGraph<CallGraphTy, DB>> {
+  using graph_type = ReverseCGGraph<CallGraphTy, DB>;
+  using value_type = typename CallGraphTy::f_t;
+  using vertex_t = typename graph_type::FunctionId;
+  using edge_t = vertex_t;
+
+  static constexpr vertex_t Invalid = vertex_t(UINT32_MAX);
+
+  static constexpr auto mapToFunction(const graph_type &G) {
+    return [&G](ByConstRef<typename CallGraphTy::n_t> Inst) {
+      const auto &Fun = G.IRDB->getFunctionOf(Inst);
+      return G.FC.getOrNull(Fun).value();
+    };
+  }
+
+  static constexpr auto outEdges(const graph_type &G, vertex_t Vtx) {
+    return llvm::map_range(G.CGView->getCallersOf(G.FC[Vtx]), mapToFunction(G));
+  }
+
+  static constexpr decltype(auto) nodes(const graph_type &G) {
+    return G.CGView->getAllVertexFunctions();
+  }
+
+  // TODO: Roots
+
+  static constexpr auto vertices(const graph_type &G) {
+    return iota<vertex_t>(G.CGView->getNumVertexFunctions());
+  }
+
+  static constexpr decltype(auto) node(const graph_type &G, vertex_t Vtx) {
+    return G.FC[Vtx];
+  }
+
+  static constexpr size_t size(const graph_type &G) {
+    return G.CGView->getNumVertexFunctions();
+  }
+
+  static constexpr vertex_t target(edge_t Edge) { return Edge; }
+  static constexpr vertex_t withEdgeTarget(edge_t /*Edge*/, vertex_t Vtx) {
+    return Vtx;
+  }
+};
+
 } // namespace psr
 
 #endif // PHASAR_CONTROLFLOW_CALLGRAPHBASE_H
diff --git a/include/phasar/DB/ProjectIRDBBase.h b/include/phasar/DB/ProjectIRDBBase.h
index c30fffd342..0fccf84f0d 100644
--- a/include/phasar/DB/ProjectIRDBBase.h
+++ b/include/phasar/DB/ProjectIRDBBase.h
@@ -10,6 +10,7 @@
 #ifndef PHASAR_DB_PROJECTIRDBBASE_H
 #define PHASAR_DB_PROJECTIRDBBASE_H
 
+#include "phasar/Utils/ByRef.h"
 #include "phasar/Utils/Nullable.h"
 #include "phasar/Utils/TypeTraits.h"
 
@@ -84,6 +85,13 @@ class LLVM_DEPRECATED(
     return self().hasFunctionImpl(FunctionName);
   }
 
+  /// Returns the function that contains the given instruction Inst.
+  /// Each instruction must be part of a function.
+  [[nodiscard]] f_t getFunctionOf(ByConstRef<n_t> Inst) const {
+    assert(isValid());
+    return self().getFunctionOfImpl(Inst);
+  }
+
   /// Returns the global variable if available, nullptr/nullopt
   /// otherwise.
   [[nodiscard]] Nullable<g_t>
diff --git a/include/phasar/DataFlow/IfdsIde/Solver/Compressor.h b/include/phasar/DataFlow/IfdsIde/Solver/Compressor.h
index 7479bbd0c9..98272a3b1e 100644
--- a/include/phasar/DataFlow/IfdsIde/Solver/Compressor.h
+++ b/include/phasar/DataFlow/IfdsIde/Solver/Compressor.h
@@ -9,27 +9,6 @@
 
 namespace psr {
 
-struct NoneCompressor final {
-  constexpr NoneCompressor() noexcept = default;
-
-  template <typename T>
-    requires(!std::is_same_v<NoneCompressor, T>)
-  constexpr NoneCompressor(const T & /*unused*/) noexcept {}
-
-  template <typename T>
-  [[nodiscard]] decltype(auto) getOrInsert(T &&Val) const noexcept {
-    return std::forward<T>(Val);
-  }
-  template <typename T>
-  [[nodiscard]] decltype(auto) operator[](T &&Val) const noexcept {
-    return std::forward<T>(Val);
-  }
-  void reserve(size_t /*unused*/) const noexcept {}
-
-  [[nodiscard]] size_t size() const noexcept { return 0; }
-  [[nodiscard]] size_t capacity() const noexcept { return 0; }
-};
-
 class LLVMProjectIRDB;
 
 /// Once we have fast instruction IDs (as we already have in IntelliSecPhasar),
diff --git a/include/phasar/PhasarLLVM/ControlFlow/VTA/TypePropagator.h b/include/phasar/PhasarLLVM/ControlFlow/VTA/TypePropagator.h
index 2e6d6b874d..b6b12091b0 100644
--- a/include/phasar/PhasarLLVM/ControlFlow/VTA/TypePropagator.h
+++ b/include/phasar/PhasarLLVM/ControlFlow/VTA/TypePropagator.h
@@ -11,6 +11,7 @@
 #define PHASAR_PHASARLLVM_CONTROLFLOW_TYPEPROPAGATOR_H
 
 #include "phasar/PhasarLLVM/ControlFlow/VTA/TypeAssignmentGraph.h"
+#include "phasar/Utils/SCCId.h"
 #include "phasar/Utils/TypedVector.h"
 
 #include "llvm/ADT/DenseSet.h"
@@ -22,7 +23,6 @@ class Value;
 } // namespace llvm
 
 namespace psr {
-template <typename GraphNodeId> struct SCCId;
 template <typename GraphNodeId> struct SCCHolder;
 template <typename GraphNodeId> struct SCCDependencyGraph;
 template <typename GraphNodeId> struct SCCOrder;
diff --git a/include/phasar/PhasarLLVM/DB/LLVMProjectIRDB.h b/include/phasar/PhasarLLVM/DB/LLVMProjectIRDB.h
index 13c3f1f5d5..337ac8ce64 100644
--- a/include/phasar/PhasarLLVM/DB/LLVMProjectIRDB.h
+++ b/include/phasar/PhasarLLVM/DB/LLVMProjectIRDB.h
@@ -189,6 +189,11 @@ class LLVMProjectIRDB : public ProjectIRDBBase<LLVMProjectIRDB> {
   hasFunctionImpl(llvm::StringRef FunctionName) const noexcept {
     return Mod->getFunction(FunctionName) != nullptr;
   }
+  [[nodiscard]] f_t getFunctionOfImpl(n_t Inst) const {
+    assert(Inst != nullptr);
+    return Inst->getFunction();
+  }
+
   [[nodiscard]] g_t
   getGlobalVariableImpl(llvm::StringRef GlobalVariableName) const;
   [[nodiscard]] g_t
diff --git a/include/phasar/PhasarLLVM/DataFlow/IfdsIde/LLVMFunctionDataFlowFacts.h b/include/phasar/PhasarLLVM/DataFlow/IfdsIde/LLVMFunctionDataFlowFacts.h
deleted file mode 100644
index ec19a1b002..0000000000
--- a/include/phasar/PhasarLLVM/DataFlow/IfdsIde/LLVMFunctionDataFlowFacts.h
+++ /dev/null
@@ -1,89 +0,0 @@
-/******************************************************************************
- * Copyright (c) 2025 Fabian Schiebel.
- * All rights reserved. This program and the accompanying materials are made
- * available under the terms of LICENSE.txt.
- *
- * Contributors:
- *     Fabian Schiebel, bulletSpace and others
- *****************************************************************************/
-
-#ifndef PHASAR_PHASARLLVM_DATAFLOW_IFDSIDE_LLVMFUNCTIONDATAFLOWFACTS_H
-#define PHASAR_PHASARLLVM_DATAFLOW_IFDSIDE_LLVMFUNCTIONDATAFLOWFACTS_H
-
-#include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
-#include "phasar/PhasarLLVM/DataFlow/IfdsIde/FunctionDataFlowFacts.h"
-#include "phasar/Utils/DefaultValue.h"
-
-#include "llvm/IR/Argument.h"
-#include "llvm/IR/Function.h"
-
-#include <unordered_map>
-#include <vector>
-
-namespace psr::library_summary {
-
-class LLVMFunctionDataFlowFacts;
-[[nodiscard]] LLVMFunctionDataFlowFacts
-readFromFDFF(const FunctionDataFlowFacts &Fdff, const LLVMProjectIRDB &Irdb);
-
-/// @brief A LLVM-specific mapping of FunctionDataFlowFacts
-class LLVMFunctionDataFlowFacts {
-public:
-  LLVMFunctionDataFlowFacts() noexcept = default;
-  using ParameterMappingTy = FunctionDataFlowFacts::ParameterMappingTy;
-
-  /// insert a set of data flow facts
-  void insertSet(const llvm::Function *Fun, uint32_t Index,
-                 std::vector<DataFlowFact> OutSet) {
-
-    LLVMFdff[Fun].try_emplace(Index, std::move(OutSet));
-  }
-  void insertSet(const llvm::Function *Fun, const llvm::Argument *Arg,
-                 std::vector<DataFlowFact> OutSet) {
-
-    insertSet(Fun, Arg->getArgNo(), std::move(OutSet));
-  }
-
-  void addElement(const llvm::Function *Fun, uint32_t Index, DataFlowFact Out) {
-    LLVMFdff[Fun][Index].emplace_back(Out);
-  }
-  void addElement(const llvm::Function *Fun, const llvm::Argument *Arg,
-                  DataFlowFact Out) {
-    addElement(Fun, Arg->getArgNo(), Out);
-  }
-
-  [[nodiscard]] bool contains(const llvm::Function *Fn) {
-    return LLVMFdff.count(Fn);
-  }
-
-  [[nodiscard]] const std::vector<DataFlowFact> &
-  getFacts(const llvm::Function *Fun, uint32_t Index) {
-    auto Iter = LLVMFdff.find(Fun);
-    if (Iter != LLVMFdff.end()) {
-      return Iter->second[Index];
-    }
-    return getDefaultValue<std::vector<DataFlowFact>>();
-  }
-  [[nodiscard]] const std::vector<DataFlowFact> &
-  getFacts(const llvm::Function *Fun, const llvm::Argument *Arg) {
-    return getFacts(Fun, Arg->getArgNo());
-  }
-
-  [[nodiscard]] const ParameterMappingTy &
-  getFactsForFunction(const llvm::Function *Fun) {
-    auto Iter = LLVMFdff.find(Fun);
-    if (Iter != LLVMFdff.end()) {
-      return Iter->second;
-    }
-    return getDefaultValue<ParameterMappingTy>();
-  }
-
-  friend LLVMFunctionDataFlowFacts
-  readFromFDFF(const FunctionDataFlowFacts &Fdff, const LLVMProjectIRDB &Irdb);
-
-private:
-  std::unordered_map<const llvm::Function *, ParameterMappingTy> LLVMFdff;
-};
-} // namespace psr::library_summary
-
-#endif // PHASAR_PHASARLLVM_DATAFLOW_IFDSIDE_LLVMFUNCTIONDATAFLOWFACTS_H
diff --git a/include/phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSTaintAnalysis.h b/include/phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSTaintAnalysis.h
index 4199dc4ee4..a6025c6254 100644
--- a/include/phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSTaintAnalysis.h
+++ b/include/phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSTaintAnalysis.h
@@ -13,9 +13,9 @@
 #include "phasar/DataFlow/IfdsIde/IFDSTabulationProblem.h"
 #include "phasar/PhasarLLVM/ControlFlow/LLVMBasedICFG.h"
 #include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
-#include "phasar/PhasarLLVM/DataFlow/IfdsIde/LLVMFunctionDataFlowFacts.h"
 #include "phasar/PhasarLLVM/Domain/LLVMAnalysisDomain.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h"
+#include "phasar/PhasarLLVM/Utils/LLVMFunctionDataFlowFacts.h"
 
 #include <map>
 #include <set>
diff --git a/include/phasar/PhasarLLVM/HelperAnalyses.h b/include/phasar/PhasarLLVM/HelperAnalyses.h
index 63b9044444..156e1622bf 100644
--- a/include/phasar/PhasarLLVM/HelperAnalyses.h
+++ b/include/phasar/PhasarLLVM/HelperAnalyses.h
@@ -13,7 +13,9 @@
 #include "phasar/ControlFlow/CallGraphAnalysisType.h"
 #include "phasar/ControlFlow/CallGraphData.h"
 #include "phasar/PhasarLLVM/HelperAnalysisConfig.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasSetData.h"
+#include "phasar/Pointer/UnionFindAliasAnalysisType.h"
 
 #include "llvm/ADT/Twine.h"
 
@@ -60,14 +62,14 @@ class HelperAnalyses { // NOLINT(cppcoreguidelines-special-member-functions)
   ~HelperAnalyses() noexcept;
 
   [[nodiscard]] LLVMProjectIRDB &getProjectIRDB();
-  [[nodiscard]] LLVMAliasSet &getAliasInfo();
+  [[nodiscard]] LLVMAliasInfoRef getAliasInfo();
   [[nodiscard]] DIBasedTypeHierarchy &getTypeHierarchy();
   [[nodiscard]] LLVMBasedICFG &getICFG();
   [[nodiscard]] LLVMBasedCFG &getCFG();
 
 private:
   std::unique_ptr<LLVMProjectIRDB> IRDB;
-  std::unique_ptr<LLVMAliasSet> PT;
+  LLVMAliasInfo PT{};
   std::unique_ptr<DIBasedTypeHierarchy> TH;
   std::unique_ptr<LLVMBasedICFG> ICF;
   std::unique_ptr<LLVMBasedCFG> CFG;
@@ -78,6 +80,7 @@ class HelperAnalyses { // NOLINT(cppcoreguidelines-special-member-functions)
   // PTS
   std::optional<LLVMAliasSetData> PrecomputedPTS;
   AliasAnalysisType PTATy{};
+  UnionFindAliasAnalysisType UFAATy{};
   bool AllowLazyPTS{};
 
   // ICF
diff --git a/include/phasar/PhasarLLVM/HelperAnalysisConfig.h b/include/phasar/PhasarLLVM/HelperAnalysisConfig.h
index be3427667b..d29c12c68d 100644
--- a/include/phasar/PhasarLLVM/HelperAnalysisConfig.h
+++ b/include/phasar/PhasarLLVM/HelperAnalysisConfig.h
@@ -14,6 +14,7 @@
 #include "phasar/ControlFlow/CallGraphData.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasSetData.h"
 #include "phasar/Pointer/AliasAnalysisType.h"
+#include "phasar/Pointer/UnionFindAliasAnalysisType.h"
 #include "phasar/Utils/Soundness.h"
 
 #include <optional>
@@ -23,6 +24,7 @@ struct HelperAnalysisConfig {
   std::optional<LLVMAliasSetData> PrecomputedPTS = std::nullopt;
   std::optional<CallGraphData> PrecomputedCG = std::nullopt;
   AliasAnalysisType PTATy = AliasAnalysisType::CFLAnders;
+  UnionFindAliasAnalysisType UFAATy = UnionFindAliasAnalysisType::CtxIndSens;
   CallGraphAnalysisType CGTy = CallGraphAnalysisType::OTF;
   Soundness SoundnessLevel = Soundness::Soundy;
   bool AutoGlobalSupport = true;
diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h b/include/phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h
index bbe69a0f74..4bb0bc21f6 100644
--- a/include/phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h
@@ -24,6 +24,11 @@ namespace psr {
 using LLVMAliasIteratorRef =
     AliasIteratorRef<const llvm::Value *, const llvm::Instruction *>;
 
+template <typename T>
+concept IsLLVMAliasIterator =
+    detail::IsAliasIteratorFor<T, const llvm::Value *,
+                               const llvm::Instruction *>;
+
 using LLVMAliasInfoRef =
     AliasInfoRef<const llvm::Value *, const llvm::Instruction *>;
 
diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h b/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h
new file mode 100644
index 0000000000..7f118a7d4b
--- /dev/null
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h
@@ -0,0 +1,170 @@
+#pragma once
+
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
+#include "phasar/PhasarLLVM/Domain/LLVMAnalysisDomain.h"
+#include "phasar/Pointer/PointerAssignmentGraph.h"
+
+namespace llvm {
+class Instruction;
+class Value;
+class Function;
+} // namespace llvm
+
+namespace psr {
+
+namespace library_summary {
+class LLVMFunctionDataFlowFacts;
+} // namespace library_summary
+
+/// The PAG-node used for LLVM-based pointer-assignment graphs. It consists of
+/// regular LLVM values + special return-slots per non-void function. In that
+/// case, the stored pointer is the corresponding function.
+///
+/// This class is compatible with llvm::TinyPtrVector and other APIs relying on
+/// llvm::PointerLikeTypeTraits.
+struct PAGVariable : public llvm::PointerIntPair<const llvm::Value *, 1, bool> {
+  using Base = llvm::PointerIntPair<const llvm::Value *, 1, bool>;
+
+  struct Return {
+    const llvm::Function *Fun;
+  };
+
+  PAGVariable() noexcept = default; // To enable move-assign in TinyPtrVector
+  PAGVariable(const llvm::Value *Var) noexcept : Base(Var, false) {}
+  PAGVariable(Return RetVar) noexcept : Base(RetVar.Fun, true) {
+    assert(RetVar.Fun != nullptr);
+  }
+
+  [[nodiscard]] bool isReturnVariable() const noexcept {
+    return this->getInt();
+  }
+
+  [[nodiscard]] bool isInFunction() const noexcept {
+    return isReturnVariable() ||
+           llvm::isa<llvm::Argument, llvm::Instruction>(this->getPointer());
+  }
+
+  [[nodiscard]] const llvm::Function *getFunction() const noexcept {
+    const auto *Ptr = this->getPointer();
+    if (isReturnVariable()) {
+      return llvm::cast<llvm::Function>(Ptr);
+    }
+    if (const auto *Arg = llvm::dyn_cast<llvm::Argument>(Ptr)) {
+      return Arg->getParent();
+    }
+    if (const auto *Inst = llvm::dyn_cast<llvm::Instruction>(Ptr)) {
+      return Inst->getFunction();
+    }
+
+    return nullptr;
+  }
+
+  [[nodiscard]] const llvm::Value *get() const noexcept {
+    return this->getPointer();
+  }
+  explicit operator const llvm::Value *() const noexcept { return get(); }
+
+  [[nodiscard]] const llvm::Value *valueOrNull() const noexcept {
+    return isReturnVariable() ? nullptr : get();
+  }
+
+  friend bool operator==(PAGVariable V1, PAGVariable V2) noexcept {
+    return V1.getOpaqueValue() == V2.getOpaqueValue();
+  }
+  friend bool operator!=(PAGVariable V1, PAGVariable V2) noexcept {
+    return !(V1 == V2);
+  }
+
+  friend auto hash_value(PAGVariable V) noexcept {
+    return llvm::hash_value(V.getOpaqueValue());
+  }
+};
+
+[[nodiscard]] std::string to_string(PAGVariable Var);
+
+/// Analysis domain for LLVM-IR pointer-assignment graphs.
+/// Uses \c PAGVariable as the variable type and the standard LLVM instruction /
+/// function / project-IRDB types from \c LLVMAnalysisDomainDefault.
+struct LLVMPAGDomain : LLVMAnalysisDomainDefault {
+  using v_t = PAGVariable;
+};
+
+/// Concrete \c PAGBuilder for LLVM IR.
+///
+/// Traverses all functions in the given \c LLVMProjectIRDB and emits PAG
+/// nodes and edges to the provided \c PBStrategyRef.
+///
+/// Achieves basic field sensitivity by handlking constant GEPs in an ad-hoc
+/// manner.
+///
+/// An optional \c LLVMFunctionDataFlowFacts object can be supplied to apply
+/// pre-computed library summaries at potentially declaration-only calls.
+class LLVMPAGBuilder : public PAGBuilder<LLVMPAGDomain> {
+public:
+  constexpr LLVMPAGBuilder() noexcept = default;
+  /// \param MLSum Pre-computed library summary facts. If non-null, callee
+  ///   analysis for matched library functions is replaced by these summaries.
+  constexpr LLVMPAGBuilder(
+      const library_summary::LLVMFunctionDataFlowFacts *MLSum) noexcept
+      : MLSum(MLSum) {}
+
+  void buildPAG(const LLVMProjectIRDB &IRDB, ValueCompressor<v_t> &VC,
+                pag::PBStrategyRef<LLVMPAGDomain> Strategy) override;
+
+private:
+  struct PAGBuildData;
+
+  const library_summary::LLVMFunctionDataFlowFacts *MLSum{};
+};
+
+} // namespace psr
+
+namespace llvm {
+template <> struct PointerLikeTypeTraits<psr::PAGVariable> {
+  static void *getAsVoidPointer(psr::PAGVariable P) {
+    return P.getOpaqueValue();
+  }
+
+  static psr::PAGVariable getFromVoidPointer(void *P) {
+    psr::PAGVariable V{nullptr};
+    static_cast<psr::PAGVariable::Base &>(V) =
+        psr::PAGVariable::Base::getFromOpaqueValue(P);
+    return V;
+  }
+
+  static psr::PAGVariable getFromVoidPointer(const void *P) {
+    psr::PAGVariable V{nullptr};
+    static_cast<psr::PAGVariable::Base &>(V) =
+        psr::PAGVariable::Base::getFromOpaqueValue(P);
+    return V;
+  }
+
+  static constexpr int NumLowBitsAvailable =
+      PointerLikeTypeTraits<psr::PAGVariable::Base>::NumLowBitsAvailable;
+};
+
+template <> struct DenseMapInfo<psr::PAGVariable> {
+  static psr::PAGVariable getEmptyKey() noexcept {
+    return DenseMapInfo<const llvm::Value *>::getEmptyKey();
+  }
+  static psr::PAGVariable getTombstoneKey() noexcept {
+    return DenseMapInfo<const llvm::Value *>::getTombstoneKey();
+  }
+  static hash_code getHashValue(psr::PAGVariable V) noexcept {
+    return hash_value(V);
+  }
+
+  static bool isEqual(psr::PAGVariable V1, psr::PAGVariable V2) noexcept {
+    return V1 == V2;
+  }
+};
+} // namespace llvm
diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
new file mode 100644
index 0000000000..30972bc9c7
--- /dev/null
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
@@ -0,0 +1,465 @@
+#pragma once
+
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCallGraph.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h"
+#include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
+#include "phasar/Pointer/AliasResult.h"
+#include "phasar/Pointer/BottomupUnionFindAA.h"
+#include "phasar/Pointer/RawAliasSet.h"
+#include "phasar/Pointer/UnionFindAA.h"
+#include "phasar/Utils/Macros.h"
+#include "phasar/Utils/MapUtils.h"
+#include "phasar/Utils/MaybeUniquePtr.h"
+#include "phasar/Utils/NonNullPtr.h"
+#include "phasar/Utils/Utilities.h"
+#include "phasar/Utils/ValueCompressor.h"
+
+#include "llvm/IR/Instructions.h"
+#include "llvm/Support/Casting.h"
+
+#include <memory>
+#include <type_traits>
+
+namespace psr {
+extern template class CallingContextSensUnionFindAA<LLVMPAGDomain>;
+extern template class IndirectionSensUnionFindAA<LLVMPAGDomain>;
+extern template class BottomupUnionFindAA<LLVMPAGDomain>;
+
+/// Returns a \c ValueId handler suitable for \c RawAliasSet::foreach() that
+/// maps each alias \c ValueId back to all of its underlying \c llvm::Value*
+/// (via \p VC), forwarding non-null values to \p Callback.
+constexpr std::invocable<ValueId> auto
+llvmUnionFindAliasHandler(const ValueCompressor<PAGVariable> &VC,
+                          std::invocable<const llvm::Value *> auto Callback) {
+  return [&VC, Callback{copyOrRef(Callback)}](ValueId Alias) {
+    for (auto V : VC.id2vars(Alias)) {
+      if (const auto *LLVMVar = V.valueOrNull()) [[likely]] {
+        std::invoke(Callback, LLVMVar);
+      }
+    }
+  };
+}
+
+namespace pag {
+/// Utility class to make pag::PBMixin<IndirectionSensUnionFindAA,
+/// LLVMCGProvider> implement PBStrategy.
+class LLVMCGProvider : public LLVMPAGDomain {
+public:
+  constexpr LLVMCGProvider(NonNullPtr<const LLVMBasedCallGraph> CG) noexcept
+      : CG(CG) {}
+
+  void withCalleesOfCallAt(n_t Inst,
+                           std::invocable<f_t> auto WithCallee) const {
+    for (const auto *Callee : CG->getCalleesOfCallAt(Inst)) {
+      std::invoke(WithCallee, Callee);
+    }
+  }
+
+private:
+  NonNullPtr<const LLVMBasedCallGraph> CG;
+};
+} // namespace pag
+
+/// CRTP mixin that adds the LLVM alias-iterator interface to a class that
+/// holds a \c UnionFindAAResult and a \c ValueCompressor<PAGVariable>.
+///
+/// Provides \c forallAliasesOf(), \c mayAlias(), and \c alias() overloads
+/// accepting both \c llvm::Value* and \c ValueId arguments.  Results are
+/// reported as \c llvm::Value* via the stored \c ValueCompressor.
+///
+/// The derived class must expose a \c VC member (pointer to a
+/// \c ValueCompressor<PAGVariable>).
+///
+/// \tparam Derived The CRTP derived class.
+/// \tparam AAResT  A type satisfying \c UnionFindAAResult.
+template <typename Derived, typename AAResT>
+  requires UnionFindAAResult<std::remove_cvref_t<AAResT>>
+// NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
+struct LLVMUnionFindAliasIteratorMixin {
+  [[no_unique_address]] AAResT AARes;
+
+  using v_t = const llvm::Value *;
+  using n_t = const llvm::Instruction *;
+
+  [[nodiscard]] decltype(auto) getRawAliasSet(ValueId ValId) const {
+    return AARes.getRawAliasSet(ValId);
+  }
+
+  [[nodiscard]] const auto &base() const noexcept { return AARes; }
+
+  void
+  forallAliasesOf(ValueId VId, const auto & /*Inst*/,
+                  std::invocable<const llvm::Value *> auto Callback) const {
+    const auto &RawAliases = AARes.getRawAliasSet(VId);
+    RawAliases.foreach (
+        llvmUnionFindAliasHandler(*self().VC, copyOrRef(Callback)));
+  }
+
+  void
+  forallAliasesOf(const llvm::Value *Ptr, const auto &Inst,
+                  std::invocable<const llvm::Value *> auto Callback) const {
+    if (auto ValId = self().VC->getOrNull(Ptr)) {
+      forallAliasesOf(*ValId, Inst, copyOrRef(Callback));
+    }
+  }
+
+  [[nodiscard]] bool mayAlias(ValueId Ptr1, ValueId Ptr2) const {
+    return AARes.mayAlias(Ptr1, Ptr2);
+  }
+
+  [[nodiscard]] bool mayAlias(ValueId Ptr1, ValueId Ptr2,
+                              const auto & /*AtInstruction*/) const {
+    return AARes.mayAlias(Ptr1, Ptr2);
+  }
+
+  [[nodiscard]] bool mayAlias(const llvm::Value *Ptr1,
+                              const llvm::Value *Ptr2) const {
+    auto ValId1 = self().VC->getOrNull(Ptr1);
+    auto ValId2 = self().VC->getOrNull(Ptr2);
+
+    return ValId1 && ValId2 && mayAlias(*ValId1, *ValId2);
+  }
+
+  [[nodiscard]] bool mayAlias(const llvm::Value *Ptr1, const llvm::Value *Ptr2,
+                              const auto & /*AtInstruction*/) const {
+    return mayAlias(Ptr1, Ptr2);
+  }
+
+  [[nodiscard]] AliasResult alias(const llvm::Value *Ptr1,
+                                  const llvm::Value *Ptr2,
+                                  const auto &AtInstruction) const {
+    auto ValId1 = self().VC->getOrNull(Ptr1);
+    auto ValId2 = self().VC->getOrNull(Ptr2);
+    if (!ValId1 || !ValId2) {
+      return AliasResult::NoAlias;
+    }
+    if (*ValId1 == *ValId2) {
+      // XXX: Check exactly the conditions for must alias!
+      return !llvm::isa<llvm::LoadInst>(Ptr1) &&
+                     !llvm::isa<llvm::LoadInst>(Ptr2)
+                 ? AliasResult::MustAlias
+                 : AliasResult::MayAlias;
+    }
+    return mayAlias(*ValId1, *ValId2, AtInstruction) ? AliasResult::MayAlias
+                                                     : AliasResult::NoAlias;
+  }
+
+  [[nodiscard]] constexpr const Derived &self() const noexcept {
+    return *static_cast<const Derived *>(this);
+  }
+};
+
+template <typename AAResT>
+  requires UnionFindAAResult<std::remove_cvref_t<AAResT>>
+// NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
+struct LLVMUnionFindAliasIterator
+    : public LLVMUnionFindAliasIteratorMixin<LLVMUnionFindAliasIterator<AAResT>,
+                                             AAResT> {
+  MaybeUniquePtr<const ValueCompressor<PAGVariable>> VC;
+
+  constexpr LLVMUnionFindAliasIterator(
+      AAResT &&AARes, MaybeUniquePtr<const ValueCompressor<PAGVariable>> VC)
+      : psr::LLVMUnionFindAliasIteratorMixin<LLVMUnionFindAliasIterator<AAResT>,
+                                             AAResT>{PSR_FWD(AARes)},
+        VC(std::move(VC)) {}
+};
+
+template <typename AAResT>
+LLVMUnionFindAliasIterator(AAResT,
+                           MaybeUniquePtr<const ValueCompressor<PAGVariable>>)
+    -> LLVMUnionFindAliasIterator<AAResT>;
+template <typename AAResT>
+LLVMUnionFindAliasIterator(AAResT, const ValueCompressor<PAGVariable> *)
+    -> LLVMUnionFindAliasIterator<AAResT>;
+
+namespace detail {
+class LLVMLocalUnionFindAliasIteratorBase {
+public:
+  explicit LLVMLocalUnionFindAliasIteratorBase(
+      const ValueCompressor<PAGVariable> &VC);
+
+protected:
+  llvm::DenseMap<const llvm::Function *, RawAliasSet<ValueId>> GlobalsOrInFun;
+};
+} // namespace detail
+
+/// CRTP mixin adding a function-local view on top of a global
+/// \c UnionFindAAResult.
+///
+/// Extends \c LLVMUnionFindAliasIteratorMixin with \c forallAliasesOf()
+/// overloads that accept an \c llvm::Function* or \c llvm::Instruction*
+/// context.  When a non-null context is provided, alias sets are intersected
+/// with the set of variables that are visible in that function (globals plus
+/// locals defined in that function), giving a function-local result even
+/// though the underlying analysis is interprocedural.
+template <typename Derived, typename AAResT>
+class LLVMLocalUnionFindAliasIteratorMixin
+    : public detail::LLVMLocalUnionFindAliasIteratorBase {
+public:
+  LLVMLocalUnionFindAliasIteratorMixin(AAResT &&AARes,
+                                       const ValueCompressor<PAGVariable> &VC)
+      : detail::LLVMLocalUnionFindAliasIteratorBase(VC), AARes(PSR_FWD(AARes)) {
+  }
+
+  [[nodiscard]] decltype(auto) getRawAliasSet(ValueId ValId) const {
+    return AARes.getRawAliasSet(ValId);
+  }
+
+  [[nodiscard]] auto getRawAliasSet(ValueId ValId,
+                                    const llvm::Function *Context) const {
+    auto Vars = AARes.getRawAliasSet(ValId);
+    if (Context) {
+      Vars &= getOrDefault(GlobalsOrInFun, Context);
+    }
+    return Vars;
+  }
+
+  [[nodiscard]] const auto &base() const noexcept { return AARes; }
+
+  [[nodiscard]] auto getRawAliasSet(ValueId ValId,
+                                    const llvm::Instruction *Context) const {
+    return getRawAliasSet(ValId, getFunction(Context));
+  }
+
+  void forallAliasesOf(ValueId VId, const llvm::Function *Context,
+                       std::invocable<const llvm::Value *> auto WithAlias) {
+    const auto AliasHandler =
+        llvmUnionFindAliasHandler(*self().VC, copyOrRef(WithAlias));
+
+    auto &&RawVars = AARes.getRawAliasSet(VId);
+    if (Context) {
+      auto Vars = PSR_FWD(RawVars);
+      Vars &= getOrDefault(GlobalsOrInFun, Context);
+      Vars.foreach (AliasHandler);
+    } else {
+      RawVars.foreach (AliasHandler);
+    }
+  }
+
+  void forallAliasesOf(const llvm::Value *Val, const llvm::Function *Context,
+                       std::invocable<const llvm::Value *> auto WithAlias) {
+    if (auto ValId = self().VC->getOrNull(Val)) {
+      forallAliasesOf(*ValId, Context, copyOrRef(WithAlias));
+    }
+  }
+
+  void forallAliasesOf(ValueId ValId, const llvm::Instruction *AtInstruction,
+                       std::invocable<const llvm::Value *> auto WithAlias) {
+    forallAliasesOf(ValId, psr::getFunction(AtInstruction),
+                    copyOrRef(WithAlias));
+  }
+
+  void forallAliasesOf(const llvm::Value *Val,
+                       const llvm::Instruction *AtInstruction,
+                       std::invocable<const llvm::Value *> auto WithAlias) {
+    forallAliasesOf(Val, psr::getFunction(AtInstruction), copyOrRef(WithAlias));
+  }
+
+  void forallAliasesOf(const llvm::Value *Val,
+                       std::invocable<const llvm::Value *> auto WithAlias) {
+    forallAliasesOf(Val, psr::getFunction(Val), copyOrRef(WithAlias));
+  }
+
+  [[nodiscard]] bool
+  mayAlias(ValueId ValId1, ValueId ValId2,
+           const llvm::Instruction * /*AtInstruction*/ = nullptr) const {
+    // XXX: Should we filter by AtInstruction-context here as well?
+    return AARes.mayAlias(ValId1, ValId2);
+  }
+
+  [[nodiscard]] bool
+  mayAlias(const llvm::Value *Ptr1, const llvm::Value *Ptr2,
+           const llvm::Instruction * /*AtInstruction*/ = nullptr) const {
+    auto ValId1 = self().VC->getOrNull(Ptr1);
+    auto ValId2 = self().VC->getOrNull(Ptr2);
+
+    // XXX: Should we filter by AtInstruction-context here as well?
+    return ValId1 && ValId2 && AARes.mayAlias(*ValId1, *ValId2);
+  }
+
+  [[nodiscard]] AliasResult alias(const llvm::Value *Ptr1,
+                                  const llvm::Value *Ptr2,
+                                  const auto &AtInstruction) const {
+    auto ValId1 = self().VC->getOrNull(Ptr1);
+    auto ValId2 = self().VC->getOrNull(Ptr2);
+    if (!ValId1 || !ValId2) {
+      return AliasResult::NoAlias;
+    }
+    if (*ValId1 == *ValId2) {
+      // XXX: Check exactly the conditions for must alias!
+      return !llvm::isa<llvm::LoadInst>(Ptr1) &&
+                     !llvm::isa<llvm::LoadInst>(Ptr2)
+                 ? AliasResult::MustAlias
+                 : AliasResult::MayAlias;
+    }
+    return mayAlias(*ValId1, *ValId2, AtInstruction) ? AliasResult::MayAlias
+                                                     : AliasResult::NoAlias;
+  }
+
+  [[nodiscard]] constexpr const Derived &self() const noexcept {
+    return *static_cast<const Derived *>(this);
+  }
+
+private:
+  AAResT AARes;
+};
+
+template <typename AAResT>
+class LLVMLocalUnionFindAliasIterator
+    : public LLVMLocalUnionFindAliasIteratorMixin<
+          LLVMLocalUnionFindAliasIterator<AAResT>, AAResT> {
+  friend LLVMLocalUnionFindAliasIteratorMixin<
+      LLVMLocalUnionFindAliasIterator<AAResT>, AAResT>;
+
+public:
+  LLVMLocalUnionFindAliasIterator(
+      AAResT &&AARes, NonNullPtr<const ValueCompressor<PAGVariable>> VC)
+      : LLVMLocalUnionFindAliasIteratorMixin<
+            LLVMLocalUnionFindAliasIterator<AAResT>, AAResT>(PSR_FWD(AARes),
+                                                             *VC),
+        VC(VC) {}
+
+private:
+  NonNullPtr<const ValueCompressor<PAGVariable>> VC;
+};
+
+/// Low-level entry point: builds the PAG for \p IRDB using the given
+/// \p AnalysisT strategy, and returns the raw alias-analysis result (not
+/// wrapped in an \c LLVMUnionFindAliasIterator).
+///
+/// \param IRDB   The project to analyze.
+/// \param Ana    A \c PBStrategy instance (e.g., \c BasicUnionFindAA,
+///               \c BottomupUnionFindAA).  Taken by forwarding reference and
+///               consumed when results are extracted.
+/// \param VC     Optional pre-populated \c ValueCompressor.  A new one is
+///               allocated if null.
+/// \param Impl   PAG builder implementation (default: \c LLVMPAGBuilder).
+template <pag::PBStrategy AnalysisT,
+          std::derived_from<PAGBuilder<LLVMPAGDomain>> PAGBuilderImpl =
+              LLVMPAGBuilder>
+[[nodiscard]] inline UnionFindAAResult auto
+computeUnionFindAARaw(const LLVMProjectIRDB &IRDB, AnalysisT &&Ana,
+                      MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr,
+                      PAGBuilderImpl Impl = {}) {
+  if (!VC) {
+    VC = std::make_unique<ValueCompressor<PAGVariable>>();
+  }
+
+  Impl.buildPAG(IRDB, *VC, &Ana);
+
+  const auto NumVars = VC->size();
+  return PSR_FWD(Ana).consumeAAResults(NumVars);
+}
+
+template <pag::CanOnAddEdge AnalysisT,
+          std::derived_from<PAGBuilder<LLVMPAGDomain>> PAGBuilderImpl =
+              LLVMPAGBuilder>
+[[nodiscard]] inline UnionFindAAResult auto
+computeUnionFindAARaw(const LLVMProjectIRDB &IRDB, AnalysisT &&Ana,
+                      const LLVMBasedCallGraph &CG,
+                      MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr,
+                      PAGBuilderImpl Impl = {}) {
+  auto Strategy = pag::PBMixin{
+      PSR_FWD(Ana),
+      pag::LLVMCGProvider{&CG},
+  };
+  return computeUnionFindAARaw(IRDB, Strategy, std::move(VC), std::move(Impl));
+}
+
+[[nodiscard]] CallingContextSensUnionFindAAResult computeCtxSensUnionFindAARaw(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr);
+[[nodiscard]] BasicUnionFindAAResult computeBotCtxSensUnionFindAARaw(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr);
+[[nodiscard]] BasicUnionFindAAResult computeIndSensUnionFindAARaw(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr);
+[[nodiscard]] UnionFindAAResultIntersection<CallingContextSensUnionFindAAResult,
+                                            BasicUnionFindAAResult>
+computeCtxIndSensUnionFindAARaw(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr);
+[[nodiscard]] UnionFindAAResultIntersection<BasicUnionFindAAResult,
+                                            BasicUnionFindAAResult>
+computeBotCtxIndSensUnionFindAARaw(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr);
+
+/// Builds the PAG and returns a \c LLVMUnionFindAliasIterator (owns the \c
+/// ValueCompressor and the raw result) that implements the \c
+/// IsLLVMAliasIterator concept.
+///
+/// \param IRDB   The project to analyze.
+/// \param Ana    A \c PBStrategy instance. Consumed when results are extracted.
+/// \param VC     Optional pre-populated \c ValueCompressor. A new one is
+///               allocated if null; the iterator takes ownership.
+/// \param Impl   PAG builder implementation (default: \c LLVMPAGBuilder).
+template <pag::PBStrategy AnalysisT,
+          std::derived_from<PAGBuilder<LLVMPAGDomain>> PAGBuilderImpl =
+              LLVMPAGBuilder>
+[[nodiscard]] inline IsLLVMAliasIterator auto
+computeUnionFindAA(const LLVMProjectIRDB &IRDB, AnalysisT &&Ana,
+                   MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr,
+                   PAGBuilderImpl Impl = {}) {
+  if (!VC) {
+    VC = std::make_unique<ValueCompressor<PAGVariable>>();
+  }
+
+  auto AARes =
+      computeUnionFindAARaw(IRDB, PSR_FWD(Ana), VC.get(), std::move(Impl));
+  return LLVMUnionFindAliasIterator{
+      std::move(AARes),
+      std::move(VC),
+  };
+}
+
+template <pag::CanOnAddEdge AnalysisT,
+          std::derived_from<PAGBuilder<LLVMPAGDomain>> PAGBuilderImpl =
+              LLVMPAGBuilder>
+[[nodiscard]] inline IsLLVMAliasIterator auto
+computeUnionFindAA(const LLVMProjectIRDB &IRDB, AnalysisT &&Ana,
+                   const LLVMBasedCallGraph &CG,
+                   MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr,
+                   PAGBuilderImpl Impl = {}) {
+  auto Strategy = pag::PBMixin{
+      PSR_FWD(Ana),
+      pag::LLVMCGProvider{&CG},
+  };
+  return computeUnionFindAA(IRDB, Strategy, std::move(VC), std::move(Impl));
+}
+
+[[nodiscard]] LLVMUnionFindAliasIterator<CallingContextSensUnionFindAAResult>
+computeCtxSensUnionFindAA(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr);
+[[nodiscard]] LLVMUnionFindAliasIterator<BasicUnionFindAAResult>
+computeBotCtxSensUnionFindAA(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr);
+[[nodiscard]] LLVMUnionFindAliasIterator<BasicUnionFindAAResult>
+computeIndSensUnionFindAA(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr);
+[[nodiscard]] LLVMUnionFindAliasIterator<UnionFindAAResultIntersection<
+    CallingContextSensUnionFindAAResult, BasicUnionFindAAResult>>
+computeCtxIndSensUnionFindAA(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr);
+[[nodiscard]] LLVMUnionFindAliasIterator<UnionFindAAResultIntersection<
+    BasicUnionFindAAResult, BasicUnionFindAAResult>>
+computeBotCtxIndSensUnionFindAA(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr);
+
+} // namespace psr
diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h
new file mode 100644
index 0000000000..06675f30da
--- /dev/null
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h
@@ -0,0 +1,216 @@
+#pragma once
+
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCallGraph.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMAliasSet.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMPointsToUtils.h"
+#include "phasar/Pointer/AliasAnalysisType.h"
+#include "phasar/Pointer/AliasInfoTraits.h"
+#include "phasar/Pointer/AliasResult.h"
+#include "phasar/Pointer/AliasSetOwner.h"
+#include "phasar/Pointer/RawAliasSet.h"
+#include "phasar/Pointer/UnionFindAliasAnalysisType.h"
+#include "phasar/Utils/AnalysisProperties.h"
+#include "phasar/Utils/TypedVector.h"
+#include "phasar/Utils/ValueCompressor.h"
+
+#include <memory>
+#include <type_traits>
+
+namespace llvm {
+class Value;
+class Instruction;
+class Function;
+} // namespace llvm
+
+namespace psr {
+
+class LLVMUnionFindAliasSet;
+class LLVMProjectIRDB;
+
+template <>
+struct AliasInfoTraits<LLVMUnionFindAliasSet>
+    : DefaultAATraits<const llvm::Value *, const llvm::Instruction *> {};
+
+/// Concrete \c IsAliasInfo implementation backed by a union-find alias
+/// analysis.
+///
+/// Constructed once from an \c LLVMProjectIRDB and a call graph; the chosen
+/// analysis variant is determined by \c Config.  Alias sets are materialized
+/// lazily on first query and cached per \c ValueId in \c AliasSets.
+///
+/// \note When \c AnalysisLocality::FunctionLocal is selected, alias sets are
+///   filtered to variables visible in the function that contains the query
+///   instruction.  The per-\c ValueId cache does **not** account for the
+///   instruction context, so the first caller's function wins — do not mix
+///   queries to local pointers from different functions for the same value in
+///   local mode.
+class LLVMUnionFindAliasSet
+    : public AnalysisPropertiesMixin<LLVMUnionFindAliasSet> {
+public:
+  using traits_t = AliasInfoTraits<LLVMUnionFindAliasSet>;
+  using n_t = traits_t::n_t;
+  using v_t = traits_t::v_t;
+  using AliasSetTy = traits_t::AliasSetTy;
+  using AliasSetPtrTy = traits_t::AliasSetPtrTy;
+  using AllocationSiteSetPtrTy = traits_t::AllocationSiteSetPtrTy;
+
+  /// Whether alias sets are reported globally or filtered to the function
+  /// containing the query instruction.
+  enum class AnalysisLocality : uint8_t {
+    /// All aliases across all functions are reported.
+    Global,
+    /// Aliases are intersected with variables visible in the querying function
+    /// (globals + function-local values).
+    FunctionLocal,
+  };
+
+  struct Config {
+    /// The specific union-find analysis variant to run (default:
+    /// \c BotCtxIndSens — bottom-up, context- and indirection-sensitive).
+    UnionFindAliasAnalysisType AType =
+        UnionFindAliasAnalysisType::BotCtxIndSens;
+    /// Controls whether alias sets are scoped to the querying function.
+    AnalysisLocality ALocality = AnalysisLocality::Global;
+  };
+
+  explicit LLVMUnionFindAliasSet(const LLVMProjectIRDB *IRDB,
+                                 const LLVMBasedCallGraph &BaseCG, Config Cfg,
+                                 ValueCompressor<PAGVariable> *VC);
+  explicit LLVMUnionFindAliasSet(const LLVMProjectIRDB *IRDB,
+                                 const LLVMBasedCallGraph &BaseCG, Config Cfg)
+      : LLVMUnionFindAliasSet(IRDB, BaseCG, Cfg, nullptr) {}
+  explicit LLVMUnionFindAliasSet(const LLVMProjectIRDB *IRDB,
+                                 const LLVMBasedCallGraph &BaseCG)
+      : LLVMUnionFindAliasSet(IRDB, BaseCG, Config{}, nullptr) {}
+
+  [[nodiscard]] constexpr std::true_type isInterProcedural() const noexcept {
+    return {};
+  };
+
+  [[nodiscard]] constexpr std::integral_constant<AliasAnalysisType,
+                                                 AliasAnalysisType::UnionFind>
+  getAliasAnalysisType() const noexcept {
+    return {};
+  };
+
+  [[nodiscard]] constexpr AnalysisProperties
+  getAnalysisProperties() const noexcept {
+    return Props;
+  }
+
+  [[nodiscard]] constexpr AliasResult alias(v_t V1, v_t V2, n_t I) const {
+    assert(isValid());
+    return AARes->alias(V1, V2, I);
+  }
+
+  void foreachAliasOf(v_t V, n_t I,
+                      llvm::function_ref<void(v_t)> WithAlias) const {
+    assert(isValid());
+    AARes->forallAliasesOf(V, I, WithAlias);
+  }
+
+  [[nodiscard]] AliasSetPtrTy getAliasSet(v_t V, n_t I) {
+    assert(isValid());
+    auto ValId = AARes->VC->getOrNull(V);
+    if (!ValId) {
+      return getEmptyAliasSet();
+    }
+
+    assert(AliasSets.inbounds(*ValId));
+    if (!AliasSets[*ValId]) [[unlikely]] {
+      AliasSets[*ValId] = AARes->constructAliasSet(*ValId, I, Owner);
+    }
+
+    return AliasSets[*ValId];
+  }
+
+  [[nodiscard]] AllocationSiteSetPtrTy
+  getReachableAllocationSites(v_t V, bool IntraProcOnly, n_t I) const {
+    assert(isValid());
+    auto ValId = AARes->VC->getOrNull(V);
+    if (!ValId) {
+      return std::make_unique<AliasSetTy>();
+    }
+
+    return AARes->constructReachableAllocSites(V, *ValId, IntraProcOnly, I);
+  }
+
+  [[nodiscard]] bool isInReachableAllocationSites(
+      const llvm::Value *V, const llvm::Value *PotentialValue,
+      bool IntraProcOnly, const llvm::Instruction *I) const {
+    assert(isValid());
+    if (!psr::isInterestingPointer(V)) {
+      return false;
+    }
+
+    if (!psr::isInReachableAllocationSitesTy(V, PotentialValue,
+                                             IntraProcOnly)) {
+      return false;
+    }
+
+    return alias(V, PotentialValue, I) != AliasResult::NoAlias;
+  }
+
+  void print(llvm::raw_ostream &OS) const;
+  void printAsJson(llvm::raw_ostream &OS) const;
+
+  [[nodiscard]] bool isValid() const noexcept {
+    return AARes != nullptr && Props != AnalysisProperties::None &&
+           AARes->VC != nullptr && AARes->VC->size() == AliasSets.size();
+  }
+
+private:
+  struct UnionFindAAResultConcept {
+    MaybeUniquePtr<const ValueCompressor<PAGVariable>> VC;
+    std::optional<RawAliasSet<ValueId>> AllocationSites{};
+
+    UnionFindAAResultConcept(
+        MaybeUniquePtr<const ValueCompressor<PAGVariable>> VC) noexcept
+        : VC(std::move(VC)) {}
+    virtual ~UnionFindAAResultConcept() = default;
+
+    virtual void forallAliasesOf(v_t Ptr, n_t Inst,
+                                 llvm::function_ref<void(v_t)> Callback) = 0;
+
+    virtual AliasResult alias(v_t Ptr1, v_t Ptr2, n_t AtInstruction) = 0;
+
+    virtual AliasSetPtrTy
+    constructAliasSet(ValueId ValId, n_t Inst,
+                      AliasSetOwner<AliasSetTy> &Owner) = 0;
+
+    virtual AllocationSiteSetPtrTy
+    constructReachableAllocSites(v_t V, ValueId ValId, bool IntraProcOnly,
+                                 n_t Inst) = 0;
+
+    virtual void print(llvm::raw_ostream &OS, Config Cfg) const = 0;
+  };
+
+  template <template <typename, typename> typename AAResIterT, typename AAResT>
+  struct UnionFindAAResultModel;
+
+  [[nodiscard]] static BoxedPtr<AliasSetTy> getEmptyAliasSet();
+
+  // --- data members:
+
+  std::unique_ptr<UnionFindAAResultConcept> AARes{};
+  AnalysisProperties Props{};
+  Config Cfg{};
+
+  AliasSetOwner<AliasSetTy>::memory_resource_type MRes{};
+  AliasSetOwner<AliasSetTy> Owner{&MRes};
+  TypedVector<ValueId, AliasSetPtrTy> AliasSets;
+};
+
+[[nodiscard]] llvm::StringRef
+to_string(LLVMUnionFindAliasSet::AnalysisLocality ALoc) noexcept;
+} // namespace psr
diff --git a/include/phasar/PhasarLLVM/SimpleAnalysisConstructor.h b/include/phasar/PhasarLLVM/SimpleAnalysisConstructor.h
index ebc62aa065..d49c1f5b71 100644
--- a/include/phasar/PhasarLLVM/SimpleAnalysisConstructor.h
+++ b/include/phasar/PhasarLLVM/SimpleAnalysisConstructor.h
@@ -17,7 +17,6 @@
 
 namespace psr {
 class LLVMProjectIRDB;
-class LLVMAliasSet;
 class LLVMBasedICFG;
 class DIBasedTypeHierarchy;
 
@@ -36,31 +35,32 @@ ProblemTy createAnalysisProblem(HelperAnalyses &HA, ArgTys &&...Args) {
                      std::forward<ArgTys>(Args)...);
   } else if constexpr (std::is_constructible_v<ProblemTy,
                                                const LLVMProjectIRDB *,
-                                               LLVMAliasSet *, ArgTys...>) {
-    return ProblemTy(&HA.getProjectIRDB(), &HA.getAliasInfo(),
+                                               LLVMAliasInfoRef, ArgTys...>) {
+    return ProblemTy(&HA.getProjectIRDB(), HA.getAliasInfo(),
                      std::forward<ArgTys>(Args)...);
-  } else if constexpr (std::is_constructible_v<
-                           ProblemTy, const LLVMProjectIRDB *,
-                           const LLVMBasedICFG *, LLVMAliasSet *, ArgTys...>) {
-    return ProblemTy(&HA.getProjectIRDB(), &HA.getICFG(), &HA.getAliasInfo(),
+  } else if constexpr (std::is_constructible_v<ProblemTy,
+                                               const LLVMProjectIRDB *,
+                                               const LLVMBasedICFG *,
+                                               LLVMAliasInfoRef, ArgTys...>) {
+    return ProblemTy(&HA.getProjectIRDB(), &HA.getICFG(), HA.getAliasInfo(),
                      std::forward<ArgTys>(Args)...);
   } else if constexpr (std::is_constructible_v<
                            ProblemTy, const LLVMProjectIRDB *,
                            const DIBasedTypeHierarchy *, const LLVMBasedCFG *,
-                           LLVMAliasSet *, ArgTys...>) {
+                           LLVMAliasInfoRef, ArgTys...>) {
     return ProblemTy(&HA.getProjectIRDB(), &HA.getTypeHierarchy(), &HA.getCFG(),
-                     &HA.getAliasInfo(), std::forward<ArgTys>(Args)...);
+                     HA.getAliasInfo(), std::forward<ArgTys>(Args)...);
   } else if constexpr (std::is_constructible_v<
                            ProblemTy, const LLVMProjectIRDB *,
                            const DIBasedTypeHierarchy *, const LLVMBasedICFG *,
-                           LLVMAliasSet *, ArgTys...>) {
+                           LLVMAliasInfoRef, ArgTys...>) {
     return ProblemTy(&HA.getProjectIRDB(), &HA.getTypeHierarchy(),
-                     &HA.getICFG(), &HA.getAliasInfo(),
+                     &HA.getICFG(), HA.getAliasInfo(),
                      std::forward<ArgTys>(Args)...);
   } else if constexpr (std::is_constructible_v<
                            ProblemTy, const LLVMProjectIRDB *,
-                           const LLVMBasedCFG *, LLVMAliasSet *, ArgTys...>) {
-    return ProblemTy(&HA.getProjectIRDB(), &HA.getCFG(), &HA.getAliasInfo(),
+                           const LLVMBasedCFG *, LLVMAliasInfoRef, ArgTys...>) {
+    return ProblemTy(&HA.getProjectIRDB(), &HA.getCFG(), HA.getAliasInfo(),
                      std::forward<ArgTys>(Args)...);
   } else {
     static_assert(
diff --git a/include/phasar/PhasarLLVM/Utils/LLVMFunctionDataFlowFacts.h b/include/phasar/PhasarLLVM/Utils/LLVMFunctionDataFlowFacts.h
new file mode 100644
index 0000000000..3c3d808f81
--- /dev/null
+++ b/include/phasar/PhasarLLVM/Utils/LLVMFunctionDataFlowFacts.h
@@ -0,0 +1,86 @@
+/******************************************************************************
+ * Copyright (c) 2025 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel, bulletSpace and others
+ *****************************************************************************/
+
+#ifndef PHASAR_PHASARLLVM_DATAFLOW_IFDSIDE_LLVMFUNCTIONDATAFLOWFACTS_H
+#define PHASAR_PHASARLLVM_DATAFLOW_IFDSIDE_LLVMFUNCTIONDATAFLOWFACTS_H
+
+#include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
+#include "phasar/Utils/DefaultValue.h"
+#include "phasar/Utils/FunctionDataFlowFacts.h"
+#include "phasar/Utils/MapUtils.h"
+
+#include "llvm/IR/Argument.h"
+#include "llvm/IR/Function.h"
+
+#include <vector>
+
+namespace psr::library_summary {
+
+class LLVMFunctionDataFlowFacts;
+[[nodiscard]] LLVMFunctionDataFlowFacts
+readFromFDFF(const FunctionDataFlowFacts &Fdff,
+             std::invocable<llvm::StringRef> auto GetFunctionByNameOrNull);
+
+/// @brief A LLVM-specific mapping of FunctionDataFlowFacts
+class LLVMFunctionDataFlowFacts {
+public:
+  LLVMFunctionDataFlowFacts() noexcept = default;
+  using ParameterMappingTy = FunctionDataFlowFacts::ParameterMappingTy;
+
+  [[nodiscard]] bool contains(const llvm::Function *Fn) const {
+    return LLVMFdff.count(Fn);
+  }
+
+  [[nodiscard]] const std::vector<DataFlowFact> &
+  getFacts(const llvm::Function *Fun, uint32_t Index) const {
+    if (const auto *Iter = getOrDefault(LLVMFdff, Fun)) {
+      return getOrDefault(*Iter, Index);
+    }
+    return default_value();
+  }
+  [[nodiscard]] const std::vector<DataFlowFact> &
+  getFacts(const llvm::Function *Fun, const llvm::Argument *Arg) const {
+    return getFacts(Fun, Arg->getArgNo());
+  }
+
+  [[nodiscard]] const ParameterMappingTy &
+  getFactsForFunction(const llvm::Function *Fun) const {
+    if (const auto *Iter = getOrDefault(LLVMFdff, Fun)) {
+      return *Iter;
+    }
+    return default_value();
+  }
+
+  [[nodiscard]] const ParameterMappingTy *
+  getFactsForFunctionOrNull(const llvm::Function *Fun) const {
+    return getOrDefault(LLVMFdff, Fun);
+  }
+
+  [[nodiscard]] friend LLVMFunctionDataFlowFacts
+  readFromFDFF(const FunctionDataFlowFacts &Fdff,
+               std::invocable<llvm::StringRef> auto GetFunctionByNameOrNull) {
+    LLVMFunctionDataFlowFacts Ret{};
+    Ret.LLVMFdff.reserve(Fdff.size());
+
+    for (const auto &Elem : Fdff) {
+      if (const auto *Fun =
+              std::invoke(GetFunctionByNameOrNull, Elem.getKey())) {
+        Ret.LLVMFdff.try_emplace(Fun, &Elem.getValue());
+      }
+    }
+
+    return Ret;
+  }
+
+private:
+  llvm::DenseMap<const llvm::Function *, const ParameterMappingTy *> LLVMFdff;
+};
+} // namespace psr::library_summary
+
+#endif // PHASAR_PHASARLLVM_DATAFLOW_IFDSIDE_LLVMFUNCTIONDATAFLOWFACTS_H
diff --git a/include/phasar/PhasarLLVM/Utils/LLVMShorthands.h b/include/phasar/PhasarLLVM/Utils/LLVMShorthands.h
index 532a4803f4..dcad26415a 100644
--- a/include/phasar/PhasarLLVM/Utils/LLVMShorthands.h
+++ b/include/phasar/PhasarLLVM/Utils/LLVMShorthands.h
@@ -19,6 +19,12 @@
 
 #include "phasar/Utils/Utilities.h"
 
+#include "llvm/IR/Argument.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/Instruction.h"
+#include "llvm/IR/Type.h"
+#include "llvm/Support/Casting.h"
+
 #include <string>
 #include <vector>
 
@@ -256,6 +262,47 @@ bool isGuardVariable(const llvm::Value *V);
  */
 bool isStaticVariableLazyInitializationBranch(const llvm::BranchInst *Inst);
 
+[[nodiscard]] inline bool
+definitelyContainsNoPointerFast(const llvm::Type *Ty) noexcept {
+  return Ty->isIntOrIntVectorTy() || Ty->isFloatingPointTy() ||
+         Ty->isFPOrFPVectorTy() || Ty->isVoidTy();
+}
+
+namespace detail {
+bool definitelyContainsNoPointerImpl(const llvm::Type *Ty) noexcept;
+} // namespace detail
+
+/// Approximates, whether the given LLVM type may not contain a pointer.
+/// This check is designed to be extremely lightweight and is therefore not very
+/// precise.
+///
+/// \returns True, iff it can be proven that Ty does *not* contain a pointer
+[[nodiscard]] inline bool
+definitelyContainsNoPointer(const llvm::Type *Ty) noexcept {
+  if (definitelyContainsNoPointerFast(Ty)) {
+    return true;
+  }
+
+  return detail::definitelyContainsNoPointerImpl(Ty);
+}
+/// Approximates, whether the given LLVM value may not contain a pointer.
+/// This check is designed to be extremely lightweight and is therefore not very
+/// precise.
+///
+/// \returns True, iff it can be proven that Val does *not* contain a pointer
+[[nodiscard]] inline bool definitelyContainsNoPointer(const llvm::Value *Val) {
+  return llvm::isa<llvm::ConstantData>(Val) ||
+         definitelyContainsNoPointer(Val->getType());
+}
+
+/// Approximates, whether the given LLVM value may be address-taken, i.e.,
+/// whether its pointer value is used for other purposes than just
+/// store/load/gep.
+///
+/// This check is designed to be rather lightweight and may therefore not be
+/// precise in all cases.
+[[nodiscard]] bool isAddressTakenVariable(const llvm::Value *Var) noexcept;
+
 /**
  * Tests for <https://llvm.org/docs/LangRef.html#llvm-var-annotation-intrinsic>
  * e.g.
@@ -264,6 +311,26 @@ bool isStaticVariableLazyInitializationBranch(const llvm::BranchInst *Inst);
  */
 bool isVarAnnotationIntrinsic(const llvm::Function *F);
 
+inline const llvm::Function *getFunction(const llvm::Value *V) {
+  if (!V) {
+    return nullptr;
+  }
+  if (const auto *Inst = llvm::dyn_cast<llvm::Instruction>(V)) {
+    return Inst->getFunction();
+  }
+  if (const auto *Arg = llvm::dyn_cast<llvm::Argument>(V)) {
+    return Arg->getParent();
+  }
+  return nullptr;
+}
+inline const llvm::Function *getFunction(const llvm::Instruction *Inst) {
+  if (!Inst) {
+    return nullptr;
+  }
+
+  return Inst->getFunction();
+}
+
 /**
  * Retrieves String annotation value as per
  * <https://llvm.org/docs/LangRef.html#llvm-var-annotation-intrinsic>
diff --git a/include/phasar/Pointer/AliasAnalysisType.def b/include/phasar/Pointer/AliasAnalysisType.def
index c65c28b105..258819b378 100644
--- a/include/phasar/Pointer/AliasAnalysisType.def
+++ b/include/phasar/Pointer/AliasAnalysisType.def
@@ -15,6 +15,7 @@ ALIAS_ANALYSIS_TYPE(Basic, "basic", "Basic LLVM alias resolving based on simple,
 ALIAS_ANALYSIS_TYPE(CFLSteens, "cflsteens", "Steensgaard-style alias analysis (equality-based)")
 ALIAS_ANALYSIS_TYPE(CFLAnders, "cflanders", "Andersen-style alias analysis (subset-based) (default)")
 ALIAS_ANALYSIS_TYPE(PointsTo, "points-to", "Alias-information based on (external) points-to information")
+ALIAS_ANALYSIS_TYPE(UnionFind, "union-find", "Steensgaard-style alias analysis based on union-find structures")
 
 #ifdef PHASAR_USE_SVF
 ALIAS_ANALYSIS_TYPE(SVFDDA, "svf-dda", "Alias-information based on SVF's ContextDDA analysis. Requires SVF.")
diff --git a/include/phasar/Pointer/AliasInfo.h b/include/phasar/Pointer/AliasInfo.h
index bd2daa3314..67fecbc82d 100644
--- a/include/phasar/Pointer/AliasInfo.h
+++ b/include/phasar/Pointer/AliasInfo.h
@@ -232,10 +232,10 @@ class [[gsl::Pointer]] AliasInfoRef
         return static_cast<ConcreteAA *>(AA)->alias(Pointer1, Pointer2,
                                                     AtInstruction);
       },
-      [](const void *AA) noexcept {
+      [](const void *AA) noexcept -> bool {
         return static_cast<const ConcreteAA *>(AA)->isInterProcedural();
       },
-      [](const void *AA) noexcept {
+      [](const void *AA) noexcept -> AliasAnalysisType {
         return static_cast<const ConcreteAA *>(AA)->getAliasAnalysisType();
       },
       [](void *AA, ByConstRef<v_t> Pointer, ByConstRef<n_t> AtInstruction) {
@@ -259,15 +259,28 @@ class [[gsl::Pointer]] AliasInfoRef
         static_cast<const ConcreteAA *>(AA)->printAsJson(OS);
       },
       [](void *AA, void *Other) {
-        static_cast<ConcreteAA *>(AA)->mergeWith(
-            *static_cast<ConcreteAA *>(Other));
+        if constexpr (requires(ConcreteAA &CAA) { CAA.mergeWith(CAA); }) {
+          static_cast<ConcreteAA *>(AA)->mergeWith(
+              *static_cast<ConcreteAA *>(Other));
+        } else {
+          llvm::report_fatal_error(llvm::getTypeName<ConcreteAA>() +
+                                   " does not support mergeWith()");
+        }
       },
       [](void *AA, ByConstRef<v_t> Pointer1, ByConstRef<v_t> Pointer2,
          ByConstRef<n_t> AtInstruction, AliasResult Kind) {
-        static_cast<ConcreteAA *>(AA)->introduceAlias(Pointer1, Pointer2,
-                                                      AtInstruction, Kind);
+        if constexpr (requires(ConcreteAA &CAA) {
+                        CAA.introduceAlias(Pointer1, Pointer2, AtInstruction,
+                                           Kind);
+                      }) {
+          static_cast<ConcreteAA *>(AA)->introduceAlias(Pointer1, Pointer2,
+                                                        AtInstruction, Kind);
+        } else {
+          llvm::report_fatal_error(llvm::getTypeName<ConcreteAA>() +
+                                   " does not support introduceAlias()");
+        }
       },
-      [](const void *AA) noexcept {
+      [](const void *AA) noexcept -> AnalysisProperties {
         return static_cast<const ConcreteAA *>(AA)->getAnalysisProperties();
       },
       []() noexcept { return llvm::getTypeName<ConcreteAA>(); },
diff --git a/include/phasar/Pointer/AliasInfoBase.h b/include/phasar/Pointer/AliasInfoBase.h
index 0892b92171..1cc740e077 100644
--- a/include/phasar/Pointer/AliasInfoBase.h
+++ b/include/phasar/Pointer/AliasInfoBase.h
@@ -40,11 +40,13 @@ concept IsAliasInfo =
              typename AliasInfoTraits<T>::n_t Inst) {
       CVal.print(llvm::outs());
       CVal.printAsJson(llvm::outs());
-      MutVal.mergeWith(MutVal);
-      MutVal.introduceAlias(Ptr, Ptr, Inst, AliasResult{});
+      // MutVal.mergeWith(MutVal);
+      // MutVal.introduceAlias(Ptr, Ptr, Inst, AliasResult{});
 
-      { CVal.isInterProcedural() } -> std::convertible_to<bool>;
-      { CVal.getAliasAnalysisType() } -> std::same_as<AliasAnalysisType>;
+      { CVal.isInterProcedural() } noexcept -> std::convertible_to<bool>;
+      {
+        CVal.getAliasAnalysisType()
+      } noexcept -> std::convertible_to<AliasAnalysisType>;
       { MutVal.alias(Ptr, Ptr, Inst) } -> std::same_as<AliasResult>;
       {
         MutVal.getAliasSet(Ptr, Inst)
@@ -55,10 +57,12 @@ concept IsAliasInfo =
       {
         MutVal.isInReachableAllocationSites(Ptr, Ptr, bool{}, Inst)
       } -> std::convertible_to<bool>;
-      { CVal.getAnalysisProperties() } -> std::same_as<AnalysisProperties>;
-      { CVal.isContextSensitive() } -> std::convertible_to<bool>;
-      { CVal.isFieldSensitive() } -> std::convertible_to<bool>;
-      { CVal.isFlowSensitive() } -> std::convertible_to<bool>;
+      {
+        CVal.getAnalysisProperties()
+      } noexcept -> std::convertible_to<AnalysisProperties>;
+      { CVal.isContextSensitive() } noexcept -> std::convertible_to<bool>;
+      { CVal.isFieldSensitive() } noexcept -> std::convertible_to<bool>;
+      { CVal.isFlowSensitive() } noexcept -> std::convertible_to<bool>;
     };
 
 } // namespace psr
diff --git a/include/phasar/Pointer/AliasIterator.h b/include/phasar/Pointer/AliasIterator.h
index 1e139c88f0..f3944e81f9 100644
--- a/include/phasar/Pointer/AliasIterator.h
+++ b/include/phasar/Pointer/AliasIterator.h
@@ -34,7 +34,7 @@ concept IsAliasIteratorFor =
 
 template <typename T>
 concept HasAlias = requires(T &AS, typename T::v_t Ptr, typename T::n_t Inst) {
-  { AS.alias(Ptr, Ptr, Inst) } -> std::same_as<AliasResult>;
+  { AS.alias(Ptr, Ptr, Inst) } -> std::convertible_to<AliasResult>;
 };
 
 template <typename T>
diff --git a/include/phasar/Pointer/AliasResult.h b/include/phasar/Pointer/AliasResult.h
index 825d51ca0c..ac373b852a 100644
--- a/include/phasar/Pointer/AliasResult.h
+++ b/include/phasar/Pointer/AliasResult.h
@@ -22,6 +22,11 @@ enum class AliasResult {
 
 std::string toString(AliasResult AR);
 
+// for ADL std::to_string compatibility
+[[nodiscard]] inline auto to_string(AliasResult Res) noexcept { // NOLINT
+  return toString(Res);
+}
+
 AliasResult toAliasResult(llvm::StringRef S);
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, AliasResult AR);
diff --git a/include/phasar/Pointer/BottomupUnionFindAA.h b/include/phasar/Pointer/BottomupUnionFindAA.h
new file mode 100644
index 0000000000..d4a69ee9ca
--- /dev/null
+++ b/include/phasar/Pointer/BottomupUnionFindAA.h
@@ -0,0 +1,258 @@
+#pragma once
+
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#include "phasar/ControlFlow/CallGraph.h"
+#include "phasar/ControlFlow/CallGraphBase.h"
+#include "phasar/Pointer/PointerAssignmentGraph.h"
+#include "phasar/Pointer/RawAliasSet.h"
+#include "phasar/Pointer/UnionFindAA.h"
+#include "phasar/Utils/DebugOutput.h"
+#include "phasar/Utils/IotaIterator.h"
+#include "phasar/Utils/Logger.h"
+#include "phasar/Utils/MapUtils.h"
+#include "phasar/Utils/MaybeUniquePtr.h"
+#include "phasar/Utils/Printer.h"
+#include "phasar/Utils/SCCGeneric.h"
+#include "phasar/Utils/SCCId.h"
+#include "phasar/Utils/Soundness.h"
+#include "phasar/Utils/TypedVector.h"
+#include "phasar/Utils/ValueCompressor.h"
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallVector.h"
+
+#include <cstdint>
+#include <optional>
+#include <unordered_map>
+
+namespace psr {
+
+struct BottomupUnionFindAABase {
+  static constexpr llvm::StringLiteral LogCategory = "BottomupUnionFindAA";
+};
+
+/// SCC-based, bottom-up union-find alias analysis.
+///
+/// Interprocedural Steensgaard-style analysis with summary propagation along
+/// the SCC DAG of the call graph.
+///
+/// When \p SoundnessFlag is \c Soundness::Soundy (default), a top-down pass
+/// propagates parameter aliasing information back to callers for soundness.
+/// Set it to \c Soundness::Unsound to skip this pass and trade precision for
+/// speed.
+///
+/// Intra-SCC Call/Return edges (mutual recursion) are handled
+/// context-insensitively.
+///
+/// Implements \c pag::PBStrategy. After \c buildPAG() completes, call
+/// \c consumeAAResults() to obtain a \c BasicUnionFindAAResult.
+///
+/// \tparam AnalysisDomainT The analysis domain, e.g., \c LLVMPAGDomain.
+/// \tparam SoundnessFlag   Controls whether the top-down parameter-aliasing
+///                         pass is performed.
+template <typename AnalysisDomainT, Soundness SoundnessFlag = Soundness::Soundy>
+class BottomupUnionFindAA : BottomupUnionFindAABase {
+  struct ParamInfo {
+    ValueId Arg;
+    ValueId Param;
+    pag::Call CS;
+  };
+  struct CallSiteInfo {
+    llvm::SmallVector<ParamInfo, 2> Params{};
+    llvm::SmallVector<ValueId, 1> Ret{};
+    std::optional<ValueId> RetSlot{};
+  };
+
+public:
+  using n_t = typename AnalysisDomainT::n_t;
+  using v_t = typename AnalysisDomainT::v_t;
+  using f_t = typename AnalysisDomainT::f_t;
+  using db_t = typename AnalysisDomainT::db_t;
+
+  using CGTy = CallGraph<n_t, f_t>;
+  using RevCGTy = ReverseCGGraph<CGTy, db_t>;
+  using FunVtxTy = typename RevCGTy::FunctionId;
+
+  using BottomupUnionFindAABase::LogCategory;
+
+  static constexpr auto InvalidSCC = SCCId<FunVtxTy>(UINT32_MAX);
+
+  constexpr BottomupUnionFindAA(RevCGTy &&RevCG,
+                                NonNullPtr<SCCHolder<FunVtxTy>> CGSCCs)
+      : RevCG(std::move(RevCG)), CGSCCs(CGSCCs.get()) {
+    const auto NumSCCs = CGSCCs->size();
+    Calls.resize(NumSCCs);
+    IdsForSum.resize(NumSCCs);
+  }
+
+  constexpr BottomupUnionFindAA(RevCGTy &&RevCG) : RevCG(std::move(RevCG)) {
+    auto SCCs = computeSCCs(this->RevCG);
+    this->CGSCCs = std::make_unique<SCCHolder<FunVtxTy>>(std::move(SCCs));
+    const auto NumSCCs = CGSCCs->size();
+    Calls.resize(NumSCCs);
+    IdsForSum.resize(NumSCCs);
+  }
+
+  void withCalleesOfCallAt(ByConstRef<n_t> CS,
+                           std::invocable<f_t> auto WithCallee) const {
+    for (const auto &Callee : RevCG.CGView->getCalleesOfCallAt(CS)) {
+      std::invoke(WithCallee, Callee);
+    }
+  }
+
+  void onAddEdge(ValueId From, ValueId To, pag::Edge E,
+                 Nullable<n_t> CallSite) {
+    if (E.isa<pag::Call>()) {
+      auto FromSCC = SCCOfVal[From];
+      auto ToSCC = SCCOfVal[To];
+      if (FromSCC != ToSCC && FromSCC != InvalidSCC && ToSCC != InvalidSCC) {
+        Calls[FromSCC][CallSite].Params.emplace_back(From, To,
+                                                     E.cast<pag::Call>());
+        IdsForSum[ToSCC].insert(To);
+        return;
+      }
+      // fallthrough -- intra-SCC edges are context-insensitive
+    } else if (E.isa<pag::Return>()) {
+      auto FromSCC = SCCOfVal[From];
+      auto ToSCC = SCCOfVal[To];
+      if (FromSCC != ToSCC && FromSCC != InvalidSCC && ToSCC != InvalidSCC) {
+        auto &RetInfo = Calls[ToSCC][CallSite];
+        assert(RetInfo.RetSlot == std::nullopt || RetInfo.RetSlot == To);
+        RetInfo.RetSlot = To;
+        RetInfo.Ret.push_back(From);
+
+        IdsForSum[FromSCC].insert(From);
+        return;
+      }
+      // fallthrough -- intra-SCC edges are context-insensitive
+    }
+
+    Base.onAddEdge(From, To, E, CallSite);
+  }
+
+  void onAddValue(ByConstRef<v_t> Var, ValueId VId) {
+    auto &SccPlace = SCCOfVal.emplace_back(InvalidSCC);
+    if (auto &&Fun = getFunction(Var)) {
+      if (auto FunVtx = RevCG.FC.getOrNull(Fun)) {
+        SccPlace = CGSCCs->SCCOfNode[*FunVtx];
+      }
+    }
+
+    Base.onAddValue(Var, VId);
+  }
+
+  [[nodiscard]] BasicUnionFindAAResult consumeAAResults(size_t NumVars) && {
+
+    bottomupPropagation(NumVars);
+
+    if constexpr (SoundnessFlag != Soundness::Unsound) {
+      // For soundness, we need to handle parameter aliasing
+      topdownPropagation();
+    }
+
+    return std::move(Base).consumeAAResults(NumVars);
+  }
+
+private:
+  void bottomupPropagation(size_t NumVars) {
+    TypedVector<ValueId, RawAliasSet<ValueId>> IntermediateBackView(NumVars);
+
+    for (SCCId<FunVtxTy> CurrSCC :
+         llvm::reverse(iota<SCCId<FunVtxTy>>(CGSCCs->size()))) {
+
+      for (const auto &[CS, CSInfo] : Calls[CurrSCC]) {
+        PHASAR_LOG_LEVEL_CAT(DEBUG, LogCategory, "At CS: " << NToString(CS));
+        llvm::SmallDenseMap<ValueId, llvm::SmallVector<ValueId, 2>> BackMap;
+
+        for (const auto &[Arg, Param, E] : CSInfo.Params) {
+          auto ParamRep = Base.AliasSets.find(Param);
+          BackMap[ParamRep].push_back(Arg);
+        }
+        if (CSInfo.RetSlot) {
+          for (auto Ret : CSInfo.Ret) {
+            auto RetRep = Base.AliasSets.find(Ret);
+            BackMap[RetRep].push_back(*CSInfo.RetSlot);
+          }
+        }
+
+        // --- Apply summaries:
+        for (const auto &[Param, Args] : BackMap) {
+          PHASAR_LOG_LEVEL_CAT(DEBUG, LogCategory,
+                               "  Param: " << psr::to_underlying(Param)
+                                           << "; Args: "
+                                           << PrettyPrinter{Args});
+
+          const auto &ToAliases = IntermediateBackView[Param];
+          ToAliases.foreach ([&](ValueId Alias) {
+            auto AliasRep = Base.AliasSets.find(Alias);
+            if (const auto *AliasFroms = getOrNull(BackMap, AliasRep)) {
+              for (auto Arg : Args) {
+                PHASAR_LOG_LEVEL_CAT(DEBUG, LogCategory,
+                                     "  JOIN " << psr::to_underlying(Arg)
+                                               << " WITH "
+                                               << PrettyPrinter{*AliasFroms});
+
+                for (auto Alias : *AliasFroms) {
+                  Base.AliasSets.join(Arg, Alias);
+                }
+              }
+            }
+          });
+        }
+      }
+      // --- Compute new summaries:
+
+      IdsForSum[CurrSCC].foreach ([&](ValueId SumId) {
+        auto SumIdRep = Base.AliasSets.find(SumId);
+        IntermediateBackView[SumIdRep].insert(SumId);
+      });
+    }
+  }
+
+  void topdownPropagation() {
+    for (SCCId<FunVtxTy> CurrSCC : iota<SCCId<FunVtxTy>>(CGSCCs->size())) {
+      for (const auto &[CS, CSInfo] : Calls[CurrSCC]) {
+        const size_t Sz = CSInfo.Params.size();
+        for (size_t I : psr::iota(Sz)) {
+          const ParamInfo FirstInfo = CSInfo.Params[I];
+          const auto FirstArgRep = Base.AliasSets.find(FirstInfo.Arg);
+          for (size_t J : psr::iota(I + 1, Sz)) {
+            const ParamInfo &SecondInfo = CSInfo.Params[J];
+            const auto SecondArgRep = Base.AliasSets.find(SecondInfo.Arg);
+
+            if (FirstArgRep == SecondArgRep) {
+              // Found parameter-aliasing!
+              Base.AliasSets.join(FirstInfo.Param, SecondInfo.Param);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  [[nodiscard]] Nullable<f_t> getFunction(ByConstRef<v_t> Var) {
+    if constexpr (requires() { getPointerFrom(Var)->getFunction(); }) {
+      return getPointerFrom(Var)->getFunction();
+    } else {
+      return RevCG.IRDB->getFunctionOf(Var);
+    }
+  }
+
+  RevCGTy RevCG;
+  MaybeUniquePtr<SCCHolder<FunVtxTy>> CGSCCs;
+
+  TypedVector<ValueId, SCCId<FunVtxTy>> SCCOfVal;
+  TypedVector<SCCId<FunVtxTy>, std::unordered_map<n_t, CallSiteInfo>> Calls;
+  TypedVector<SCCId<FunVtxTy>, RawAliasSet<ValueId>> IdsForSum;
+  BasicUnionFindAA<AnalysisDomainT> Base{};
+};
+} // namespace psr
diff --git a/include/phasar/Pointer/CallingContextConstructor.h b/include/phasar/Pointer/CallingContextConstructor.h
new file mode 100644
index 0000000000..0b5003b7d0
--- /dev/null
+++ b/include/phasar/Pointer/CallingContextConstructor.h
@@ -0,0 +1,183 @@
+#pragma once
+
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#include "phasar/ControlFlow/CallGraph.h"
+#include "phasar/DB/ProjectIRDB.h"
+#include "phasar/Utils/ByRef.h"
+#include "phasar/Utils/Compressor.h"
+#include "phasar/Utils/StrongTypeDef.h"
+
+#include "llvm/ADT/DenseMapInfo.h"
+#include "llvm/ADT/Hashing.h"
+
+#include <array>
+#include <concepts>
+#include <cstdint>
+
+namespace psr {
+/// A K-limited call-string context.  Stores the \p K most recent call-sites
+/// that led to the current execution point (index 0 = most recent).  The
+/// default \p K = 1 gives a 1-call-site context (CFA/k-CFA style).
+template <typename N, unsigned K = 1> struct CallingContext {
+  using n_t = N;
+
+  /// The K most recent call-sites; index 0 is the most recent.
+  std::array<n_t, K> Callers{};
+
+  [[nodiscard]] friend auto hash_value(const CallingContext &CC) {
+    return llvm::hash_combine_range(CC.Callers.begin(), CC.Callers.end());
+  }
+
+  [[nodiscard]] friend bool
+  operator==(const CallingContext &L,
+             const CallingContext &R) noexcept = default;
+
+  [[nodiscard]] CallingContext withPrefix(n_t FirstCS) const noexcept {
+    auto Ret = *this;
+    auto Tmp = FirstCS;
+    for (size_t I = 0; I != K; ++I) {
+      auto NextTmp = Ret.Callers[I];
+      Ret.Callers[I] = Tmp;
+      Tmp = NextTmp;
+    }
+
+    return Ret;
+  }
+};
+} // namespace psr
+
+namespace llvm {
+template <typename N, unsigned K>
+struct DenseMapInfo<psr::CallingContext<N, K>> {
+  using CallingContext = psr::CallingContext<N, K>;
+
+  static CallingContext getEmptyKey() noexcept {
+    CallingContext Ret{};
+    Ret.Callers[0] = llvm::DenseMapInfo<N>::getEmptyKey();
+    return Ret;
+  }
+  static CallingContext getTombstoneKey() noexcept {
+    CallingContext Ret{};
+    Ret.Callers[0] = llvm::DenseMapInfo<N>::getTombstoneKey();
+    return Ret;
+  }
+
+  static auto getHashValue(psr::ByConstRef<CallingContext> CC) {
+    return hash_value(CC);
+  }
+
+  static bool isEqual(psr::ByConstRef<CallingContext> L,
+                      psr::ByConstRef<CallingContext> R) noexcept {
+    return L == R;
+  }
+};
+} // namespace llvm
+
+PHASAR_STRONG_TYPEDEF(psr, uint32_t, CallingContextId, None = 0);
+
+namespace psr {
+
+/// Manages the set of calling contexts encountered for a given analysis and
+/// maps them to dense sequential \c CallingContextId values.
+///
+/// Used by \c CallingContextSensUnionFindAA to enumerate all call-string
+/// prefixes of length ≤ K for each function.  Contexts are interned in a
+/// \c Compressor; \c CallingContextId::None (id 0) always represents the
+/// "no calling context" (top-level / uncalled) entry.
+///
+/// \tparam N  Node type (call-site).
+/// \tparam F  Function type.
+/// \tparam K  Maximum call-string depth (must be in [1, 9]).
+template <typename N, typename F, unsigned K = 1>
+class CallingContextConstructor {
+public:
+  static_assert(K > 0);
+  static_assert(K < 10, "Do you really want a sooo large context-k-limit? "
+                        "Reconsider your choices!");
+
+  using n_t = N;
+  using f_t = F;
+
+  CallingContextConstructor() {
+    // Assign Id 0 === ContextId::None
+    CC2Id.getOrInsert(CallingContext<n_t, K>{});
+  }
+
+  /// Enumerates all call-string prefixes of length ≤ K that lead to \p Fun
+  /// and invokes \p CCVisitor(firstCallSite, contextId) for each one.
+  /// If \p Fun has no callers (or K is exhausted), the "None" context is used.
+  template <ProjectIRDB DBTy>
+    requires(std::same_as<typename DBTy::f_t, f_t> &&
+             std::same_as<typename DBTy::n_t, n_t>)
+  void visitAllCallingContexts(
+      ByConstRef<f_t> Fun, const CallGraph<n_t, f_t> &CG, const DBTy &IRDB,
+      std::invocable<n_t, CallingContextId> auto CCVisitor) {
+    CallingContext<n_t, K> Ctx{};
+    visitAllCallingContextsImpl<0>(Fun, CG, IRDB, CCVisitor, Ctx);
+  }
+
+  /// Enumerates all calling contexts that include \p Call as their most recent
+  /// call-site and invokes \p CCVisitor(contextId) for each one.
+  template <ProjectIRDB DBTy>
+    requires(std::same_as<typename DBTy::f_t, f_t> &&
+             std::same_as<typename DBTy::n_t, n_t>)
+  void visitContextsAtCall(ByConstRef<n_t> Call, const CallGraph<n_t, f_t> &CG,
+                           const DBTy &IRDB,
+                           std::invocable<CallingContextId> auto CCVisitor) {
+    CallingContext<n_t, K> Ctx{};
+    Ctx.Callers[0] = Call;
+    visitAllCallingContextsImpl<1>(
+        IRDB.getFunctionOf(Call), CG, IRDB,
+        [CCVisitor{std::move(CCVisitor)}](ByConstRef<n_t>,
+                                          CallingContextId Ctx) {
+          std::invoke(CCVisitor, Ctx);
+        },
+        Ctx);
+  }
+
+  CallingContextId getOrInsert(ByConstRef<CallingContext<n_t, K>> CC) {
+    return CC2Id.getOrInsert(CC);
+  }
+
+  [[nodiscard]] ByConstRef<CallingContext<n_t, K>>
+  operator[](CallingContextId Ctx) {
+    return CC2Id[Ctx];
+  }
+
+private:
+  template <unsigned Idx, typename DBTy>
+  void visitAllCallingContextsImpl(
+      ByConstRef<f_t> Fun, const CallGraph<n_t, f_t> &CG, const DBTy &IRDB,
+      std::invocable<n_t, CallingContextId> auto &&CCVisitor,
+      CallingContext<n_t, K> &CurrCtx) {
+    // TODO: Improve this algorithm
+
+    if constexpr (Idx < K) {
+      auto &&CallersOfCS = CG.getCallersOf(Fun);
+
+      for (const auto &CS : CallersOfCS) {
+        CurrCtx.Callers[Idx] = CS;
+        visitAllCallingContextsImpl<(Idx + 1)>(IRDB.getFunctionOf(CS), CG, IRDB,
+                                               CCVisitor, CurrCtx);
+      }
+
+      if (!CallersOfCS.empty()) {
+        return;
+      }
+    }
+
+    auto CtxId = CC2Id.getOrInsert(CurrCtx);
+    std::invoke(CCVisitor, CurrCtx.Callers[0], CtxId);
+  }
+
+  Compressor<CallingContext<n_t, K>, CallingContextId> CC2Id{};
+};
+} // namespace psr
diff --git a/include/phasar/Pointer/PointerAssignmentGraph.h b/include/phasar/Pointer/PointerAssignmentGraph.h
new file mode 100644
index 0000000000..f111659f4b
--- /dev/null
+++ b/include/phasar/Pointer/PointerAssignmentGraph.h
@@ -0,0 +1,451 @@
+#pragma once
+
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#include "phasar/Utils/ByRef.h"
+#include "phasar/Utils/Macros.h"
+#include "phasar/Utils/Nullable.h"
+#include "phasar/Utils/TypeTraits.h"
+#include "phasar/Utils/Utilities.h"
+#include "phasar/Utils/ValueCompressor.h"
+
+#include "llvm/Support/Compiler.h"
+
+#include <concepts>
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <type_traits>
+#include <utility>
+#include <variant>
+
+namespace psr {
+
+namespace pag {
+/// Direct pointer assignment: `To = From`.
+struct Assign {};
+/// GEP (field-access) edge. \p Offset holds the byte offset when statically
+/// known; \c std::nullopt for non-constant GEPs.
+struct Gep {
+  std::optional<int16_t> Offset;
+};
+/// Passing an argument at a call site. \p ArgNo is the 0-based parameter index.
+struct Call {
+  uint16_t ArgNo;
+};
+/// Return value flows from callee to caller call-site.
+struct Return {};
+/// Load of a pointer: `To = *From`.
+struct Load {};
+/// Store of a non-aliased pointer: `*To = From`.
+struct Store {};
+/// Store of a potentially aliased pointer: `*To = From`.
+struct StorePOI {};
+/// Block-copy of aggregate memory (e.g., memcpy/memmove): all pointer fields
+/// inside the source are assumed to flow to the corresponding fields of the
+/// destination.
+struct Copy {};
+
+/// Tagged union of all PAG edge kinds, see above.
+struct Edge : public std::variant<Assign, Gep, Call, Return, Load, Store,
+                                  StorePOI, Copy> {
+  using Base =
+      std::variant<Assign, Gep, Call, Return, Load, Store, StorePOI, Copy>;
+  using std::variant<Assign, Gep, Call, Return, Load, Store, StorePOI,
+                     Copy>::variant;
+
+  enum class EdgeKind : uint32_t {};
+
+  template <typename T> static constexpr EdgeKind kindOf() noexcept {
+    return EdgeKind(psr::variant_idx<Base, T>);
+  }
+
+  [[nodiscard]] constexpr EdgeKind kind() const noexcept {
+    return EdgeKind(this->index());
+  }
+
+  template <typename T, typename... Ts>
+  [[nodiscard]] constexpr bool isa() const noexcept {
+    return std::holds_alternative<T>(*this) ||
+           (... || std::holds_alternative<Ts>(*this));
+  }
+
+  template <typename T>
+  [[nodiscard]] constexpr std::optional<T> dyn_cast() const noexcept {
+    if (const auto *Ptr = std::get_if<T>(this)) {
+      return *Ptr;
+    }
+
+    return std::nullopt;
+  }
+
+  template <typename T> [[nodiscard]] constexpr T cast() const noexcept {
+    assert(isa<T>() && "Invalid cast!");
+    const auto *Ptr = std::get_if<T>(this);
+    return *Ptr;
+  }
+
+  template <typename HandlerFn>
+  LLVM_ATTRIBUTE_ALWAYS_INLINE constexpr decltype(auto)
+  apply(HandlerFn &&Handler) const {
+    return std::visit(PSR_FWD(Handler), *this);
+  }
+
+  [[nodiscard]] friend constexpr llvm::StringRef to_string(Edge E) noexcept {
+    return E.apply(psr::Overloaded{
+        [](Assign) { return "Assign"; },
+        // TODO: Print offset, if present
+        [](Gep) { return "Gep"; },
+        // TODO: Print ArgNo
+        [](Call) { return "Call"; },
+        [](Return) { return "Return"; },
+        [](Load) { return "Load"; },
+        [](Store) { return "Store"; },
+        [](StorePOI) { return "StorePOI"; },
+        [](Copy) { return "Copy"; },
+    });
+  }
+};
+
+template <typename T, typename N>
+concept CanOnAddEdgeN =
+    requires(T &Strategy, ValueId From, ValueId To, pag::Edge E) {
+      Strategy.onAddEdge(From, To, E, Nullable<N>{});
+    };
+
+template <typename T>
+concept CanOnAddEdge = CanOnAddEdgeN<T, typename T::n_t>;
+
+template <typename T>
+concept CanWithCalleesOfCallAt =
+    requires(const T &CStrategy, const typename T::n_t &Inst) {
+      CStrategy.withCalleesOfCallAt(Inst, [](typename T::f_t Callee) {});
+    };
+
+/// Minimal requirements for a PAG-builder strategy: analysis-domain type
+/// members plus \c withCalleesOfCallAt.  Does not require \c onAddEdge; use
+/// \c PBStrategy for the full requirement set.
+template <typename T>
+concept PBStrategyBase =
+    CanWithCalleesOfCallAt<T> &&
+    requires(T &Strategy, const T &CStrategy, ValueId From, ValueId To,
+             const typename T::n_t &Inst, pag::Edge E) {
+      typename T::v_t;
+      typename T::db_t;
+      typename T::f_t;
+      typename T::n_t;
+    };
+
+template <typename T>
+concept PBStrategy = CanOnAddEdge<T> && PBStrategyBase<T>;
+
+template <typename T>
+concept CanOnAddValue = requires(T &Strategy, const T::v_t &Var) {
+  Strategy.onAddValue(Var, ValueId{});
+};
+
+/// A PAG-strategy that can provide a capacity hint for the
+/// number of PAG nodes (used to pre-allocate internal buffers).
+template <typename T>
+concept CanGetNumPossibleValues =
+    requires(const T &CStrategy, const T::db_t &IRDB) {
+      {
+        CStrategy.getNumPossibleValues(IRDB)
+      } noexcept -> std::convertible_to<size_t>;
+    };
+
+template <typename T>
+concept CanConsumeAAResults =
+    requires(T Strategy) { std::move(Strategy).consumeAAResults(size_t(0)); };
+
+/// Fans out every PAG-builder callback to two independent strategies.
+/// \p FirstT must be a full \c PBStrategy; \p SecondT only needs to satisfy
+/// \c CanOnAddEdge (it borrows the \c withCalleesOfCallAt and analysis-domain
+/// types from \p FirstT).
+///
+/// Useful for intersecting alias analyses.
+template <PBStrategy FirstT, CanOnAddEdgeN<typename FirstT::n_t> SecondT>
+// requires(std::same_as<typename FirstT::n_t, typename SecondT::n_t> &&
+//          std::same_as<typename FirstT::v_t, typename SecondT::v_t> &&
+//          std::same_as<typename FirstT::f_t, typename SecondT::f_t> &&
+//          std::same_as<typename FirstT::db_t, typename SecondT::db_t>)
+struct PBStrategyCombinator {
+  using n_t = typename FirstT::n_t;
+  using v_t = typename FirstT::v_t;
+  using f_t = typename FirstT::f_t;
+  using db_t = typename FirstT::db_t;
+
+  [[no_unique_address]] FirstT First;
+  [[no_unique_address]] SecondT Second;
+
+  constexpr void onAddEdge(ValueId From, ValueId To, Edge E,
+                           Nullable<n_t> AtInstruction) {
+    First.onAddEdge(From, To, E, AtInstruction);
+    Second.onAddEdge(From, To, E, AtInstruction);
+  }
+
+  constexpr void onAddValue(ByConstRef<v_t> Variable, ValueId VId)
+    requires(CanOnAddValue<FirstT> || CanOnAddValue<SecondT>)
+  {
+    if constexpr (CanOnAddValue<FirstT>) {
+      First.onAddValue(Variable, VId);
+    }
+    if constexpr (CanOnAddValue<SecondT>) {
+      Second.onAddValue(Variable, VId);
+    }
+  }
+
+  [[nodiscard]] constexpr size_t
+  getNumPossibleValues(const db_t &IRDB) const noexcept
+    requires(CanGetNumPossibleValues<FirstT> ||
+             CanGetNumPossibleValues<SecondT>)
+  {
+    const auto Retrieve = [&IRDB]<typename S>(const S &Strategy) {
+      if constexpr (CanGetNumPossibleValues<S>) {
+        return Strategy.getNumPossibleValues(IRDB);
+      }
+      return 0;
+    };
+
+    return std::max(Retrieve(First), Retrieve(Second));
+  }
+
+  constexpr void
+  withCalleesOfCallAt(ByConstRef<n_t> CS,
+                      llvm::function_ref<void(f_t)> WithCallee) const {
+    // We assume, both are on the same call-graph.
+    if constexpr (CanWithCalleesOfCallAt<SecondT>) {
+      Second.withCalleesOfCallAt(CS, WithCallee);
+    } else {
+      First.withCalleesOfCallAt(CS, WithCallee);
+    }
+  }
+
+  constexpr auto consumeAAResults(size_t NumVars) &&
+      requires(CanConsumeAAResults<FirstT> && !CanConsumeAAResults<SecondT>) {
+        return std::move(First).consumeAAResults(NumVars);
+      }
+};
+
+/// Upgrades a \c CanOnAddEdge type to a full \c PBStrategy by mixing in the
+/// analysis-domain types and \c withCalleesOfCallAt from a separate
+/// \c PBStrategyBase.  Typical use: wrap an edge-listener (e.g., a union-find
+/// accumulator) that does not own a call-graph with a call-graph provider.
+///
+/// \tparam FirstT  The edge-listener. Must satisfy \c CanOnAddEdge.
+/// \tparam SecondT The call-graph / domain provider. Must satisfy
+///                 \c PBStrategyBase.
+template <CanOnAddEdge FirstT, PBStrategyBase SecondT>
+struct PBMixin : public FirstT {
+  using n_t = typename SecondT::n_t;
+  using v_t = typename SecondT::v_t;
+  using f_t = typename SecondT::f_t;
+  using db_t = typename SecondT::db_t;
+
+  [[no_unique_address]] SecondT Second;
+
+  [[nodiscard]] constexpr size_t
+  getNumPossibleValues(const db_t &IRDB) const noexcept
+    requires(!CanGetNumPossibleValues<FirstT> &&
+             CanGetNumPossibleValues<SecondT>)
+  {
+    return Second.getNumPossibleValues(IRDB);
+  }
+
+  constexpr void
+  withCalleesOfCallAt(ByConstRef<n_t> CS,
+                      llvm::function_ref<void(f_t)> WithCallee) const {
+    Second.withCalleesOfCallAt(CS, WithCallee);
+  }
+};
+
+/// Debug-only PAG-builder strategy that emits the PAG as a Graphviz DOT
+/// digraph to \c llvm::errs().  The opening \c "digraph PAG {" is printed in
+/// the constructor and the closing brace in the destructor (move-construction
+/// transfers ownership, preventing a double-close).
+struct TracingPBStrategy {
+  bool Engaged = true;
+
+  TracingPBStrategy() { llvm::errs() << "digraph PAG {\n"; }
+  ~TracingPBStrategy() {
+    if (Engaged) {
+      llvm::errs() << "}\n";
+    }
+  }
+
+  constexpr TracingPBStrategy(TracingPBStrategy &&Other) noexcept
+      : Engaged(std::exchange(Other.Engaged, false)) {}
+  constexpr TracingPBStrategy &operator=(TracingPBStrategy &&Other) noexcept {
+    Engaged = std::exchange(Other.Engaged, false);
+    return *this;
+  }
+
+  void onAddEdge(ValueId From, ValueId To, Edge E,
+                 const auto & /*AtInstruction*/) const {
+    llvm::errs() << "  " << uint32_t(From) << "->" << uint32_t(To)
+                 << "[label=\"";
+    llvm::errs().write_escaped(to_string(E)) << "\"];\n";
+  }
+};
+
+/// The main customization point for PAG building.
+/// Implement this interface to provide several callbacks to the PAGBuilder,
+/// specifying how the PAG should be built.
+template <typename AnalysisDomainT> class PBStrategyRef final {
+public:
+  using n_t = typename AnalysisDomainT::n_t;
+  using v_t = typename AnalysisDomainT::v_t;
+  using f_t = typename AnalysisDomainT::f_t;
+  using db_t = typename AnalysisDomainT::db_t;
+
+  /// Creates a type-erased PBStrategyRef from a non-null pointer to a concrete
+  /// Strategy-object.
+  template <PBStrategy ConcreteStrategyT>
+    requires(!same_as_decay<PBStrategyRef, ConcreteStrategyT>)
+  constexpr PBStrategyRef(ConcreteStrategyT *Strategy) noexcept
+      : VT(&VTableFor<ConcreteStrategyT>), Ctx(Strategy) {
+    assert(Strategy != nullptr);
+  }
+
+  /// Called by buildPAG() for every (unique) edge that should be added to the
+  /// PAG
+  ///
+  /// \param From The source-node.
+  /// \param To The destination-node.
+  /// \param E The edge-label that specifies the kind of data-flow that is
+  /// denoted by this edge.
+  /// \param AtInstruction Optionally holds the instruction that caused this
+  /// edge to be created.
+  void onAddEdge(ValueId From, ValueId To, pag::Edge E,
+                 Nullable<n_t> AtInstruction) {
+    VT->OnAddEdge(Ctx, From, To, E, AtInstruction);
+  }
+
+  /// Called by buildPAG() for every (unique) node that should be added to the
+  /// PAG, *excluding* nodes that have already been registered in the used
+  /// ValueCompressor before buildPAG() was called.
+  ///
+  /// \param Variable The IR-specific variable/value for which the new node
+  /// has been created.
+  /// \param VId The value-id of the newly created node.
+  void onAddValue(ByConstRef<v_t> Variable, ValueId VId) {
+    VT->OnAddValue(Ctx, Variable, VId);
+  }
+
+  /// Estimates the maximum number of values created in the ValueCompressor.
+  /// Must not be exact, this is just for pre-allocating buffers for
+  /// optimization purposes.
+  [[nodiscard]] size_t getNumPossibleValues(const db_t &IRDB) const noexcept {
+    return VT->GetNumPossibleValues(Ctx, IRDB);
+  }
+
+  /// Invokes a call-back with each function that may be called at the given
+  /// call-site. Usually, you want to use a CallGraph or a Resolver to implement
+  /// this function.
+  ///
+  /// \param CS The call-site.
+  /// \param WithCallee The callback to be invoked for each callee.
+  void withCalleesOfCallAt(ByConstRef<n_t> CS,
+                           llvm::function_ref<void(f_t)> WithCallee) const {
+    VT->WithCalleesOfCallAt(Ctx, CS, WithCallee);
+  }
+
+private:
+  struct VTable {
+    void (*OnAddEdge)(void *Ctx, ValueId From, ValueId To, pag::Edge E,
+                      Nullable<n_t> AtInstruction);
+    void (*OnAddValue)(void *Ctx, ByConstRef<v_t> Variable, ValueId VId);
+    size_t (*GetNumPossibleValues)(const void *Ctx, const db_t &IRDB) noexcept;
+    void (*WithCalleesOfCallAt)(const void *Ctx, ByConstRef<n_t> CS,
+                                llvm::function_ref<void(f_t)> WithCallee);
+  };
+
+  template <typename ConcreteStrategyT>
+  static void onAddEdgeThunk(void *Ctx, ValueId From, ValueId To, pag::Edge E,
+                             Nullable<n_t> AtInstruction) {
+    // Do things like allocating a new slot in the adjacency-list here
+    static_cast<ConcreteStrategyT *>(Ctx)->onAddEdge(From, To, E,
+                                                     AtInstruction);
+  }
+
+  template <typename ConcreteStrategyT>
+  static void onAddValueThunk(void *Ctx, ByConstRef<v_t> Variable,
+                              ValueId VId) {
+    if constexpr (CanOnAddValue<ConcreteStrategyT>) {
+      static_cast<ConcreteStrategyT *>(Ctx)->onAddValue(Variable, VId);
+    }
+  }
+
+  template <typename ConcreteStrategyT>
+  static size_t getNumPossibleValuesThunk(const void *Ctx,
+                                          const db_t &IRDB) noexcept {
+    if constexpr (CanGetNumPossibleValues<ConcreteStrategyT>) {
+      return static_cast<const ConcreteStrategyT *>(Ctx)->getNumPossibleValues(
+          IRDB);
+    } else {
+      // Fallback-heuristic
+      return IRDB.getNumInstructions();
+    }
+  }
+
+  template <typename ConcreteStrategyT>
+  static void
+  withCalleesOfCallAtThunk(const void *Ctx, ByConstRef<n_t> CS,
+                           llvm::function_ref<void(f_t)> WithCallee) {
+
+    static_cast<const ConcreteStrategyT *>(Ctx)->withCalleesOfCallAt(
+        CS, WithCallee);
+  }
+
+  template <typename ConcreteStrategyT>
+  static constexpr VTable VTableFor = {
+      &onAddEdgeThunk<ConcreteStrategyT>,
+      &onAddValueThunk<ConcreteStrategyT>,
+      &getNumPossibleValuesThunk<ConcreteStrategyT>,
+      &withCalleesOfCallAtThunk<ConcreteStrategyT>,
+  };
+
+  const VTable *VT{};
+  void *Ctx{};
+};
+} // namespace pag
+
+/// A utility-class that can be used to build a pointer-assignment graph (PAG).
+///
+/// This class does not enforce a specifiy graph-layout -- it does not even
+/// require that you explicitly store a graph in memory. Instead, you get
+/// notified about every node and edge that should be created in the PAG.
+///
+/// \tparam AnalysisDomainT The analysis domain to use.
+template <typename AnalysisDomainT> class PAGBuilder {
+public:
+  using n_t = typename AnalysisDomainT::n_t;
+  using v_t = typename AnalysisDomainT::v_t;
+  using f_t = typename AnalysisDomainT::f_t;
+  using db_t = typename AnalysisDomainT::db_t;
+
+  constexpr PAGBuilder() noexcept = default;
+  virtual ~PAGBuilder() = default;
+
+  /// Iterates the passed IRDB to build a PAG, based on the given Strategy.
+  ///
+  /// \param IRDB The IR program to analyze.
+  /// \param VC The value-compressor to use for assigning unique sequential
+  /// integer-ids to each PAG-node. This VC may be pre-populated. You can expect
+  /// that buildPAG() will respect the pre-population in that case. Otherwise,
+  /// ids will be assigned in visitation order (which is not stable and should
+  /// not be relied on!).
+  /// \param Strategy The customization-point for this function. See the docs of
+  /// PBStrategy for more information.
+  virtual void buildPAG(const db_t &IRDB, ValueCompressor<v_t> &VC,
+                        pag::PBStrategyRef<AnalysisDomainT> Strategy) = 0;
+};
+
+} // namespace psr
diff --git a/include/phasar/Pointer/RawAliasSet.h b/include/phasar/Pointer/RawAliasSet.h
new file mode 100644
index 0000000000..2aa70f0f31
--- /dev/null
+++ b/include/phasar/Pointer/RawAliasSet.h
@@ -0,0 +1,104 @@
+#pragma once
+
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#include "phasar/Utils/TypeTraits.h"
+
+#include "llvm/ADT/SparseBitVector.h"
+
+#include <concepts>
+
+namespace psr {
+
+/// Concept for alias-set containers used inside the union-find analyses.
+/// The container must support set insertion, membership test, bitwise
+/// union/intersection/difference, a \c foreach() visitor, and comparison.
+template <typename ASet>
+concept IsRawAliasSet = requires(ASet &MutSet, const ASet &ConstSet,
+                                 typename ASet::value_type ValId) {
+  ASet();
+  ASet(ConstSet);
+  ASet(std::move(MutSet));
+  MutSet = ConstSet;
+  MutSet = std::move(MutSet);
+  MutSet.insert(ValId);
+  { MutSet.tryInsert(ValId) } -> std::convertible_to<bool>;
+  { ConstSet.contains(ValId) } -> std::convertible_to<bool>;
+  // ConstSet.begin();
+  // ConstSet.end();
+  ConstSet.foreach (DummyFn<typename ASet::value_type>{});
+  MutSet |= ConstSet;
+  MutSet &= ConstSet;
+  MutSet -= ConstSet;
+  { ConstSet == ConstSet } noexcept -> std::convertible_to<bool>;
+  { ConstSet != ConstSet } noexcept -> std::convertible_to<bool>;
+  { MutSet.tryMergeWith(ConstSet) } -> std::convertible_to<bool>;
+  { MutSet.clear() } noexcept;
+  { ConstSet.empty() } noexcept -> std::convertible_to<bool>;
+  { ConstSet.size() } noexcept -> std::convertible_to<size_t>;
+};
+
+/// Sparse bit-set used to represent alias sets in union-find analyses.
+///
+/// Currently backed by \c llvm::SparseBitVector for compact storage when ids
+/// are scattered in a large range and dense storage when ids are clustered.
+/// Satisfies \c IsRawAliasSet.
+///
+/// \tparam IdT Integer-like id type (e.g., \c ValueId).
+template <SmallIdType IdT> class RawAliasSet {
+public:
+  using value_type = IdT;
+
+  RawAliasSet() = default;
+
+  void insert(IdT Id) { Bits.set(uint32_t(Id)); }
+
+  [[nodiscard]] bool tryInsert(IdT Id) {
+    return Bits.test_and_set(uint32_t(Id));
+  }
+
+  [[nodiscard]] bool contains(IdT Id) const { return Bits.test(uint32_t(Id)); }
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE void foreach (
+      std::invocable<IdT> auto Handler) const {
+    for (auto Bit : Bits) {
+      std::invoke(Handler, IdT(Bit));
+    }
+  }
+
+  void operator|=(const RawAliasSet &Other) { Bits |= Other.Bits; }
+  void operator&=(const RawAliasSet &Other) { Bits &= Other.Bits; }
+  void operator-=(const RawAliasSet &Other) {
+    Bits.intersectWithComplement(Other.Bits);
+  }
+
+  [[nodiscard]] bool empty() const noexcept { return Bits.empty(); }
+  [[nodiscard]] size_t size() const noexcept { return Bits.count(); }
+
+  void clear() noexcept { Bits.clear(); }
+
+  [[nodiscard]] auto begin() const noexcept { return Bits.begin(); }
+  [[nodiscard]] auto end() const noexcept { return Bits.end(); }
+
+  [[nodiscard]] bool tryMergeWith(const RawAliasSet &Other) {
+    return Bits |= Other.Bits;
+  }
+
+  void erase(IdT Id) { Bits.reset(uint32_t(Id)); }
+
+  [[nodiscard]] bool operator==(const RawAliasSet &Other) const noexcept {
+    return Bits == Other.Bits;
+  }
+
+private:
+  llvm::SparseBitVector<> Bits;
+  // TODO: roaring::Roaring Bits;
+};
+} // namespace psr
diff --git a/include/phasar/Pointer/UnionFindAA.h b/include/phasar/Pointer/UnionFindAA.h
new file mode 100644
index 0000000000..b7f52cf4a4
--- /dev/null
+++ b/include/phasar/Pointer/UnionFindAA.h
@@ -0,0 +1,583 @@
+#pragma once
+
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#include "phasar/ControlFlow/CallGraph.h"
+#include "phasar/Pointer/CallingContextConstructor.h"
+#include "phasar/Pointer/PointerAssignmentGraph.h"
+#include "phasar/Pointer/RawAliasSet.h"
+#include "phasar/Utils/ByRef.h"
+#include "phasar/Utils/IotaIterator.h"
+#include "phasar/Utils/Logger.h"
+#include "phasar/Utils/Macros.h"
+#include "phasar/Utils/MapUtils.h"
+#include "phasar/Utils/NonNullPtr.h"
+#include "phasar/Utils/Nullable.h"
+#include "phasar/Utils/PointerUtils.h"
+#include "phasar/Utils/TypeTraits.h"
+#include "phasar/Utils/TypedArray.h"
+#include "phasar/Utils/TypedVector.h"
+#include "phasar/Utils/UnionFind.h"
+#include "phasar/Utils/Utilities.h"
+#include "phasar/Utils/ValueCompressor.h"
+#include "phasar/Utils/ValueIdMap.h"
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/ErrorHandling.h"
+
+#include <concepts>
+#include <functional>
+#include <type_traits>
+
+namespace psr {
+
+/// Base interface for results of a union-find alias-analysis.
+template <typename T>
+concept UnionFindAAResult = requires(const T &Result, ValueId Var) {
+  { T::isCached() } noexcept -> std::convertible_to<bool>;
+  { Result.getRawAliasSet(Var) } -> std::convertible_to<RawAliasSet<ValueId>>;
+  { Result.mayAlias(Var, Var) } -> std::convertible_to<bool>;
+  { Result.size() } noexcept -> std::convertible_to<size_t>;
+};
+
+/// The intersection of two (different) independent union-find alias-analysis
+/// results.
+/// Use this to achieve better precision than feasible with a single analysis.
+template <UnionFindAAResult FirstT, UnionFindAAResult SecondT>
+struct UnionFindAAResultIntersection {
+  [[nodiscard]] static constexpr bool isCached() noexcept {
+    // The set-intersection is not cached
+    return false;
+  }
+
+  [[nodiscard]] constexpr size_t size() const noexcept {
+    assert(
+        First.size() == Second.size() &&
+        "Only alias-results on the same ValueCompressor should be intersected");
+    return First.size();
+  }
+
+  [[nodiscard]] RawAliasSet<ValueId> getRawAliasSet(ValueId Var) const {
+    auto ResultSet = First.getRawAliasSet(Var);
+    ResultSet &= Second.getRawAliasSet(Var);
+    return ResultSet;
+  }
+
+  [[nodiscard]] constexpr bool mayAlias(ValueId Var1, ValueId Var2) const {
+    return First.mayAlias(Var1, Var2) && Second.mayAlias(Var1, Var2);
+  }
+
+  [[no_unique_address]] FirstT First;
+  [[no_unique_address]] SecondT Second;
+};
+
+/// Specialization of \c PBStrategyCombinator for two union-find analyses whose
+/// results should be intersected for better precision.  Both analyses must
+/// operate on the same analysis domain. After \c buildPAG() completes, call
+/// \c consumeAAResults() to obtain a \c UnionFindAAResultIntersection.
+template <pag::PBStrategy FirstT, pag::CanOnAddEdge SecondT>
+  requires(std::same_as<typename FirstT::n_t, typename SecondT::n_t> &&
+           std::same_as<typename FirstT::v_t, typename SecondT::v_t> &&
+           std::same_as<typename FirstT::f_t, typename SecondT::f_t> &&
+           std::same_as<typename FirstT::db_t, typename SecondT::db_t>)
+struct UnionFindAACombinator
+    : public pag::PBStrategyCombinator<FirstT, SecondT> {
+
+  constexpr UnionFindAACombinator(std::convertible_to<FirstT> auto &&First,
+                                  std::convertible_to<SecondT> auto &&Second)
+      : pag::PBStrategyCombinator<FirstT, SecondT>{PSR_FWD(First),
+                                                   PSR_FWD(Second)} {}
+
+  [[nodiscard]] UnionFindAAResult auto consumeAAResults(size_t NumVars) && {
+    return UnionFindAAResultIntersection{
+        std::move(this->First).consumeAAResults(NumVars),
+        std::move(this->Second).consumeAAResults(NumVars),
+    };
+  }
+};
+
+template <typename FirstT, typename SecondT>
+UnionFindAACombinator(FirstT, SecondT)
+    -> UnionFindAACombinator<FirstT, SecondT>;
+
+/// Lazy cache that wraps any \c UnionFindAAResult and memoises
+/// \c getRawAliasSet() results in a \c ValueIdMap.
+///
+/// Not thread-safe. Each unique \p ValueId is computed at most once on first
+/// access.
+///
+/// \tparam ShouldCacheMayAlias  When \c true (default), \c mayAlias() is
+///   answered via the cached alias sets (one set look-up).  When \c false,
+///   \c mayAlias() is forwarded directly to the underlying result without
+///   materializing a set, which can be faster for analyses whose
+///   \c mayAlias() implementation is already O(1).
+template <UnionFindAAResult AAResT, bool ShouldCacheMayAlias = true>
+class CachedUnionFindAAResult {
+public:
+  explicit CachedUnionFindAAResult(AAResT &&AARes) : AARes(std::move(AARes)) {
+    Cache.reserve(this->AARes.size());
+  }
+
+  [[nodiscard]] static constexpr bool isCached() noexcept { return true; }
+
+  [[nodiscard]] constexpr size_t size() const noexcept { return AARes.size(); }
+
+  [[nodiscard]] const RawAliasSet<ValueId> &getRawAliasSet(ValueId Var) const {
+    auto [It, Inserted] = Cache.try_emplace(Var);
+    if (Inserted) [[unlikely]] {
+      It->second = AARes.getRawAliasSet(Var);
+    }
+    return It->second;
+  }
+
+  [[nodiscard]] bool mayAlias(ValueId Var1, ValueId Var2) const {
+    if constexpr (ShouldCacheMayAlias) {
+      return getRawAliasSet(Var1).contains(Var2);
+    } else {
+      return AARes.mayAlias(Var1, Var2);
+    }
+  }
+
+private:
+  mutable ValueIdMap<ValueId, RawAliasSet<ValueId>> Cache;
+
+  [[no_unique_address]] AAResT AARes;
+};
+
+/// Implements the AliasIterator interface on union-find alias-analysis results.
+template <typename AAResT, typename Var2IdMapper, typename Id2VarMapper>
+  requires UnionFindAAResult<std::remove_cvref_t<AAResT>>
+struct UnionFindAliasIterator {
+  [[no_unique_address]] AAResT AARes;
+  [[no_unique_address]] Var2IdMapper Var2Id;
+  [[no_unique_address]] Id2VarMapper Id2Var;
+
+  void forallAliasesOf(auto &&Ptr, auto && /*Inst*/, auto Callback) {
+    auto Id = std::invoke(Var2Id, Ptr);
+    const auto &RawAliases = AARes.getRawAliasSet(Id);
+    RawAliases.foreach ([&, Callback = copyOrRef(Callback)](ValueId Alias) {
+      std::invoke(Id2Var, Alias, Callback);
+    });
+  }
+};
+
+/// Common storage for union-find alias-analysis results: a \c BackwardView
+/// that maps each equivalence-class representative (\c ObjectRepId) to the
+/// set of all \c ValueId members in that class.
+struct UnionFindAAResultBase {
+  /// Opaque id for equivalence-class representatives after \c compress().
+  enum class ObjectRepId : uint32_t {};
+
+  /// Maps each \c ObjectRepId (equivalence class) to the set of \c ValueId
+  /// members it contains.
+  TypedVector<ObjectRepId, RawAliasSet<ValueId>> BackwardView;
+
+  void dump(llvm::raw_ostream &OS = llvm::errs(), uint32_t Indent = 0) const;
+};
+
+/// Alias-analysis result for flow- and context-insensitive union-find
+/// analyses.  Each \c ValueId maps to exactly one \c ObjectRepId
+/// (its equivalence-class representative).
+struct BasicUnionFindAAResult : UnionFindAAResultBase {
+  /// Maps each \c ValueId to its equivalence-class representative.
+  TypedVector<ValueId, ObjectRepId> Var2Rep;
+
+  [[nodiscard]] static constexpr bool isCached() noexcept { return true; }
+  [[nodiscard]] constexpr size_t size() const noexcept {
+    return Var2Rep.size();
+  }
+
+  [[nodiscard]] const RawAliasSet<ValueId> &
+  getRawAliasSet(ValueId Var) const noexcept {
+    auto Rep = Var2Rep[Var];
+    return BackwardView[Rep];
+  }
+
+  [[nodiscard]] bool mayAlias(ValueId Var1, ValueId Var2) const noexcept {
+    if (Var1 == Var2) {
+      return true;
+    }
+
+    if (!Var2Rep.inbounds(Var1) || !Var2Rep.inbounds(Var2)) {
+      return false;
+    }
+
+    auto Rep1 = Var2Rep[Var1];
+    auto Rep2 = Var2Rep[Var2];
+    return Rep1 == Rep2;
+  }
+};
+
+/// Alias-analysis result for calling-context-sensitive union-find analyses.
+///
+/// A single \c ValueId can belong to multiple equivalence classes (one per
+/// calling context it was cloned into), so \c Var2Rep holds a small vector
+/// of \c ObjectRepId values per variable.
+struct CallingContextSensUnionFindAAResult : UnionFindAAResultBase {
+  /// Maps each \c ValueId to the set of equivalence-class representatives it
+  /// belongs to (one per calling context).
+  TypedVector<ValueId, llvm::SmallVector<ObjectRepId, 2>> Var2Rep{};
+
+  [[nodiscard]] static constexpr bool isCached() noexcept { return false; }
+  [[nodiscard]] constexpr size_t size() const noexcept {
+    return Var2Rep.size();
+  }
+
+  [[nodiscard]] RawAliasSet<ValueId> getRawAliasSet(ValueId Var) const {
+    RawAliasSet<ValueId> ResultSet;
+    for (auto Rep : Var2Rep[Var]) {
+      ResultSet |= BackwardView[Rep];
+    }
+    return ResultSet;
+  }
+
+  [[nodiscard]] bool mayAlias(ValueId Var1, ValueId Var2) const noexcept {
+    if (Var1 == Var2) {
+      return true;
+    }
+
+    // Note: K is mostly small (1 or 2), so below loop should be very cheap
+    if (!Var2Rep.inbounds(Var1) || !Var2Rep.inbounds(Var2)) {
+      return false;
+    }
+    const auto &Reps1 = Var2Rep[Var1];
+    const auto &Reps2 = Var2Rep[Var2];
+    for (ObjectRepId R1 : Reps1) {
+      if (llvm::is_contained(Reps2, R1)) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+
+/// Union-find alias-analysis that is neither context, nor field, nor
+/// indirection sensitive.
+/// Most useful for building a more precise alias-analysis on top of this,
+/// instead of using this directly.
+///
+/// \tparam AnalysisDomainT The analysis domain to use, e.g., LLVMPAGDomain.
+/// \tparam ObjectIdT The type of object-Ids (default ValueId).
+template <typename AnalysisDomainT, typename ObjectIdT = ValueId>
+struct BasicUnionFindAA {
+  using ObjectId = ObjectIdT;
+
+  using n_t = typename AnalysisDomainT::n_t;
+  using v_t = typename AnalysisDomainT::v_t;
+  using f_t = typename AnalysisDomainT::f_t;
+  using db_t = typename AnalysisDomainT::db_t;
+
+  void onAddEdge(ObjectId From, ObjectId To, pag::Edge /*E*/,
+                 Nullable<n_t> /*AtInstruction*/) {
+    AliasSets.join(From, To);
+  }
+
+  void onAddValue(ByConstRef<v_t> /*Var*/, ObjectId VId) {
+    AliasSets.grow(size_t(VId) + 1);
+  }
+
+  template <std::invocable<ValueId> Var2ObjFn = IdentityFn>
+  [[nodiscard]] BasicUnionFindAAResult
+  consumeAAResults(size_t NumVars, Var2ObjFn Var2Obj = {}) && {
+    auto Equiv = std::move(AliasSets)
+                     .template compress<BasicUnionFindAAResult::ObjectRepId>();
+
+    static constexpr auto InvalidRep =
+        BasicUnionFindAAResult::ObjectRepId(UINT32_MAX);
+
+    BasicUnionFindAAResult Result{};
+    Result.BackwardView.resize(Equiv.numClasses());
+    Result.Var2Rep.resize(NumVars, InvalidRep);
+
+    for (auto VId : iota<ValueId>(NumVars)) {
+      // XXX: We should skip only-ret val-ids
+      auto ObjId = std::invoke(Var2Obj, VId);
+      auto Rep = Equiv[ObjId];
+      assert(Result.Var2Rep[VId] == InvalidRep &&
+             "Mapping from ValueId to AliasSet-Id must be injective!");
+      Result.Var2Rep[VId] = Rep;
+      Result.BackwardView[Rep].insert(VId);
+    }
+
+    return Result;
+  }
+
+  UnionFind<ObjectId> AliasSets{};
+};
+
+/// Union-find alias-analysis that achieves (partial) calling-context
+/// sensitivity through heap cloning.
+/// Implements pag::PBStrategy.
+///
+/// \tparam AnalysisDomainT The analysis domain to use, e.g., LLVMPAGDomain.
+/// \tparam K The maximum length of call-strings (default 1).
+template <typename AnalysisDomainT, unsigned K = 1>
+class CallingContextSensUnionFindAA {
+public:
+  enum class CtxObjectId : uint32_t {};
+
+  using n_t = typename AnalysisDomainT::n_t;
+  using v_t = typename AnalysisDomainT::v_t;
+  using f_t = typename AnalysisDomainT::f_t;
+  using db_t = typename AnalysisDomainT::db_t;
+
+  constexpr CallingContextSensUnionFindAA(
+      NonNullPtr<const CallGraph<n_t, f_t>> CG,
+      NonNullPtr<const db_t> IRDB) noexcept
+      : CG(CG), IRDB(IRDB) {}
+
+  void onAddEdge(ValueId From, ValueId To, pag::Edge E,
+                 Nullable<n_t> CallSite) {
+    E.apply(Overloaded{
+        [&, this, CallSite](pag::Call) {
+          for (const auto &[ArgCtxId, FromObj] : Var2Obj[From]) {
+            auto ParamCtx = CC[ArgCtxId].withPrefix(CallSite);
+            auto ParamCtxId = CC.getOrInsert(ParamCtx);
+
+            if (const auto *Dst = getObjectOrNull(To, ParamCtxId)) {
+              Base.AliasSets.join(FromObj, *Dst);
+            }
+          }
+        },
+        [&, this, CallSite](pag::Return) {
+          for (const auto &[CSValCtxId, ToObj] : Var2Obj[To]) {
+            auto RetCtx = CC[CSValCtxId].withPrefix(CallSite);
+            auto RetCtxId = CC.getOrInsert(RetCtx);
+
+            if (const auto *Src = getObjectOrNull(From, RetCtxId)) {
+              Base.AliasSets.join(*Src, ToObj);
+            }
+          }
+        },
+        [&, this](auto) {
+          const auto &FromObjects = Var2Obj[From];
+          for (const auto &[FromCtx, FromObj] : FromObjects) {
+            if (FromCtx == CallingContextId::None) {
+              for (const auto &[ToCtx, ToObj] : Var2Obj[To]) {
+                Base.AliasSets.join(FromObj, ToObj);
+              }
+            } else if (const auto *Dst = getObjectOrNull(To, FromCtx)) {
+              Base.AliasSets.join(FromObj, *Dst);
+            }
+          }
+        },
+    });
+  }
+
+  void onAddValue(ByConstRef<v_t> Var, ValueId VId) {
+    Var2Obj.emplace_back();
+    if (const auto &Fun = getFunction(Var)) {
+      CC.visitAllCallingContexts(
+          unwrapNullable(Fun), *CG, *IRDB,
+          [this, VId](ByConstRef<n_t> /*FirstCS*/, CallingContextId Ctx) {
+            std::ignore = getObject(VId, Ctx);
+          });
+
+      if (!CG->getCallersOf(unwrapNullable(Fun)).empty()) {
+        return;
+      }
+      // fallback in case, we have no callers
+    }
+    std::ignore = getObject(VId, CallingContextId::None);
+  }
+
+  void withCalleesOfCallAt(ByConstRef<n_t> CS,
+                           std::invocable<f_t> auto WithCallee) const {
+    for (const auto &Callee : CG->getCalleesOfCallAt(CS)) {
+      std::invoke(WithCallee, Callee);
+    }
+  }
+
+  /// Retrieve the analysis results after buildPAG() has returned.
+  [[nodiscard]] CallingContextSensUnionFindAAResult
+  consumeAAResults(size_t NumVars) && {
+    auto Equiv = std::move(Base.AliasSets)
+                     .template compress<BasicUnionFindAAResult::ObjectRepId>();
+
+    CallingContextSensUnionFindAAResult Result{};
+    Result.BackwardView.resize(Equiv.numClasses());
+    Result.Var2Rep.resize(NumVars);
+
+    for (const auto &[ValId, Objects] : Var2Obj.enumerate()) {
+      // XXX: We should skip only-ret val-ids
+
+      for (const auto &[_, Obj] : Objects) {
+        auto Rep = Equiv[Obj];
+        if (Result.BackwardView[Rep].tryInsert(ValId)) {
+          Result.Var2Rep[ValId].push_back(Rep);
+        }
+      }
+      if (Objects.empty()) {
+        PHASAR_LOG_LEVEL_CAT(WARNING, "CallingContextSensUnionFindAA",
+                             "Empty Objects-set for Var#" << uint32_t(ValId));
+      }
+    }
+
+    return Result;
+  }
+
+private:
+  [[nodiscard]] Nullable<f_t> getFunction(ByConstRef<v_t> Var) {
+    if constexpr (requires() { getPointerFrom(Var)->getFunction(); }) {
+      return getPointerFrom(Var)->getFunction();
+    } else {
+      return IRDB->getFunctionOf(Var);
+    }
+  }
+
+  [[nodiscard]] const CtxObjectId *getObjectOrNull(ValueId Val,
+                                                   CallingContextId Ctx) {
+
+    const auto *Ret = getOrNull(Var2Obj[Val], Ctx);
+    if (!Ret) {
+      Ret = getOrNull(Var2Obj[Val], CallingContextId::None);
+    }
+
+    return Ret;
+  }
+  [[nodiscard]] CtxObjectId getObject(ValueId VId, CallingContextId Ctx) {
+    auto [It, Inserted] =
+        Var2Obj[VId].try_emplace(Ctx, CtxObjectId(Obj2Var.size()));
+    if (Inserted) {
+      Obj2Var.emplace_back(VId, Ctx);
+      Base.AliasSets.grow(size_t(It->second) + 1);
+    }
+    return It->second;
+  }
+
+  NonNullPtr<const CallGraph<n_t, f_t>> CG;
+  NonNullPtr<const db_t> IRDB;
+  TypedVector<CtxObjectId, std::pair<ValueId, CallingContextId>> Obj2Var{};
+  TypedVector<ValueId, llvm::SmallDenseMap<CallingContextId, CtxObjectId>>
+      Var2Obj{};
+
+  CallingContextConstructor<n_t, f_t, K> CC{};
+  BasicUnionFindAA<AnalysisDomainT, CtxObjectId> Base{};
+};
+
+/// Union-find alias-analysis that achieves (partial) indirection-depth-context
+/// sensitivity through heap cloning.
+/// Use this with pag::PBMixin to implement pag::PBStrategy.
+///
+/// \tparam AnalysisDomainT The analysis domain to use, e.g., LLVMPAGDomain.
+/// \tparam K The maximum depth of pointer-indirections that can be
+/// differentiated (default 5).
+template <typename AnalysisDomainT, unsigned K = 5>
+class IndirectionSensUnionFindAA {
+public:
+  static_assert(K > 0, "A depth-limit of 0 is invalid!");
+
+  enum class IndObjectId : uint32_t {};
+  enum class IndDepth : uint32_t {};
+
+  using n_t = typename AnalysisDomainT::n_t;
+  using v_t = typename AnalysisDomainT::v_t;
+  using f_t = typename AnalysisDomainT::f_t;
+  using db_t = typename AnalysisDomainT::db_t;
+
+  void onAddEdge(ValueId From, ValueId To, pag::Edge E,
+                 Nullable<n_t> /*CallSite*/) {
+    using namespace pag;
+    const auto &FromFldObjects = Var2Obj[From];
+    for (const auto &[FromCtx, FromObj] : FromFldObjects.enumerate()) {
+      switch (E.kind()) {
+      case Edge::kindOf<Copy>():
+        if (FromCtx == IndDepth{}) {
+          break;
+        }
+
+      // fallthrough
+      case Edge::kindOf<Assign>():
+      case Edge::kindOf<Gep>():
+      case Edge::kindOf<Call>():
+      case Edge::kindOf<Return>():
+        if (auto ToObj = getObjectOrNull(To, FromCtx)) {
+          Base.AliasSets.join(FromObj, *ToObj);
+        }
+
+        break;
+      case Edge::kindOf<Load>():
+        if (auto ToCtx = prevDepth(FromCtx)) {
+          if (auto ToObj = getObjectOrNull(To, *ToCtx)) {
+            Base.AliasSets.join(FromObj, *ToObj);
+          }
+        }
+        if (FromCtx == IndDepth(K - 1)) {
+          // For soundness
+          if (auto ToObj = getObjectOrNull(To, FromCtx)) {
+            Base.AliasSets.join(FromObj, *ToObj);
+          }
+        }
+        break;
+      case Edge::kindOf<Store>():
+      case Edge::kindOf<StorePOI>():
+        if (auto ToObj = getObjectOrNull(To, nextDepth(FromCtx))) {
+          Base.AliasSets.join(FromObj, *ToObj);
+        }
+
+        break;
+      default:
+        llvm_unreachable("This switch should cover all cases explicitly");
+      }
+    }
+  }
+
+  void onAddValue(ByConstRef<v_t> /*Var*/, ValueId VId) {
+    auto Obj = Obj2Var.size();
+    Base.AliasSets.grow(Obj + K);
+    Var2Obj.emplace_back(generate_tag, [Obj](IndDepth Depth) {
+      return IndObjectId(Obj + size_t(Depth));
+    });
+    // XXX: For some values, we can already see that depth>=2 does not make
+    // sense, so we could exit the below loop early
+    for (auto Depth : iota<IndDepth>(K)) {
+      Obj2Var.emplace_back(VId, Depth);
+    }
+  }
+
+  /// Retrieve the analysis results after buildPAG() has returned.
+  [[nodiscard]] BasicUnionFindAAResult consumeAAResults(size_t NumVars) && {
+    return std::move(Base).consumeAAResults(NumVars, [this](ValueId VId) {
+      // When presenting the results, we only care about the values at depth 0
+      return Var2Obj[VId][IndDepth{}];
+    });
+  }
+
+private:
+  [[nodiscard]] std::optional<IndObjectId> getObjectOrNull(ValueId VId,
+                                                           IndDepth Ctx) {
+    const auto &Map = Var2Obj[VId];
+    if (!Map.inbounds(Ctx)) {
+      return std::nullopt;
+    }
+
+    return Map[Ctx];
+  }
+
+  constexpr static IndDepth nextDepth(IndDepth Ctx) noexcept {
+    if (Ctx == IndDepth(K - 1)) {
+      return Ctx;
+    }
+
+    return IndDepth(uint32_t(Ctx) + 1);
+  }
+  constexpr static std::optional<IndDepth> prevDepth(IndDepth Ctx) noexcept {
+    if (Ctx == IndDepth{}) {
+      return std::nullopt;
+    }
+    return IndDepth(uint32_t(Ctx) - 1);
+  }
+
+  TypedVector<ValueId, TypedArray<IndDepth, IndObjectId, K>> Var2Obj{};
+  TypedVector<IndObjectId, std::pair<ValueId, IndDepth>> Obj2Var{};
+  BasicUnionFindAA<AnalysisDomainT, IndObjectId> Base{};
+};
+} // namespace psr
diff --git a/include/phasar/Pointer/UnionFindAAType.def b/include/phasar/Pointer/UnionFindAAType.def
new file mode 100644
index 0000000000..0a486a0584
--- /dev/null
+++ b/include/phasar/Pointer/UnionFindAAType.def
@@ -0,0 +1,20 @@
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#ifndef UNIONFIND_ALIAS_ANALYSIS_TYPE
+#define UNIONFIND_ALIAS_ANALYSIS_TYPE(NAME, CMDFLAG, DESC)
+#endif
+
+UNIONFIND_ALIAS_ANALYSIS_TYPE(CtxSens, "ctx-sens", "Context-sensitive analysis with k=1 heap-cloning")
+UNIONFIND_ALIAS_ANALYSIS_TYPE(IndSens, "ind-sens", "Pointer-indirection-sensitive analysis with k=5 heap-cloning")
+UNIONFIND_ALIAS_ANALYSIS_TYPE(CtxIndSens, "ctx-ind-sens", "Intersection of ctx-sens and ind-sens")
+UNIONFIND_ALIAS_ANALYSIS_TYPE(BotCtxSens, "botctx-sens", "Unbounded context-sensitive analysis, but only provides function-local results")
+UNIONFIND_ALIAS_ANALYSIS_TYPE(BotCtxIndSens, "botctx-ind-sens", "Intersection of botctx-sens and ind-sens")
+
+#undef UNIONFIND_ALIAS_ANALYSIS_TYPE
diff --git a/include/phasar/Pointer/UnionFindAliasAnalysisType.h b/include/phasar/Pointer/UnionFindAliasAnalysisType.h
new file mode 100644
index 0000000000..dec47142fa
--- /dev/null
+++ b/include/phasar/Pointer/UnionFindAliasAnalysisType.h
@@ -0,0 +1,29 @@
+#pragma once
+
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#include "llvm/ADT/StringRef.h"
+
+namespace psr {
+enum class UnionFindAliasAnalysisType : uint8_t {
+#define UNIONFIND_ALIAS_ANALYSIS_TYPE(NAME, CMDFLAG, DESC) NAME,
+#include "phasar/Pointer/UnionFindAAType.def"
+};
+
+[[nodiscard]] constexpr llvm::StringRef
+to_string(UnionFindAliasAnalysisType AType) noexcept {
+  switch (AType) {
+#define UNIONFIND_ALIAS_ANALYSIS_TYPE(NAME, CMDFLAG, DESC)                     \
+  case UnionFindAliasAnalysisType::NAME:                                       \
+    return CMDFLAG;
+#include "phasar/Pointer/UnionFindAAType.def"
+  }
+}
+} // namespace psr
diff --git a/include/phasar/Utils/BitSet.h b/include/phasar/Utils/BitSet.h
index 732ff7f6e8..80f07eba0b 100644
--- a/include/phasar/Utils/BitSet.h
+++ b/include/phasar/Utils/BitSet.h
@@ -10,6 +10,8 @@
 #ifndef PHASAR_UTILS_BITSET_H
 #define PHASAR_UTILS_BITSET_H
 
+#include "phasar/Utils/TypeTraits.h"
+
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallBitVector.h"
 
@@ -20,6 +22,7 @@
 #include <cstdint>
 #include <functional>
 #include <iterator>
+#include <optional>
 #include <type_traits>
 
 namespace psr {
@@ -34,13 +37,21 @@ namespace psr {
 /// convertible from and to uint32_t.
 /// \tparam BitVectorTy The underlying bit-vector to use. Must be either
 /// llvm::BitVector or llvm::SmallBitVector.
-template <typename IdT, typename BitVectorTy = llvm::BitVector> class BitSet {
+template <SmallIdType IdT, typename BitVectorTy = llvm::BitVector>
+class BitSet {
   static llvm::ArrayRef<uintptr_t> getWords(const llvm::BitVector &BV,
                                             uintptr_t & /*Store*/) {
+    // getData() accesses Bits[0] unconditionally; guard against empty vector.
+    if (BV.empty()) {
+      return {};
+    }
     return BV.getData();
   }
   static llvm::ArrayRef<uintptr_t> getWords(const llvm::SmallBitVector &BV,
                                             uintptr_t &Store) {
+    if (BV.empty()) {
+      return {};
+    }
     return BV.getData(Store);
   }
 
@@ -178,7 +189,20 @@ template <typename IdT, typename BitVectorTy = llvm::BitVector> class BitSet {
   }
   [[nodiscard]] iterator end() const noexcept { return Bits.set_bits_end(); }
 
-  /// Calls the given handler function for each sert bit in the bitset.
+  /// Returns the smallest element in the set, or std::nullopt if empty.
+  [[nodiscard]] std::optional<IdT> findFirst() const noexcept {
+    const int First = Bits.find_first();
+    return First >= 0 ? std::optional<IdT>(IdT(First)) : std::nullopt;
+  }
+
+  /// Returns the smallest element greater than \p Key, or std::nullopt if
+  /// none exists.
+  [[nodiscard]] std::optional<IdT> findNext(IdT Key) const noexcept {
+    const int Next = Bits.find_next(int(uint32_t(Key)));
+    return Next >= 0 ? std::optional<IdT>(IdT(Next)) : std::nullopt;
+  }
+
+  /// Calls the given handler function for each set bit in the bitset.
   ///
   /// This is likely faster than using iterators.
   template <std::invocable<IdT> HandlerFn>
diff --git a/include/phasar/Utils/Compressor.h b/include/phasar/Utils/Compressor.h
index 7bc0cb9457..6e23750ad3 100644
--- a/include/phasar/Utils/Compressor.h
+++ b/include/phasar/Utils/Compressor.h
@@ -23,16 +23,15 @@
 #include <deque>
 #include <functional>
 #include <optional>
-#include <type_traits>
 
 namespace psr {
-template <typename T, typename IdT = uint32_t> class Compressor;
+template <typename T, IdType IdT = uint32_t> class Compressor;
 
 /// \brief A utility class that assigns a sequential Id to every inserted
 /// object.
 ///
 /// This specialization handles types that can be efficiently passed by value
-template <typename T, typename IdT>
+template <typename T, IdType IdT>
   requires(CanEfficientlyPassByValue<T> && has_llvm_dense_map_info<T>)
 class Compressor<T, IdT> {
 public:
@@ -112,7 +111,7 @@ class Compressor<T, IdT> {
 /// object.
 ///
 /// This specialization handles types that cannot be efficiently passed by value
-template <typename T, typename IdT>
+template <typename T, IdType IdT>
   requires(!CanEfficientlyPassByValue<T> || !has_llvm_dense_map_info<T>)
 class Compressor<T, IdT> {
 public:
@@ -249,6 +248,45 @@ class Compressor<T, IdT> {
   llvm::DenseMap<const T *, IdT, DSI> ToInt;
 };
 
+struct NoneCompressor final {
+  constexpr NoneCompressor() noexcept = default;
+
+  template <typename T>
+    requires(!std::is_same_v<NoneCompressor, T>)
+  constexpr NoneCompressor(const T & /*unused*/) noexcept {}
+
+  template <typename T>
+  [[nodiscard]] constexpr decltype(auto) getOrInsert(T &&Val) const noexcept {
+    return std::forward<T>(Val);
+  }
+
+  template <typename T>
+  constexpr std::pair<T, bool> insert(const T &Elem) const {
+    return {Elem, false};
+  }
+
+  template <typename T>
+  constexpr std::optional<T> getOrNull(const T &Elem) const {
+    return {Elem};
+  }
+
+  template <typename T> constexpr T get(const T &Elem) const { return Elem; }
+
+  template <typename T>
+  [[nodiscard]] constexpr bool inbounds(const T & /*Idx*/) const noexcept {
+    return true;
+  }
+
+  template <typename T>
+  [[nodiscard]] constexpr decltype(auto) operator[](T &&Val) const noexcept {
+    return std::forward<T>(Val);
+  }
+  constexpr void reserve(size_t /*unused*/) const noexcept {}
+
+  [[nodiscard]] constexpr size_t size() const noexcept { return 0; }
+  [[nodiscard]] constexpr size_t capacity() const noexcept { return 0; }
+};
+
 } // namespace psr
 
 #endif // PHASAR_DATAFLOW_IFDSIDE_SOLVER_COMPRESSOR_H
diff --git a/include/phasar/Utils/DebugOutput.h b/include/phasar/Utils/DebugOutput.h
index 738739854a..1e3cf6e475 100644
--- a/include/phasar/Utils/DebugOutput.h
+++ b/include/phasar/Utils/DebugOutput.h
@@ -10,6 +10,7 @@
 #define PHASAR_UTILS_DEBUGOUTPUT_H
 
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
+#include "phasar/Utils/TypeTraits.h"
 
 #include "llvm/IR/Type.h"
 #include "llvm/Support/raw_os_ostream.h"
@@ -30,8 +31,8 @@ namespace detail {
 template <typename OS_t, typename T> void printHelper(OS_t &OS, const T &Data);
 
 template <typename OS_t, typename... Args, size_t... Idx>
-void printTuple(OS_t &OS, const std::tuple<Args...> &Tup,
-                std::index_sequence<Idx...> /*unused*/) {
+inline void printTuple(OS_t &OS, const std::tuple<Args...> &Tup,
+                       std::index_sequence<Idx...> /*unused*/) {
   OS << "(";
   ((OS << (Idx == 0 ? "" : ", "), printHelper(OS, std::get<Idx>(Tup))), ...);
   OS << ")";
@@ -56,6 +57,12 @@ template <typename OS_t, typename T> void printHelper(OS_t &OS, const T &Data) {
     }
   } else if constexpr (is_printable_v<ElemTy, OS_t>) {
     OS << Data;
+  } else if constexpr (has_str_v<ElemTy>) {
+    OS << Data.str();
+  } else if constexpr (has_adl_to_string_v<ElemTy>) {
+    OS << psr::adl_to_string(Data);
+  } else if constexpr (std::is_enum_v<ElemTy>) {
+    OS << std::underlying_type_t<ElemTy>(Data);
   } else if constexpr (is_pair_v<ElemTy>) {
     OS << "(";
     printHelper(OS, Data.first);
@@ -64,8 +71,6 @@ template <typename OS_t, typename T> void printHelper(OS_t &OS, const T &Data) {
     OS << ")";
   } else if constexpr (is_tuple_v<ElemTy>) {
     printTuple(OS, Data, std::make_index_sequence<std::tuple_size_v<ElemTy>>());
-  } else if constexpr (has_str_v<ElemTy>) {
-    OS << Data.str();
   } else if constexpr (is_iterable_v<ElemTy>) {
     OS << "{ ";
     bool Frst = true;
diff --git a/include/phasar/PhasarLLVM/DataFlow/IfdsIde/FunctionDataFlowFacts.h b/include/phasar/Utils/FunctionDataFlowFacts.h
similarity index 95%
rename from include/phasar/PhasarLLVM/DataFlow/IfdsIde/FunctionDataFlowFacts.h
rename to include/phasar/Utils/FunctionDataFlowFacts.h
index ccb4c6b7c2..2d0afa8d8f 100644
--- a/include/phasar/PhasarLLVM/DataFlow/IfdsIde/FunctionDataFlowFacts.h
+++ b/include/phasar/Utils/FunctionDataFlowFacts.h
@@ -31,6 +31,11 @@ struct DataFlowFact {
   DataFlowFact(Parameter Param) noexcept : Fact(Param) {}
   DataFlowFact(ReturnValue Ret) noexcept : Fact(Ret) {}
 
+  template <typename T>
+  [[nodiscard]] constexpr const auto *dyn_cast() const noexcept {
+    return std::get_if<T>(&Fact);
+  }
+
   std::variant<Parameter, ReturnValue> Fact;
 };
 
diff --git a/include/phasar/Utils/IO.h b/include/phasar/Utils/IO.h
index 0d5c53135a..6dec7262fe 100644
--- a/include/phasar/Utils/IO.h
+++ b/include/phasar/Utils/IO.h
@@ -53,6 +53,9 @@ void writeTextFile(const llvm::Twine &Path, llvm::StringRef Content);
 [[nodiscard]] std::unique_ptr<llvm::raw_fd_ostream>
 openFileStream(const llvm::Twine &Filename);
 
+std::unique_ptr<llvm::raw_ostream>
+openFileForWrite(const llvm::Twine &FilePath);
+
 } // namespace psr
 
 #endif
diff --git a/include/phasar/Utils/IotaIterator.h b/include/phasar/Utils/IotaIterator.h
index c01805f688..10d8e19faa 100644
--- a/include/phasar/Utils/IotaIterator.h
+++ b/include/phasar/Utils/IotaIterator.h
@@ -84,7 +84,8 @@ template <typename IdT>
   return Ret;
 }
 
-template <typename IdT> [[nodiscard]] constexpr auto iota(size_t To) noexcept {
+template <typename IdT = size_t>
+[[nodiscard]] constexpr auto iota(size_t To) noexcept {
   static_assert(is_explicitly_convertible_to<size_t, IdT> &&
                     is_explicitly_convertible_to<IdT, size_t>,
                 "Iota only works on integers and integer-like types");
diff --git a/include/phasar/PhasarLLVM/DataFlow/IfdsIde/LibCSummary.h b/include/phasar/Utils/LibCSummary.h
similarity index 100%
rename from include/phasar/PhasarLLVM/DataFlow/IfdsIde/LibCSummary.h
rename to include/phasar/Utils/LibCSummary.h
diff --git a/include/phasar/Utils/MaybeUniquePtr.h b/include/phasar/Utils/MaybeUniquePtr.h
index 11c55553cd..7ad6d12155 100644
--- a/include/phasar/Utils/MaybeUniquePtr.h
+++ b/include/phasar/Utils/MaybeUniquePtr.h
@@ -61,6 +61,8 @@ template <typename T> class MaybeUniquePtrBase<T, true> {
 template <typename T, bool RequireAlignment = false>
 class [[clang::trivial_abi]] MaybeUniquePtr
     : detail::MaybeUniquePtrBase<T, RequireAlignment> {
+  template <typename U, bool Align> friend class MaybeUniquePtr;
+
   using detail::MaybeUniquePtrBase<T, RequireAlignment>::Data;
 
 public:
@@ -83,6 +85,14 @@ class [[clang::trivial_abi]] MaybeUniquePtr
     Other.Data = {};
   }
 
+  constexpr MaybeUniquePtr(
+      MaybeUniquePtr<std::remove_const_t<T>> &&Other) noexcept
+    requires std::is_const_v<T>
+      : detail::MaybeUniquePtrBase<T, RequireAlignment>(Other.get(),
+                                                        Other.owns()) {
+    Other.Data = {};
+  }
+
   constexpr void swap(MaybeUniquePtr &Other) noexcept {
     std::swap(Data, Other.Data);
   }
diff --git a/include/phasar/Utils/NonNullPtr.h b/include/phasar/Utils/NonNullPtr.h
new file mode 100644
index 0000000000..0a978a5ede
--- /dev/null
+++ b/include/phasar/Utils/NonNullPtr.h
@@ -0,0 +1,77 @@
+#pragma once
+
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#include "phasar/Utils/Utilities.h"
+
+#include "llvm/Support/Compiler.h"
+
+#include <functional>
+
+namespace psr {
+template <typename T>
+class [[gsl::Pointer(T)]] NonNullPtr : public std::reference_wrapper<T> {
+  using Base = std::reference_wrapper<T>;
+
+public:
+  constexpr NonNullPtr(std::nullptr_t) = delete;
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE constexpr NonNullPtr(T *Ptr) noexcept
+      : std::reference_wrapper<T>(psr::assertNotNull(Ptr)) {}
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE constexpr NonNullPtr(
+      std::reference_wrapper<T> RW) noexcept
+      : std::reference_wrapper<T>(RW) {}
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE explicit constexpr NonNullPtr(T &Ref) noexcept
+      : std::reference_wrapper<T>(Ref) {}
+
+  template <typename U>
+    requires(!std::same_as<U, T> && std::convertible_to<U *, T *>)
+  LLVM_ATTRIBUTE_ALWAYS_INLINE constexpr NonNullPtr(
+      NonNullPtr<U> Other) noexcept
+      : std::reference_wrapper<T>(Other) {}
+
+  [[nodiscard]] LLVM_ATTRIBUTE_ALWAYS_INLINE
+      LLVM_ATTRIBUTE_RETURNS_NONNULL constexpr T *
+      get() const noexcept {
+    return std::addressof(this->Base::get());
+  }
+
+  [[nodiscard]] LLVM_ATTRIBUTE_ALWAYS_INLINE
+      LLVM_ATTRIBUTE_RETURNS_NONNULL constexpr T *
+      operator->() const noexcept {
+    return get();
+  }
+
+  [[nodiscard]] LLVM_ATTRIBUTE_ALWAYS_INLINE constexpr T &
+  operator*() const noexcept {
+    return this->Base::get();
+  }
+
+  [[nodiscard]] LLVM_ATTRIBUTE_ALWAYS_INLINE constexpr bool
+  operator==(NonNullPtr Other) noexcept {
+    return get() == Other.get();
+  }
+  [[nodiscard]] LLVM_ATTRIBUTE_ALWAYS_INLINE constexpr bool
+  operator==(const T *R) noexcept {
+    return get() == R;
+  }
+  [[nodiscard]] LLVM_ATTRIBUTE_ALWAYS_INLINE constexpr bool
+  operator==(std::nullptr_t) noexcept = delete; // NonNullPtr is never null
+
+  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, NonNullPtr RW) {
+    return OS << RW.get();
+  }
+  friend std::ostream &operator<<(std::ostream &OS, NonNullPtr RW) {
+    return OS << RW.get();
+  }
+};
+} // namespace psr
diff --git a/include/phasar/Utils/SCCGeneric.h b/include/phasar/Utils/SCCGeneric.h
index d6cf50efe8..396c901a89 100644
--- a/include/phasar/Utils/SCCGeneric.h
+++ b/include/phasar/Utils/SCCGeneric.h
@@ -15,10 +15,10 @@
 #include "phasar/Utils/GraphTraits.h"
 #include "phasar/Utils/IotaIterator.h"
 #include "phasar/Utils/RepeatIterator.h"
+#include "phasar/Utils/SCCId.h"
 #include "phasar/Utils/TypedVector.h"
 
 #include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
@@ -29,69 +29,6 @@
 
 namespace psr {
 
-namespace detail {
-// Unfortunately, `enum class` cannot be templated, but we want type-safety for
-// SCC-IDs...
-struct SCCIdBase {
-  uint32_t Value{};
-
-  constexpr SCCIdBase() noexcept = default;
-
-  explicit constexpr SCCIdBase(uint32_t Val) noexcept : Value(Val) {}
-
-  explicit constexpr operator uint32_t() const noexcept { return Value; }
-  template <typename T = size_t>
-  explicit constexpr operator size_t() const noexcept
-    requires(!std::is_same_v<uint32_t, T>)
-  {
-    return Value;
-  }
-
-  explicit constexpr operator ptrdiff_t() const noexcept {
-    return ptrdiff_t(Value);
-  }
-
-  constexpr uint32_t operator+() const noexcept { return Value; }
-
-  friend constexpr bool operator==(SCCIdBase L, SCCIdBase R) noexcept {
-    return L.Value == R.Value;
-  }
-  friend constexpr bool operator!=(SCCIdBase L, SCCIdBase R) noexcept {
-    return !(L == R);
-  }
-};
-} // namespace detail
-
-/// \brief The Id of a strongly-connected component in a graph.
-///
-/// \tparam GraphNodeId The vertex-type of the graph where this SCC was computed
-/// for.
-template <typename GraphNodeId> struct SCCId : detail::SCCIdBase {
-  using detail::SCCIdBase::SCCIdBase;
-};
-
-} // namespace psr
-
-namespace llvm {
-template <typename GraphNodeId> struct DenseMapInfo<psr::SCCId<GraphNodeId>> {
-  using SCCId = psr::SCCId<GraphNodeId>;
-
-  static constexpr SCCId getEmptyKey() noexcept { return SCCId(UINT32_MAX); }
-  static constexpr SCCId getTombstoneKey() noexcept {
-    return SCCId(UINT32_MAX - 1);
-  }
-
-  static auto getHashValue(SCCId SCC) noexcept {
-    return llvm::hash_value(uint32_t(SCC));
-  }
-  static constexpr bool isEqual(SCCId SCC1, SCCId SCC2) noexcept {
-    return SCC1 == SCC2;
-  }
-};
-} // namespace llvm
-
-namespace psr {
-
 /// \brief Holds the SCCs of a given graph. Each SCC is assigned a unique
 /// sequential id.
 template <typename GraphNodeId> struct SCCHolder {
@@ -169,7 +106,7 @@ struct GraphTraits<SCCDependencyGraph<GraphNodeId>> {
   using vertex_t = SCCId<GraphNodeId>;
   using edge_t = vertex_t;
 
-  static inline constexpr auto Invalid = vertex_t(UINT32_MAX);
+  static constexpr auto Invalid = vertex_t(UINT32_MAX);
 
   [[nodiscard]] static constexpr const auto &outEdges(const graph_type &G,
                                                       vertex_t Vtx) noexcept {
diff --git a/include/phasar/Utils/SCCId.h b/include/phasar/Utils/SCCId.h
new file mode 100644
index 0000000000..0cf4aeb0c0
--- /dev/null
+++ b/include/phasar/Utils/SCCId.h
@@ -0,0 +1,81 @@
+/******************************************************************************
+ * Copyright (c) 2024 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and other
+ *****************************************************************************/
+#pragma once
+
+#include "phasar/Utils/TypeTraits.h"
+
+#include "llvm/ADT/DenseMapInfo.h"
+
+#include <cstdint>
+#include <type_traits>
+
+namespace psr {
+
+namespace detail {
+// Unfortunately, `enum class` cannot be templated, but we want type-safety for
+// SCC-IDs...
+struct SCCIdBase {
+  uint32_t Value{};
+
+  constexpr SCCIdBase() noexcept = default;
+
+  explicit constexpr SCCIdBase(uint32_t Val) noexcept : Value(Val) {}
+
+  explicit constexpr operator uint32_t() const noexcept { return Value; }
+  template <typename T = size_t>
+  explicit constexpr operator size_t() const noexcept
+    requires(!std::is_same_v<uint32_t, T>)
+  {
+    return Value;
+  }
+
+  explicit constexpr operator ptrdiff_t() const noexcept {
+    return ptrdiff_t(Value);
+  }
+
+  constexpr uint32_t operator+() const noexcept { return Value; }
+
+  friend constexpr bool operator==(SCCIdBase L, SCCIdBase R) noexcept {
+    return L.Value == R.Value;
+  }
+  friend constexpr bool operator!=(SCCIdBase L, SCCIdBase R) noexcept {
+    return !(L == R);
+  }
+};
+} // namespace detail
+
+/// \brief The Id of a strongly-connected component in a graph.
+///
+/// \tparam GraphNodeId The vertex-type of the graph where this SCC was computed
+/// for.
+template <typename GraphNodeId> struct SCCId : detail::SCCIdBase {
+  using detail::SCCIdBase::SCCIdBase;
+};
+
+static_assert(IdType<SCCId<uint32_t>>);
+
+} // namespace psr
+
+namespace llvm {
+template <typename GraphNodeId> struct DenseMapInfo<psr::SCCId<GraphNodeId>> {
+  using SCCId = psr::SCCId<GraphNodeId>;
+
+  static constexpr SCCId getEmptyKey() noexcept { return SCCId(UINT32_MAX); }
+  static constexpr SCCId getTombstoneKey() noexcept {
+    return SCCId(UINT32_MAX - 1);
+  }
+
+  static auto getHashValue(SCCId SCC) noexcept {
+    return llvm::hash_value(uint32_t(SCC));
+  }
+  static constexpr bool isEqual(SCCId SCC1, SCCId SCC2) noexcept {
+    return SCC1 == SCC2;
+  }
+};
+} // namespace llvm
diff --git a/include/phasar/Utils/StrongTypeDef.h b/include/phasar/Utils/StrongTypeDef.h
new file mode 100644
index 0000000000..85c906f81f
--- /dev/null
+++ b/include/phasar/Utils/StrongTypeDef.h
@@ -0,0 +1,101 @@
+#pragma once
+
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#include "phasar/Utils/ByRef.h"
+
+#include "llvm/ADT/DenseMapInfo.h"
+#include "llvm/Support/HashBuilder.h"
+
+#include <limits>
+#include <numeric>
+#include <type_traits>
+
+#define PHASAR_STRONG_TYPEDEF(NAMESPACE, TYPE, NAME, ...)                      \
+  namespace NAMESPACE {                                                        \
+  enum class [[clang::enum_extensibility(open)]] NAME : TYPE { __VA_ARGS__ };  \
+  }                                                                            \
+  namespace llvm {                                                             \
+  template <> struct DenseMapInfo<NAMESPACE::NAME> {                           \
+    using QUAL_NAME = NAMESPACE::NAME;                                         \
+    static constexpr QUAL_NAME getEmptyKey() noexcept {                        \
+      return QUAL_NAME(std::is_signed_v<TYPE>                                  \
+                           ? std::numeric_limits<TYPE>::min()                  \
+                           : std::numeric_limits<TYPE>::max());                \
+    }                                                                          \
+    static constexpr QUAL_NAME getTombstoneKey() noexcept {                    \
+      return QUAL_NAME(std::is_signed_v<TYPE>                                  \
+                           ? std::numeric_limits<TYPE>::min() + 1              \
+                           : std::numeric_limits<TYPE>::max() - 1);            \
+    }                                                                          \
+    static auto getHashValue(QUAL_NAME Id) noexcept {                          \
+      return llvm::hash_value(TYPE(Id));                                       \
+    }                                                                          \
+    static constexpr bool isEqual(QUAL_NAME Id1, QUAL_NAME Id2) noexcept {     \
+      return Id1 == Id2;                                                       \
+    }                                                                          \
+  };                                                                           \
+  }
+
+#define PHASAR_DERIVE_ENUM_DMI(QUAL_NAME, TYPE, TYPE_PARAM)                    \
+  namespace llvm {                                                             \
+  template <TYPE_PARAM> struct DenseMapInfo<QUAL_NAME> {                       \
+    static constexpr QUAL_NAME getEmptyKey() noexcept {                        \
+      return QUAL_NAME(std::is_signed_v<TYPE>                                  \
+                           ? std::numeric_limits<TYPE>::min()                  \
+                           : std::numeric_limits<TYPE>::max());                \
+    }                                                                          \
+    static constexpr QUAL_NAME getTombstoneKey() noexcept {                    \
+      return QUAL_NAME(std::is_signed_v<TYPE>                                  \
+                           ? std::numeric_limits<TYPE>::min() + 1              \
+                           : std::numeric_limits<TYPE>::max() - 1);            \
+    }                                                                          \
+    static auto getHashValue(QUAL_NAME Id) noexcept {                          \
+      return llvm::hash_value(TYPE(Id));                                       \
+    }                                                                          \
+    static constexpr bool isEqual(QUAL_NAME Id1, QUAL_NAME Id2) noexcept {     \
+      return Id1 == Id2;                                                       \
+    }                                                                          \
+  };                                                                           \
+  }
+
+#define PHASAR_DERIVE_DMI(QUAL_TYPE)                                           \
+  namespace llvm {                                                             \
+  template <> struct DenseMapInfo<::QUAL_TYPE> {                               \
+    using Type = ::QUAL_TYPE;                                                  \
+    static Type getEmptyKey() noexcept { return Type::getEmptyKey(); }         \
+    static Type getTombstoneKey() noexcept { return Type::getTombstoneKey(); } \
+    static bool isEqual(::psr::ByConstRef<Type> Lhs,                           \
+                        ::psr::ByConstRef<Type> Rhs) noexcept {                \
+      return Lhs == Rhs;                                                       \
+    }                                                                          \
+    static auto getHashValue(::psr::ByConstRef<Type> Val) noexcept {           \
+      using llvm::hash_value;                                                  \
+      return hash_value(Val);                                                  \
+    }                                                                          \
+  };                                                                           \
+  }
+
+namespace psr {
+template <typename EnumT>
+// NOLINTNEXTLINE(readability-identifier-naming)
+[[nodiscard]] constexpr auto to_underlying(EnumT Val) noexcept
+  requires(std::is_enum_v<EnumT>)
+{
+  return static_cast<std::underlying_type_t<EnumT>>(Val);
+}
+template <typename EnumT>
+// NOLINTNEXTLINE(readability-identifier-naming)
+[[nodiscard]] constexpr auto to_underlying(EnumT Val) noexcept
+  requires(std::is_integral_v<EnumT>)
+{
+  return Val;
+}
+} // namespace psr
diff --git a/include/phasar/Utils/TypeTraits.h b/include/phasar/Utils/TypeTraits.h
index e634382eb0..95c02db718 100644
--- a/include/phasar/Utils/TypeTraits.h
+++ b/include/phasar/Utils/TypeTraits.h
@@ -16,6 +16,7 @@
 #include "llvm/Support/raw_ostream.h"
 
 #include <concepts>
+#include <cstddef>
 #include <iterator>
 #include <string>
 #include <string_view>
@@ -57,6 +58,19 @@ class template_arg {
       decltype(getTemplateArgImpl<Base>(std::declval<const Derived &>()));
 };
 
+template <template <typename...> typename Base, typename Derived>
+class IsTemplateInstanceImpl {
+private:
+  template <template <typename...> typename TBase, typename... TT>
+  static std::true_type test(const TBase<TT...> &Impl);
+  template <template <typename...> typename TBase>
+  static std::false_type test(...);
+
+public:
+  static constexpr bool value =
+      decltype(test<Base>(std::declval<const Derived &>()))::value;
+};
+
 template <typename Var, typename T> struct variant_idx;
 template <typename... Ts, typename T>
 struct variant_idx<std::variant<Ts...>, T>
@@ -93,6 +107,12 @@ concept is_iterable_over_v = is_iterable_v<T> && requires(T &Val) {
   { *llvm::adl_begin(Val) } -> same_as_decay<Over>;
 };
 
+template <typename T>
+concept Foreachable = requires(T &Val) { Val.foreach ([](auto &&...Elem) {}); };
+template <typename T, typename... Over>
+concept ForeachableOver =
+    requires(T &Val) { Val.foreach ([](const Over &...Elem) {}); };
+
 template <typename T>
 concept is_pair_v = detail::is_pair<T>::value; // NOLINT
 
@@ -202,6 +222,17 @@ template <typename From, typename To>
 concept is_explicitly_convertible_to =
     requires(From F) { static_cast<To>(std::forward<From>(F)); };
 
+template <typename T>
+concept IdType = is_explicitly_convertible_to<T, size_t> &&
+                 is_explicitly_convertible_to<size_t, T>;
+
+template <typename T, unsigned MaxWidth = sizeof(unsigned)>
+concept SmallIdType = IdType<T> && sizeof(T) <= MaxWidth;
+
+template <typename Derived, template <typename...> typename Base>
+concept IsTemplateInstance =
+    detail::IsTemplateInstanceImpl<Base, Derived>::value;
+
 template <typename Var, typename T>
 constexpr size_t variant_idx = detail::variant_idx<Var, T>::value;
 
@@ -234,7 +265,7 @@ struct FalseFn {
 /// Delegates to the ctor of T
 template <typename T> struct DefaultConstruct {
   template <typename... U>
-  [[nodiscard]] inline T
+  [[nodiscard]] T
   operator()(U &&...Val) noexcept(std::is_nothrow_constructible_v<T, U...>) {
     return T(std::forward<U>(Val)...);
   }
@@ -272,6 +303,26 @@ struct IdentityFn {
   }
 };
 
+template <typename ArgT> struct DummyFn {
+  void operator()(ArgT Arg) const noexcept {}
+};
+
+/// True if T can be relocated by copying its bytes (e.g. via memcpy) without
+/// invoking the move constructor or destructor on the source. Uses Clang's
+/// builtin trait when available (P1144 / P2786), which covers types like
+/// std::unique_ptr that are trivially relocatable but not trivially copyable.
+/// Falls back to std::is_trivially_copyable_v on other compilers.
+template <typename T>
+inline constexpr bool IsTriviallyRelocatable =
+#if defined(__has_builtin) &&                                                  \
+    __has_builtin(__builtin_is_cpp_trivially_relocatable)
+    __builtin_is_cpp_trivially_relocatable(T);
+#elif defined(__has_builtin) && __has_builtin(__is_trivially_relocatable)
+    __is_trivially_relocatable(T);
+#else
+    std::is_trivially_copyable_v<T>;
+#endif
+
 template <typename T, typename R, typename... P>
 concept invocable_r = requires(T Val, P... Params) {
   { std::invoke(PSR_FWD(Val), PSR_FWD(Params)...) } -> std::convertible_to<R>;
diff --git a/include/phasar/Utils/TypedArray.h b/include/phasar/Utils/TypedArray.h
new file mode 100644
index 0000000000..be1aa0fbba
--- /dev/null
+++ b/include/phasar/Utils/TypedArray.h
@@ -0,0 +1,88 @@
+#pragma once
+
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#include "phasar/Utils/ByRef.h"
+#include "phasar/Utils/TypeTraits.h"
+
+#include <array>
+#include <functional>
+#include <type_traits>
+#include <utility>
+
+namespace psr {
+
+/// Tag type for the generator constructor of \c TypedArray.
+struct generate_tag_t {};
+/// Tag value passed to the \c TypedArray generator constructor.
+inline constexpr generate_tag_t generate_tag{};
+
+/// Fixed-size array indexed by a strongly-typed id \p IdT instead of
+/// \c size_t.
+///
+/// \tparam IdT    Index type.  Must satisfy \c IdType (fits in \c size_t).
+/// \tparam ValueT Element type.
+/// \tparam N      Compile-time size.
+template <IdType IdT, typename ValueT, unsigned N>
+class TypedArray : public std::array<ValueT, N> {
+  using Base = std::array<ValueT, N>;
+
+public:
+  using std::array<ValueT, N>::array;
+
+  explicit constexpr TypedArray(
+      generate_tag_t /*unused*/,
+      std::invocable<IdT> auto
+          Gen) noexcept(std::is_nothrow_invocable_v<decltype(Gen) &, IdT>) {
+    [this, Gen = copyOrRef(Gen)]<size_t... I>(std::index_sequence<I...>) {
+      ((this->Base::operator[](I) =
+            std::invoke(Gen, std::integral_constant<IdT, IdT(I)>())),
+       ...);
+    }(std::make_index_sequence<N>());
+  }
+
+  [[nodiscard]] constexpr bool inbounds(IdT Id) const noexcept {
+    return size_t(Id) < N;
+  }
+
+  [[nodiscard]] constexpr const ValueT &operator[](IdT Id) const & {
+    assert(inbounds(Id));
+    return this->Base::operator[](size_t(Id));
+  }
+
+  [[nodiscard]] constexpr ValueT &operator[](IdT Id) & {
+    assert(inbounds(Id));
+    return this->Base::operator[](size_t(Id));
+  }
+
+  [[nodiscard]] constexpr ValueT operator[](IdT Id) && {
+    assert(inbounds(Id));
+    return std::move(this->Base::operator[](size_t(Id)));
+  }
+
+  [[nodiscard]] llvm::ArrayRef<ValueT> asRef() const & noexcept {
+    return {this->Base::data(), N};
+  }
+  [[nodiscard]] llvm::ArrayRef<ValueT> asRef() && noexcept = delete;
+
+  [[nodiscard]] auto enumerate() const noexcept {
+    return llvm::map_range(llvm::enumerate(*this), [](const auto &IndexAndVal) {
+      return std::pair<IdT, ByConstRef<ValueT>>{IdT(IndexAndVal.index()),
+                                                IndexAndVal.value()};
+    });
+  }
+  [[nodiscard]] auto enumerate() noexcept {
+    return llvm::map_range(llvm::enumerate(*this), [](auto &IndexAndVal) {
+      return std::pair<IdT, ValueT &>{IdT(IndexAndVal.index()),
+                                      IndexAndVal.value()};
+    });
+  }
+};
+} // namespace psr
diff --git a/include/phasar/Utils/TypedVector.h b/include/phasar/Utils/TypedVector.h
index ef15f3e158..7b2679e336 100644
--- a/include/phasar/Utils/TypedVector.h
+++ b/include/phasar/Utils/TypedVector.h
@@ -11,6 +11,7 @@
 #define PHASAR_UTILS_TYPEDVECTOR_H
 
 #include "phasar/Utils/ByRef.h"
+#include "phasar/Utils/TypeTraits.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
@@ -32,7 +33,7 @@ namespace psr {
 /// \tparam ValueT The usual value_type of SmallVector.
 /// \tparam SmallSize The size of the inline-storage of SmallVector (default:
 /// 0)
-template <typename IdT, typename ValueT, unsigned SmallSize = 0>
+template <IdType IdT, typename ValueT, unsigned SmallSize = 0>
 class TypedVector {
 public:
   TypedVector() noexcept = default;
@@ -117,13 +118,13 @@ class TypedVector {
   drop_front(size_t Offs) && noexcept = delete;
 
   [[nodiscard]] auto enumerate() const noexcept {
-    return llvm::map_range(llvm::enumerate(Vec), [](const auto &IndexAndVal) {
+    return llvm::map_range(llvm::enumerate(Vec), [](auto &&IndexAndVal) {
       return std::pair<IdT, ByConstRef<ValueT>>{IdT(IndexAndVal.index()),
                                                 IndexAndVal.value()};
     });
   }
   [[nodiscard]] auto enumerate() noexcept {
-    return llvm::map_range(llvm::enumerate(Vec), [](auto &IndexAndVal) {
+    return llvm::map_range(llvm::enumerate(Vec), [](auto &&IndexAndVal) {
       return std::pair<IdT, ValueT &>{IdT(IndexAndVal.index()),
                                       IndexAndVal.value()};
     });
diff --git a/include/phasar/Utils/UnionFind.h b/include/phasar/Utils/UnionFind.h
new file mode 100644
index 0000000000..3589179b84
--- /dev/null
+++ b/include/phasar/Utils/UnionFind.h
@@ -0,0 +1,81 @@
+#pragma once
+
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#include "phasar/Utils/TypeTraits.h"
+
+#include "llvm/ADT/IntEqClasses.h"
+
+namespace psr {
+
+template <SmallIdType IdT = uint32_t, SmallIdType MappedIdT = IdT>
+class CompressedUnionFind;
+
+/// Mutable union-find (disjoint-set) data structure over integer-like ids.
+///
+/// Supports \c join() (union by rank with path compression, via
+/// \c llvm::IntEqClasses) and \c find() (representative look-up). When all
+/// unions have been performed, call \c compress() to obtain a
+/// \c CompressedUnionFind that assigns dense sequential class indices.
+///
+/// \tparam IdT  Element type.  Must satisfy \c SmallIdType (fits in
+///              \c uint32_t).
+template <SmallIdType IdT = uint32_t> class UnionFind {
+public:
+  UnionFind() noexcept = default;
+  explicit UnionFind(size_t InitSz) : Equiv(InitSz) {}
+
+  IdT join(IdT L, IdT R) { return IdT(Equiv.join(unsigned(L), unsigned(R))); }
+
+  [[nodiscard]] IdT find(IdT Val) const {
+    return IdT(Equiv.findLeader(unsigned(Val)));
+  }
+
+  void grow(size_t NewSz) { Equiv.grow(NewSz); }
+
+  template <SmallIdType MappedIdT = IdT>
+  [[nodiscard]] CompressedUnionFind<IdT, MappedIdT> compress() &&;
+
+private:
+  llvm::IntEqClasses Equiv;
+};
+
+/// Read-only view of a compressed union-find: maps each original element to a
+/// dense sequential class index in the range [0, numClasses()).
+///
+/// Obtained by calling \c UnionFind::compress<MappedIdT>(); not directly
+/// constructible.
+///
+/// \tparam IdT       Original element type.
+/// \tparam MappedIdT Type for the dense class indices.
+template <SmallIdType IdT, SmallIdType MappedIdT> class CompressedUnionFind {
+public:
+  [[nodiscard]] size_t numClasses() const noexcept {
+    return Equiv.getNumClasses();
+  }
+
+  [[nodiscard]] MappedIdT operator[](IdT Id) const {
+    return MappedIdT(Equiv[unsigned(Id)]);
+  }
+
+private:
+  friend UnionFind<IdT>;
+  CompressedUnionFind(llvm::IntEqClasses &&Equiv) : Equiv(std::move(Equiv)) {}
+
+  llvm::IntEqClasses Equiv;
+};
+
+template <SmallIdType IdT>
+template <SmallIdType MappedIdT>
+inline CompressedUnionFind<IdT, MappedIdT> UnionFind<IdT>::compress() && {
+  Equiv.compress();
+  return {std::move(Equiv)};
+}
+} // namespace psr
diff --git a/include/phasar/Utils/Utilities.h b/include/phasar/Utils/Utilities.h
index 414df68d30..d9cddb7531 100644
--- a/include/phasar/Utils/Utilities.h
+++ b/include/phasar/Utils/Utilities.h
@@ -10,6 +10,7 @@
 #ifndef PHASAR_UTILS_UTILITIES_H_
 #define PHASAR_UTILS_UTILITIES_H_
 
+#include "phasar/Utils/ByRef.h"
 #include "phasar/Utils/TypeTraits.h"
 
 #include "llvm/ADT/SmallVector.h"
@@ -269,6 +270,14 @@ forward_like(U &&X) noexcept { // NOLINT
   }
 }
 
+template <typename T> constexpr auto copyOrRef(T &Val) noexcept {
+  if constexpr (CanEfficientlyPassByValue<T>) {
+    return Val;
+  } else {
+    return std::ref(Val);
+  }
+}
+
 struct identity {
   template <typename T> decltype(auto) operator()(T &&Val) const noexcept {
     return std::forward<T>(Val);
diff --git a/include/phasar/Utils/ValueCompressor.h b/include/phasar/Utils/ValueCompressor.h
new file mode 100644
index 0000000000..d325841586
--- /dev/null
+++ b/include/phasar/Utils/ValueCompressor.h
@@ -0,0 +1,123 @@
+#pragma once
+
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#include "phasar/Utils/ByRef.h"
+#include "phasar/Utils/StrongTypeDef.h"
+#include "phasar/Utils/TypedVector.h"
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/TinyPtrVector.h"
+#include "llvm/Support/PointerLikeTypeTraits.h"
+
+#include <optional>
+#include <type_traits>
+
+/// The id-type for values inserted into the ValueCompressor.
+PHASAR_STRONG_TYPEDEF(psr, uint32_t, ValueId);
+
+namespace psr {
+
+namespace detail {
+template <typename T>
+static constexpr bool IsPointerWithAtleastOneFreeLowBit = false;
+template <typename T>
+  requires requires() { llvm::PointerLikeTypeTraits<T>::NumLowBitsAvailable; }
+static constexpr bool IsPointerWithAtleastOneFreeLowBit<T> =
+    llvm::PointerLikeTypeTraits<T>::NumLowBitsAvailable > 0;
+} // namespace detail
+
+/// A utility-class that assigns sequential integer-like ids (psr::ValueId) to
+/// every inserted value.
+///
+/// In contrast to psr::Compressor, the ValueCompressor can optionally
+/// assign the same id to multiple values, and it can even produce ids without
+/// corresponding values.
+///
+/// \tparam T The type of inserted values. Expected to be mostly small and
+/// trivial.
+template <typename T> class ValueCompressor {
+public:
+  using value_type = T;
+  using id_type = ValueId;
+  using var_aliases_type = std::conditional_t<
+      detail::IsPointerWithAtleastOneFreeLowBit<T>, llvm::TinyPtrVector<T>,
+      // Note: The inline-buffer of SmallVector is pointer-aligned, so it would
+      // be wasteful to only allow one, e.g., int16
+      llvm::SmallVector<T, std::max(size_t(1), sizeof(void *) / sizeof(T))>>;
+
+  [[nodiscard]] constexpr const auto &id2vars() const noexcept
+      [[clang::lifetimebound]] {
+    return Id2Vars;
+  }
+  [[nodiscard]] constexpr const auto &id2vars(ValueId Id) const noexcept
+      [[clang::lifetimebound]] {
+    return Id2Vars[Id];
+  }
+  [[nodiscard]] constexpr const auto &var2id() const noexcept
+      [[clang::lifetimebound]] {
+    return Var2Id;
+  }
+
+  /// Inserts \p Var and assigns it a fresh \c ValueId, or returns the existing
+  /// id if \p Var was already present.
+  /// \returns {id, true} on first insertion; {id, false} if already present.
+  std::pair<ValueId, bool> insert(ByConstRef<T> Var) {
+    auto [It, Inserted] = Var2Id.try_emplace(Var, ValueId(Id2Vars.size()));
+    if (Inserted) {
+      Id2Vars.emplace_back().push_back(Var);
+    }
+    return {It->second, Inserted};
+  }
+
+  /// Registers \p Var as an additional name for the existing \p Id (aliasing).
+  /// \p Id must already exist.  If \p Var already maps to some id, this is a
+  /// no-op and returns \c false; otherwise the mapping is added and \c true is
+  /// returned.
+  bool addAlias(ByConstRef<T> Var, ValueId Id) {
+    assert(Id2Vars.inbounds(Id) &&
+           "Can only add an alias to an already existing Id!");
+    if (Var2Id.try_emplace(Var, Id).second) {
+      Id2Vars[Id].push_back(Var);
+      return true;
+    }
+    return false;
+  }
+
+  /// Allocates a fresh \c ValueId with no associated variable (a placeholder
+  /// or sentinel slot).
+  [[nodiscard]] ValueId addDummy() {
+    auto Ret = ValueId(Id2Vars.size());
+    Id2Vars.emplace_back();
+    return Ret;
+  }
+
+  [[nodiscard]] std::optional<ValueId> getOrNull(ByConstRef<T> Var) const {
+    auto It = Var2Id.find(Var);
+    if (It == Var2Id.end()) {
+      return std::nullopt;
+    }
+    return It->second;
+  }
+
+  void reserve(size_t Capa) {
+    Var2Id.reserve(Capa);
+    Id2Vars.reserve(Capa);
+  }
+
+  [[nodiscard]] size_t size() const noexcept { return Id2Vars.size(); }
+  [[nodiscard]] bool empty() const noexcept { return Id2Vars.empty(); }
+
+private:
+  llvm::DenseMap<T, ValueId> Var2Id;
+  TypedVector<ValueId, var_aliases_type> Id2Vars;
+};
+
+} // namespace psr
diff --git a/include/phasar/Utils/ValueIdMap.h b/include/phasar/Utils/ValueIdMap.h
new file mode 100644
index 0000000000..bce7bd6cf6
--- /dev/null
+++ b/include/phasar/Utils/ValueIdMap.h
@@ -0,0 +1,574 @@
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#ifndef PHASAR_UTILS_VALUEIDMAP_H
+#define PHASAR_UTILS_VALUEIDMAP_H
+
+#include "phasar/Utils/BitSet.h"
+#include "phasar/Utils/Macros.h"
+#include "phasar/Utils/TypeTraits.h"
+
+#include <cassert>
+#include <cstddef>
+#include <cstring>
+#include <initializer_list>
+#include <limits>
+#include <memory>
+#include <memory_resource>
+#include <optional>
+#include <stdexcept>
+#include <type_traits>
+#include <utility>
+
+namespace psr {
+
+/// \brief A dense, partially-populated map keyed by a sequential integer-like
+/// id.
+///
+/// Models a subset of the std::unordered_map / llvm::DenseMap interface for
+/// keys that are dense unsigned integer ids (e.g. enum classes over uint32_t).
+/// Entries are stored in a flat array of uninitialized ValueT storage;
+/// only explicitly inserted entries are ever constructed — there is no upfront
+/// default-construction of the entire value array.
+///
+/// Reallocation moves all live entries via their move constructors and then
+/// destroys the originals in one pass. **Move constructors are assumed to be
+/// nothrow**.
+///
+/// \remarks Partially implemented by Claude Sonnet 4.6
+///
+/// \tparam IdT       Key type. Must satisfy SmallIdType (fits in uint32_t,
+///                   losslessly convertible to/from size_t).
+/// \tparam ValueT    Mapped value type.
+/// \tparam Allocator Allocator whose value_type is ValueT.
+///                   Defaults to std::allocator<ValueT>.
+template <SmallIdType IdT, typename ValueT,
+          typename Allocator = std::allocator<ValueT>>
+class ValueIdMap {
+  using AllocTraits = std::allocator_traits<Allocator>;
+
+public:
+  // ── Types ──────────────────────────────────────────────────────────────────
+
+  using key_type = IdT;
+  using mapped_type = ValueT;
+  using value_type = std::pair<const IdT, ValueT>;
+  using size_type = size_t;
+  using difference_type = ptrdiff_t;
+  using allocator_type = Allocator;
+  using reference = value_type &;
+  using const_reference = const value_type &;
+  using pointer = value_type *;
+  using const_pointer = const value_type *;
+
+  // ── Iterators ──────────────────────────────────────────────────────────────
+
+  /// Forward iterator over present entries. Dereferences to
+  /// std::pair<const IdT, ValueT&> by value; prefer structured bindings
+  /// (`auto [k, v]`) over `auto&` when iterating.
+  template <bool IsConst> class IteratorImpl {
+  public:
+    using MappedRef = std::conditional_t<IsConst, const ValueT &, ValueT &>;
+    using reference = std::pair<const IdT, MappedRef>;
+    using value_type = std::pair<const IdT, ValueT>;
+    using difference_type = ptrdiff_t;
+    using iterator_category = std::forward_iterator_tag;
+
+    constexpr IteratorImpl() noexcept = default;
+
+    /// Implicit conversion iterator → const_iterator.
+    template <bool WasConst>
+      requires(IsConst && !WasConst)
+    constexpr IteratorImpl(const IteratorImpl<WasConst> &Other) noexcept
+        : Map(Other.Map), CurrentKey(Other.CurrentKey) {}
+
+    constexpr reference operator*() const noexcept {
+      return {*CurrentKey, *Map->slot(*CurrentKey)};
+    }
+
+    /// Arrow proxy enabling `it->first` and `it->second`.
+    struct ArrowProxy {
+      reference Ref;
+      constexpr reference *operator->() noexcept { return &Ref; }
+    };
+    constexpr ArrowProxy operator->() const noexcept { return {**this}; }
+
+    constexpr IteratorImpl &operator++() noexcept {
+      CurrentKey = Map->IsSet.findNext(*CurrentKey);
+      return *this;
+    }
+    constexpr IteratorImpl operator++(int) noexcept {
+      auto Ret = *this;
+      ++*this;
+      return Ret;
+    }
+
+    constexpr bool
+    operator==(const IteratorImpl &Other) const noexcept = default;
+
+  private:
+    using MapPtr =
+        std::conditional_t<IsConst, const ValueIdMap *, ValueIdMap *>;
+
+    template <bool> friend class IteratorImpl;
+    friend class ValueIdMap;
+
+    constexpr IteratorImpl(MapPtr Map, std::optional<IdT> Key) noexcept
+        : Map(Map), CurrentKey(Key) {}
+
+    MapPtr Map = nullptr;
+    std::optional<IdT> CurrentKey{};
+  };
+
+  using iterator = IteratorImpl<false>;
+  using const_iterator = IteratorImpl<true>;
+
+  // ── Constructors / destructor ──────────────────────────────────────────────
+
+  /// Default constructor. The allocator is value-initialised.
+  ValueIdMap() noexcept(std::is_nothrow_default_constructible_v<Allocator>) =
+      default;
+
+  /// Constructs an empty map with the given allocator.
+  constexpr explicit ValueIdMap(const allocator_type &A) noexcept(
+      std::is_nothrow_copy_constructible_v<Allocator>)
+      : Alloc(A) {}
+
+  /// Pre-allocates storage for \p InitialCapacity entries without constructing
+  /// any values.
+  explicit ValueIdMap(size_t InitialCapacity,
+                      const allocator_type &A = allocator_type{})
+      : Alloc(A), Capacity(InitialCapacity),
+        Slots(InitialCapacity ? AllocTraits::allocate(Alloc, InitialCapacity)
+                              : nullptr) {
+    IsSet.reserve(InitialCapacity);
+  }
+
+  /// Constructs from an initializer list. \p V need not equal \p ValueT;
+  /// any type constructible to \p ValueT is accepted, avoiding an
+  /// intermediate copy (e.g. string literals when ValueT is std::string).
+  /// Duplicate keys are silently dropped (first occurrence wins).
+  template <typename V = ValueT>
+    requires std::is_constructible_v<ValueT, const V &>
+  ValueIdMap(std::initializer_list<std::pair<const IdT, V>> Init,
+             const allocator_type &A = allocator_type{})
+      : ValueIdMap(Init.begin(), Init.end(), A) {}
+
+  /// Constructs from an iterator range \p [First, Last).
+  /// Duplicate keys are silently dropped (first occurrence wins).
+  template <typename InputIt>
+  ValueIdMap(InputIt First, InputIt Last,
+             const allocator_type &A = allocator_type{})
+      : ValueIdMap(A) {
+    if constexpr (std::is_base_of_v<std::random_access_iterator_tag,
+                                    typename std::iterator_traits<
+                                        InputIt>::iterator_category>) {
+      reserve(static_cast<size_t>(std::distance(First, Last)));
+    }
+    for (; First != Last; ++First) {
+      try_emplace(First->first, First->second);
+    }
+  }
+
+  /// Copy constructor. The allocator is obtained via
+  /// allocator_traits::select_on_container_copy_construction.
+  ValueIdMap(const ValueIdMap &Other)
+      : ValueIdMap(Other, AllocTraits::select_on_container_copy_construction(
+                              Other.Alloc)) {}
+
+  /// Copy constructor with explicit allocator.
+  ValueIdMap(const ValueIdMap &Other, const allocator_type &A)
+      : Alloc(A), IsSet(Other.IsSet), Capacity(Other.Capacity) {
+    if (!Capacity) {
+      return;
+    }
+    Slots = AllocTraits::allocate(Alloc, Capacity);
+    try {
+      Other.IsSet.foreach ([&](IdT Key) {
+        AllocTraits::construct(Alloc, slot(Key), *Other.slot(Key));
+      });
+    } catch (...) {
+      freeStorage();
+      IsSet.clear();
+      throw;
+    }
+  }
+
+  /// Move constructor. The allocator is move-constructed from \p Other.
+  ValueIdMap(ValueIdMap &&Other) noexcept
+      : Alloc(std::move(Other.Alloc)), IsSet(std::move(Other.IsSet)),
+        Capacity(std::exchange(Other.Capacity, 0)),
+        Slots(std::exchange(Other.Slots, nullptr)) {}
+
+  /// Move constructor with explicit allocator.
+  ///
+  /// If the supplied allocator compares equal to Other's allocator the
+  /// storage is stolen in O(1); otherwise each live element is move-constructed
+  /// individually using the supplied allocator.
+  ValueIdMap(ValueIdMap &&Other, const allocator_type &A) : Alloc(A) {
+    if (Alloc == Other.Alloc) {
+      stealFrom(Other);
+    } else {
+      // Allocators differ: move elements individually into fresh storage.
+      IsSet = Other.IsSet;
+      if (Other.Capacity) {
+        Capacity = Other.Capacity;
+        Slots = AllocTraits::allocate(Alloc, Capacity);
+        Other.IsSet.foreach ([&](IdT Key) {
+          ValueT *Src = Other.slot(Key);
+          AllocTraits::construct(Alloc, slot(Key), std::move(*Src));
+          AllocTraits::destroy(Other.Alloc, Src);
+        });
+        Other.IsSet.clear();
+        Other.freeStorage();
+      }
+    }
+  }
+
+  /// Copy assignment. Propagates the allocator when
+  /// allocator_traits::propagate_on_container_copy_assignment is true.
+  ValueIdMap &operator=(const ValueIdMap &Other) {
+    if (this == &Other) {
+      return *this;
+    }
+    clear();
+    if constexpr (AllocTraits::propagate_on_container_copy_assignment::value) {
+      if (Alloc != Other.Alloc) {
+        freeStorage();
+        Alloc = Other.Alloc;
+      }
+    }
+    reallocAtLeast(Other.Capacity);
+    IsSet = Other.IsSet;
+    Other.IsSet.foreach ([&](IdT Key) {
+      AllocTraits::construct(Alloc, slot(Key), *Other.slot(Key));
+    });
+    return *this;
+  }
+
+  /// Replaces the contents with those of \p Init.
+  /// Duplicate keys are silently dropped (first occurrence wins).
+  template <typename V = ValueT>
+    requires std::is_constructible_v<ValueT, const V &>
+  ValueIdMap &operator=(std::initializer_list<std::pair<const IdT, V>> Init) {
+    clear();
+    reserve(Init.size());
+    for (auto &&[Key, Val] : Init) {
+      try_emplace(Key, Val);
+    }
+    return *this;
+  }
+
+  /// Move assignment. Propagates the allocator when
+  /// allocator_traits::propagate_on_container_move_assignment is true.
+  ValueIdMap &operator=(ValueIdMap &&Other) noexcept(
+      AllocTraits::propagate_on_container_move_assignment::value ||
+      AllocTraits::is_always_equal::value) {
+    if (this == &Other) {
+      return *this;
+    }
+    clear();
+    if constexpr (AllocTraits::propagate_on_container_move_assignment::value) {
+      freeStorage();
+      Alloc = std::move(Other.Alloc);
+      stealFrom(Other);
+    } else if (Alloc == Other.Alloc) {
+      freeStorage();
+      stealFrom(Other);
+    } else {
+      // Unequal allocators, no propagation: move elements individually.
+      reallocAtLeast(Other.Capacity);
+      IsSet = Other.IsSet;
+      Other.IsSet.foreach ([&](IdT Key) {
+        ValueT *Src = Other.slot(Key);
+        AllocTraits::construct(Alloc, slot(Key), std::move(*Src));
+        AllocTraits::destroy(Other.Alloc, Src);
+      });
+      Other.IsSet.clear();
+      Other.freeStorage();
+    }
+    return *this;
+  }
+
+  ~ValueIdMap() {
+    clear();
+    freeStorage();
+  }
+
+  /// Returns the allocator associated with this container.
+  // NOLINTNEXTLINE(readability-identifier-naming) -- STL API name
+  [[nodiscard]] constexpr allocator_type get_allocator() const noexcept {
+    return Alloc;
+  }
+
+  /// Swap. Propagates allocators when
+  /// allocator_traits::propagate_on_container_swap is true; otherwise the
+  /// behaviour is undefined if the two allocators are not equal (per the
+  /// AllocatorAwareContainer requirement).
+  void swap(ValueIdMap &Other) noexcept(
+      (!AllocTraits::propagate_on_container_swap::value ||
+       std::is_nothrow_swappable_v<Allocator>) &&
+      std::is_nothrow_swappable_v<BitSet<IdT>>) {
+    if constexpr (AllocTraits::propagate_on_container_swap::value) {
+      std::swap(Alloc, Other.Alloc);
+    }
+    std::swap(Slots, Other.Slots);
+    std::swap(Capacity, Other.Capacity);
+    std::swap(IsSet, Other.IsSet);
+  }
+  friend void swap(ValueIdMap &Lhs,
+                   ValueIdMap &Rhs) noexcept(noexcept(Lhs.swap(Rhs))) {
+    Lhs.swap(Rhs);
+  }
+
+  friend bool operator==(const ValueIdMap &Lhs, const ValueIdMap &Rhs) noexcept(
+      noexcept(std::declval<const ValueT &>() ==
+               std::declval<const ValueT &>())) {
+    if (Lhs.IsSet != Rhs.IsSet) {
+      return false;
+    }
+    for (auto [Key, Val] : Lhs) {
+      if (*Rhs.slot(Key) != Val) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  // ── Capacity ───────────────────────────────────────────────────────────────
+
+  /// Ensures storage for at least \p N entries without constructing any values.
+  void reserve(size_t N) {
+    if (N > Capacity) {
+      IsSet.reserve(N);
+      grow(N);
+    }
+  }
+
+  /// Returns the number of entries currently present.
+  [[nodiscard]] constexpr size_t size() const noexcept { return IsSet.size(); }
+  [[nodiscard]] constexpr bool empty() const noexcept { return IsSet.empty(); }
+  /// Returns the maximum number of elements the container can hold.
+  /// Capped at INT_MAX because llvm::BitVector (which backs BitSet) uses
+  /// an int-sized bit count internally.
+  // NOLINTNEXTLINE(readability-identifier-naming) -- STL API name
+  [[nodiscard]] constexpr size_type max_size() const noexcept {
+    return std::min(AllocTraits::max_size(Alloc),
+                    size_type(std::numeric_limits<int>::max()));
+  }
+
+  // ── Lookup ─────────────────────────────────────────────────────────────────
+
+  [[nodiscard]] constexpr bool contains(IdT Key) const noexcept {
+    return IsSet.contains(Key);
+  }
+  [[nodiscard]] constexpr size_t count(IdT Key) const noexcept {
+    return contains(Key) ? 1 : 0;
+  }
+
+  [[nodiscard]] constexpr iterator find(IdT Key) noexcept {
+    return contains(Key) ? iterator(this, Key) : end();
+  }
+  [[nodiscard]] constexpr const_iterator find(IdT Key) const noexcept {
+    return contains(Key) ? const_iterator(this, Key) : end();
+  }
+
+  /// Returns a reference to the value for \p Key.
+  /// \throws std::out_of_range if \p Key is not present.
+  [[nodiscard]] constexpr ValueT &at(IdT Key) {
+    if (!contains(Key)) {
+      throw std::out_of_range("ValueIdMap::at: key not found");
+    }
+    return *slot(Key);
+  }
+  [[nodiscard]] constexpr const ValueT &at(IdT Key) const {
+    if (!contains(Key)) {
+      throw std::out_of_range("ValueIdMap::at: key not found");
+    }
+    return *slot(Key);
+  }
+
+  // ── Element access ─────────────────────────────────────────────────────────
+
+  /// Returns a reference to the value for \p Key, default-constructing it if
+  /// absent (same semantics as std::unordered_map::operator[]).
+  ValueT &operator[](IdT Key) { return try_emplace(Key).first->second; }
+
+  // ── Modifiers ─────────────────────────────────────────────────────────────
+
+  /// Constructs a value from \p Args for \p Key if not already present.
+  /// Returns {iterator-to-entry, true} on insertion and
+  /// {iterator-to-existing-entry, false} otherwise.
+  template <typename... ArgsT>
+  std::pair<iterator, bool> try_emplace(IdT Key, ArgsT &&...Args) {
+    if (!inbounds(Key)) {
+      grow(std::max(size_t(Key) + 1, Capacity ? Capacity * 2 : 8));
+    } else if (IsSet.contains(Key)) {
+      return {iterator(this, Key), false};
+    }
+    AllocTraits::construct(Alloc, slot(Key), PSR_FWD(Args)...);
+    IsSet.insert(Key);
+    return {iterator(this, Key), true};
+  }
+
+  std::pair<iterator, bool> insert(value_type Val) {
+    return try_emplace(Val.first, std::move(Val.second));
+  }
+
+  /// Inserts or replaces the entry for \p Key with \p Obj.
+  template <typename M>
+  // NOLINTNEXTLINE(readability-identifier-naming) -- STL API name
+  std::pair<iterator, bool> insert_or_assign(IdT Key, M &&Obj) {
+    if (IsSet.contains(Key)) {
+      *slot(Key) = std::forward<M>(Obj);
+      return {iterator(this, Key), false};
+    }
+    return try_emplace(Key, std::forward<M>(Obj));
+  }
+
+  /// Removes the entry for \p Key. Returns true if an entry was present.
+  bool erase(IdT Key) noexcept {
+    if (!IsSet.tryErase(Key)) {
+      return false;
+    }
+    AllocTraits::destroy(Alloc, slot(Key));
+    return true;
+  }
+
+  /// Removes the entry pointed to by \p It and returns an iterator to the
+  /// next entry.
+  iterator erase(const_iterator It) noexcept {
+    IdT Key = It->first;
+    ++It;
+    IsSet.erase(Key);
+    AllocTraits::destroy(Alloc, slot(Key));
+    return iterator(this, It.CurrentKey);
+  }
+
+  /// Destroys all present entries without releasing the allocated storage.
+  void clear() noexcept {
+    if constexpr (!std::is_trivially_destructible_v<ValueT>) {
+      IsSet.foreach ([&](IdT Key) { AllocTraits::destroy(Alloc, slot(Key)); });
+    }
+    IsSet.clear();
+  }
+
+  // ── Iteration ─────────────────────────────────────────────────────────────
+
+  [[nodiscard]] constexpr iterator begin() noexcept {
+    return {this, IsSet.findFirst()};
+  }
+  [[nodiscard]] constexpr iterator end() noexcept {
+    return {this, std::nullopt};
+  }
+  [[nodiscard]] constexpr const_iterator begin() const noexcept {
+    return {this, IsSet.findFirst()};
+  }
+  [[nodiscard]] constexpr const_iterator end() const noexcept {
+    return {this, std::nullopt};
+  }
+  [[nodiscard]] constexpr const_iterator cbegin() const noexcept {
+    return begin();
+  }
+  [[nodiscard]] constexpr const_iterator cend() const noexcept { return end(); }
+
+private:
+  // ── Private helpers ────────────────────────────────────────────────────────
+
+  [[nodiscard]] constexpr ValueT *slot(IdT Key) noexcept {
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
+    return Slots + size_t(Key);
+  }
+  [[nodiscard]] constexpr const ValueT *slot(IdT Key) const noexcept {
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
+    return Slots + size_t(Key);
+  }
+
+  [[nodiscard]] constexpr bool inbounds(IdT Key) const noexcept {
+    return size_t(Key) < Capacity;
+  }
+
+  /// Frees current storage and allocates a fresh array of \p N elements.
+  /// No-op if N <= Capacity.
+  constexpr void reallocAtLeast(size_t N) {
+    if (N > Capacity) {
+      freeStorage();
+      Slots = AllocTraits::allocate(Alloc, N);
+      Capacity = N;
+    }
+  }
+
+  /// Deallocates the storage array if non-null and resets Slots/Capacity.
+  constexpr void freeStorage() noexcept {
+    if (Slots) {
+      AllocTraits::deallocate(Alloc, Slots, Capacity);
+      Slots = nullptr;
+      Capacity = 0;
+    }
+  }
+
+  /// Takes ownership of Other's storage (Other must have been cleared first).
+  void stealFrom(ValueIdMap &Other) noexcept {
+    IsSet = std::move(Other.IsSet);
+    Capacity = std::exchange(Other.Capacity, 0);
+    Slots = std::exchange(Other.Slots, nullptr);
+  }
+
+  void grow(size_t NewCap) {
+    assert(NewCap > Capacity);
+    ValueT *New = AllocTraits::allocate(Alloc, NewCap);
+
+    if constexpr (IsTriviallyRelocatable<ValueT>) {
+      // Trivially relocatable: a flat memcpy of all used slots suffices.
+      // Uninitialized slots contain indeterminate bytes, which is safe to copy.
+      // No per-element construction or destruction is needed.
+      if (Slots) {
+        memcpy(New, Slots, Capacity * sizeof(ValueT));
+      }
+    } else {
+      // Move-construct each live entry into new storage and destroy the
+      // original in one pass. Assumes nothrow move construction; types with
+      // throwing moves are not supported.
+      IsSet.foreach ([&](IdT Key) {
+        ValueT *Src = slot(Key);
+        AllocTraits::construct(Alloc, New + size_t(Key), // NOLINT
+                               std::move(*Src));
+        AllocTraits::destroy(Alloc, Src);
+      });
+    }
+
+    if (Slots) {
+      AllocTraits::deallocate(Alloc, Slots, Capacity);
+    }
+    Slots = New;
+    Capacity = NewCap;
+  }
+
+  // ── Data members ───────────────────────────────────────────────────────────
+
+  // Alloc must be declared first so it is available for deallocation when
+  // other members are destroyed. [[no_unique_address]] enables the empty-base
+  // optimisation for stateless allocators such as std::allocator.
+  [[no_unique_address]] Allocator Alloc{};
+  // IsSet must be declared before Slots so that if its copy constructor throws
+  // during ValueIdMap's copy constructor, Slots has not yet been allocated.
+  BitSet<IdT> IsSet;
+  size_t Capacity = 0;
+  ValueT *Slots = nullptr;
+};
+
+namespace pmr {
+template <SmallIdType IdT, typename ValueT>
+using ValueIdMap =
+    psr::ValueIdMap<IdT, ValueT, std::pmr::polymorphic_allocator<ValueT>>;
+} // namespace pmr
+
+} // namespace psr
+
+#endif // PHASAR_UTILS_VALUEIDMAP_H
diff --git a/lib/PhasarLLVM/DataFlow/IfdsIde/IfdsIde.cppm b/lib/PhasarLLVM/DataFlow/IfdsIde/IfdsIde.cppm
index 94a9f38607..22bbc7d9e2 100644
--- a/lib/PhasarLLVM/DataFlow/IfdsIde/IfdsIde.cppm
+++ b/lib/PhasarLLVM/DataFlow/IfdsIde/IfdsIde.cppm
@@ -1,7 +1,6 @@
 module;
 
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/DefaultAliasAwareIDEProblem.h"
-#include "phasar/PhasarLLVM/DataFlow/IfdsIde/LibCSummary.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/ExtendedTaintAnalysis/AbstractMemoryLocation.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/ExtendedTaintAnalysis/AbstractMemoryLocationFactory.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/ExtendedTaintAnalysis/AllSanitized.h"
@@ -106,7 +105,6 @@ using psr::JoinLatticeTraits;
 using psr::to_string;
 using psr::operator<<;
 using psr::CSTDFILEIOTypeStateDescription;
-using psr::getLibCSummary;
 using psr::IDETypeStateAnalysis;
 using psr::OpenSSLEVPKDFCTXDescription;
 using psr::OpenSSLEVPKDFCTXState;
@@ -125,15 +123,6 @@ export namespace std {
 using std::hash;
 } // namespace std
 
-export namespace psr::library_summary {
-using psr::library_summary::DataFlowFact;
-using psr::library_summary::FunctionDataFlowFacts;
-using psr::library_summary::LLVMFunctionDataFlowFacts;
-using psr::library_summary::Parameter;
-using psr::library_summary::readFromFDFF;
-using psr::library_summary::ReturnValue;
-} // namespace psr::library_summary
-
 export namespace llvm {
 using llvm::DenseMapInfo;
 } // namespace llvm
diff --git a/lib/PhasarLLVM/DataFlow/IfdsIde/LLVMFunctionDataFlowFacts.cpp b/lib/PhasarLLVM/DataFlow/IfdsIde/LLVMFunctionDataFlowFacts.cpp
deleted file mode 100644
index fdd60c7271..0000000000
--- a/lib/PhasarLLVM/DataFlow/IfdsIde/LLVMFunctionDataFlowFacts.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "phasar/PhasarLLVM/DataFlow/IfdsIde/LLVMFunctionDataFlowFacts.h"
-
-using namespace psr;
-using namespace psr::library_summary;
-
-LLVMFunctionDataFlowFacts
-library_summary::readFromFDFF(const FunctionDataFlowFacts &Fdff,
-                              const LLVMProjectIRDB &Irdb) {
-  LLVMFunctionDataFlowFacts Llvmfdff;
-  Llvmfdff.LLVMFdff.reserve(Fdff.size());
-
-  for (const auto &It : Fdff) {
-    if (const llvm::Function *Fun = Irdb.getFunction(It.first())) {
-      Llvmfdff.LLVMFdff.try_emplace(Fun, It.second);
-    }
-  }
-  return Llvmfdff;
-}
diff --git a/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSTaintAnalysis.cpp b/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSTaintAnalysis.cpp
index 3636fa346c..9f7424f02d 100644
--- a/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSTaintAnalysis.cpp
+++ b/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSTaintAnalysis.cpp
@@ -16,13 +16,13 @@
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/CFLFieldSensIFDSProblem.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/LLVMFlowFunctions.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/LLVMZeroValue.h"
-#include "phasar/PhasarLLVM/DataFlow/IfdsIde/LibCSummary.h"
 #include "phasar/PhasarLLVM/Domain/LLVMAnalysisDomain.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h"
 #include "phasar/PhasarLLVM/TaintConfig/TaintConfigUtilities.h"
 #include "phasar/PhasarLLVM/Utils/DataFlowAnalysisType.h"
 #include "phasar/PhasarLLVM/Utils/LLVMIRToSrc.h"
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
+#include "phasar/Utils/LibCSummary.h"
 #include "phasar/Utils/Logger.h"
 
 #include "llvm/ADT/ArrayRef.h"
@@ -52,7 +52,9 @@ IFDSTaintAnalysis::IFDSTaintAnalysis(const LLVMProjectIRDB *IRDB,
     : IFDSTabulationProblem(IRDB, std::move(EntryPoints), createZeroValue()),
       Config(Config), PT(PT), TaintMainArgs(TaintMainArgs),
       EnableStrongUpdateStore(EnableStrongUpdateStore),
-      Llvmfdff(library_summary::readFromFDFF(getLibCSummary(), *IRDB)) {
+      Llvmfdff(library_summary::readFromFDFF(
+          getLibCSummary(),
+          [IRDB](llvm::StringRef FName) { return IRDB->getFunction(FName); })) {
   assert(Config != nullptr);
   assert(PT);
 }
diff --git a/lib/PhasarLLVM/HelperAnalyses.cpp b/lib/PhasarLLVM/HelperAnalyses.cpp
index 355d77cdc8..6897c6980e 100644
--- a/lib/PhasarLLVM/HelperAnalyses.cpp
+++ b/lib/PhasarLLVM/HelperAnalyses.cpp
@@ -1,10 +1,15 @@
 #include "phasar/PhasarLLVM/HelperAnalyses.h"
 
+#include "phasar/PhasarLLVM/ControlFlow/EntryFunctionUtils.h"
+#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCallGraphBuilder.h"
 #include "phasar/PhasarLLVM/ControlFlow/LLVMBasedICFG.h"
+#include "phasar/PhasarLLVM/ControlFlow/Resolver/RTAResolver.h"
 #include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasSet.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasSetData.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h"
 #include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
+#include "phasar/Pointer/AliasAnalysisType.h"
 
 #include <memory>
 #include <string>
@@ -29,7 +34,7 @@ HelperAnalyses::HelperAnalyses(std::string IRFile,
                                HelperAnalysisConfig Config) noexcept
     : IRFile(std::move(IRFile)),
       PrecomputedPTS(std::move(Config.PrecomputedPTS)), PTATy(Config.PTATy),
-      AllowLazyPTS(Config.AllowLazyPTS),
+      UFAATy(Config.UFAATy), AllowLazyPTS(Config.AllowLazyPTS),
       PrecomputedCG(std::move(Config.PrecomputedCG)),
       EntryPoints(std::move(EntryPoints)), CGTy(Config.CGTy),
       SoundnessLevel(Config.SoundnessLevel),
@@ -68,16 +73,28 @@ LLVMProjectIRDB &HelperAnalyses::getProjectIRDB() {
   return *IRDB;
 }
 
-LLVMAliasSet &HelperAnalyses::getAliasInfo() {
+LLVMAliasInfoRef HelperAnalyses::getAliasInfo() {
   if (!PT) {
     if (PrecomputedPTS.has_value()) {
       PT = std::make_unique<LLVMAliasSet>(&getProjectIRDB(), *PrecomputedPTS);
+    } else if (PTATy == AliasAnalysisType::UnionFind) {
+      auto &IRDB = getProjectIRDB();
+      auto VTP = LLVMVFTableProvider(IRDB);
+      auto Res = RTAResolver(&IRDB, &VTP, &getTypeHierarchy());
+      const auto BaseCG = buildLLVMBasedCallGraph(
+          IRDB, Res, getEntryFunctions(IRDB, EntryPoints));
+      PT = std::make_unique<LLVMUnionFindAliasSet>(
+          &getProjectIRDB(), BaseCG,
+          LLVMUnionFindAliasSet::Config{
+              .AType = UFAATy,
+              .ALocality = LLVMUnionFindAliasSet::AnalysisLocality::Global,
+          });
     } else {
       PT = std::make_unique<LLVMAliasSet>(&getProjectIRDB(), AllowLazyPTS,
                                           PTATy);
     }
   }
-  return *PT;
+  return PT.get();
 }
 
 DIBasedTypeHierarchy &HelperAnalyses::getTypeHierarchy() {
@@ -94,7 +111,7 @@ LLVMBasedICFG &HelperAnalyses::getICFG() {
     } else {
       ICF = std::make_unique<LLVMBasedICFG>(
           &getProjectIRDB(), CGTy, std::move(EntryPoints), &getTypeHierarchy(),
-          needsAliasInfo(CGTy) ? &getAliasInfo() : nullptr, SoundnessLevel,
+          needsAliasInfo(CGTy) ? getAliasInfo() : nullptr, SoundnessLevel,
           AutoGlobalSupport);
     }
   }
diff --git a/lib/PhasarLLVM/Pointer/AliasAnalysisView.cpp b/lib/PhasarLLVM/Pointer/AliasAnalysisView.cpp
index 0ecf705e40..31fba0689c 100644
--- a/lib/PhasarLLVM/Pointer/AliasAnalysisView.cpp
+++ b/lib/PhasarLLVM/Pointer/AliasAnalysisView.cpp
@@ -1,6 +1,9 @@
 #include "phasar/PhasarLLVM/Pointer/AliasAnalysisView.h"
 
 #include "phasar/Config/phasar-config.h" // for PHASAR_USE_SVF
+#include "phasar/Pointer/AliasAnalysisType.h"
+
+#include "llvm/Support/ErrorHandling.h"
 
 #ifdef PHASAR_USE_SVF
 #include "SVF/SVFBasedAliasAnalysis.h"
@@ -21,6 +24,10 @@ AliasAnalysisView::create(LLVMProjectIRDB &IRDB, bool UseLazyEvaluation,
   case AliasAnalysisType::SVFVFS:
     return createSVFVFSAnalysis(IRDB);
 #endif
+  case AliasAnalysisType::UnionFind:
+    llvm::report_fatal_error(
+        "Cannot use AliasAnalysisType::UnionFind with LLVMAliasSet. Use "
+        "LLVMUnionFindAliasSet instead!");
   default:
     return createLLVMBasedAnalysis(IRDB, UseLazyEvaluation, PATy);
   }
diff --git a/lib/PhasarLLVM/Pointer/CMakeLists.txt b/lib/PhasarLLVM/Pointer/CMakeLists.txt
index 2825505ba5..1736a41820 100644
--- a/lib/PhasarLLVM/Pointer/CMakeLists.txt
+++ b/lib/PhasarLLVM/Pointer/CMakeLists.txt
@@ -6,6 +6,7 @@ add_phasar_library(phasar_llvm_pointer
   LINKS
     phasar_utils
     phasar_pointer
+    phasar_controlflow
     phasar_llvm_utils
     phasar_llvm_db
 
diff --git a/lib/PhasarLLVM/Pointer/FilteredAliasesUtils.h b/lib/PhasarLLVM/Pointer/FilteredAliasesUtils.h
index f227673121..a41cd73455 100644
--- a/lib/PhasarLLVM/Pointer/FilteredAliasesUtils.h
+++ b/lib/PhasarLLVM/Pointer/FilteredAliasesUtils.h
@@ -1,22 +1,20 @@
 #pragma once
 
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalAlias.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/Support/Compiler.h"
 
-LLVM_LIBRARY_VISIBILITY inline const llvm::Function *
-getFunction(const llvm::Value *V) {
-  if (const auto *Inst = llvm::dyn_cast<llvm::Instruction>(V)) {
-    return Inst->getFunction();
-  }
-  if (const auto *Arg = llvm::dyn_cast<llvm::Argument>(V)) {
-    return Arg->getParent();
-  }
-  return nullptr;
-}
-
 [[nodiscard]] LLVM_LIBRARY_VISIBILITY inline bool
 isConstantGlobalValue(const llvm::GlobalValue *GlobV) {
   if (const auto *Glob = llvm::dyn_cast<llvm::GlobalVariable>(GlobV)) {
diff --git a/lib/PhasarLLVM/Pointer/FilteredLLVMAliasIterator.cpp b/lib/PhasarLLVM/Pointer/FilteredLLVMAliasIterator.cpp
index 28762fa746..e1e82ccc9b 100644
--- a/lib/PhasarLLVM/Pointer/FilteredLLVMAliasIterator.cpp
+++ b/lib/PhasarLLVM/Pointer/FilteredLLVMAliasIterator.cpp
@@ -1,6 +1,7 @@
 #include "phasar/PhasarLLVM/Pointer/FilteredLLVMAliasIterator.h"
 
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h"
+#include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
 
 #include "llvm/IR/Constants.h"
 
diff --git a/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp b/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp
new file mode 100644
index 0000000000..63ebf47d58
--- /dev/null
+++ b/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp
@@ -0,0 +1,714 @@
+#include "phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h"
+
+#include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
+#include "phasar/PhasarLLVM/Utils/LLVMFunctionDataFlowFacts.h"
+#include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
+#include "phasar/Pointer/PointerAssignmentGraph.h"
+#include "phasar/Utils/BitSet.h"
+#include "phasar/Utils/LibCSummary.h"
+#include "phasar/Utils/MapUtils.h"
+#include "phasar/Utils/ValueCompressor.h"
+
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/DataLayout.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/IntrinsicInst.h"
+#include "llvm/IR/Operator.h"
+
+#include <concepts>
+#include <functional>
+
+using namespace psr;
+using namespace psr::pag;
+using LLVMPBStrategyRef = pag::PBStrategyRef<LLVMPAGDomain>;
+
+static_assert(detail::IsPointerWithAtleastOneFreeLowBit<PAGVariable>);
+
+std::string psr::to_string(PAGVariable Var) {
+  auto Ret = llvmIRToString(Var.get());
+  if (Var.isReturnVariable()) {
+    Ret += ".<ret>";
+  }
+  return Ret;
+}
+
+namespace {
+
+struct GlobalCache {
+  const llvm::DataLayout &DL; // NOLINT
+  // Due to the recursion in getOrCreateGCacheEntry, we need pointer stability
+  std::unordered_map<const llvm::Constant *, llvm::SmallVector<ValueId, 1>>
+      Cache{};
+
+  [[nodiscard]] llvm::ArrayRef<ValueId> getOrCreateGCacheEntry(
+      LLVMPBStrategyRef Strategy, const llvm::Constant *Const,
+      std::invocable<const llvm::Value *, LLVMPBStrategyRef> auto GetVariable) {
+    if (definitelyContainsNoPointer(Const)) {
+      return {};
+    }
+
+    auto [It, Inserted] = Cache.try_emplace(Const);
+    if (!Inserted) {
+      return It->second;
+    }
+
+    auto &Vec = It->second;
+
+    // We do not care about null here
+    if (llvm::isa<llvm::ConstantPointerNull>(Const)) {
+      return {};
+    }
+
+    if (const auto *CGep = llvm::dyn_cast<llvm::GEPOperator>(Const)) {
+      // TODO: Properly handle constant GEPs
+      return getOrCreateGCacheEntry(
+          Strategy, llvm::cast<llvm::Constant>(CGep->getPointerOperand()),
+          GetVariable);
+    }
+
+    if (Const->getType()->isPointerTy()) {
+      Vec.push_back(GetVariable(Const, Strategy));
+
+      return Vec;
+    }
+
+    // TODO: Get rid of the recursion
+
+    if (const auto *Arr = llvm::dyn_cast<llvm::ConstantAggregate>(Const)) {
+      if (Arr->getType()->isArrayTy() &&
+          definitelyContainsNoPointer(Arr->getType()->getArrayElementType())) {
+        return {};
+      }
+
+      size_t ArrayLen = Arr->getNumOperands();
+      for (size_t I = 0; I < ArrayLen; ++I) {
+        auto *Elem = llvm::cast<llvm::Constant>(
+            Arr->getAggregateElement(I)->stripPointerCastsAndAliases());
+        auto ElemVars = getOrCreateGCacheEntry(Strategy, Elem, GetVariable);
+        Vec.append(ElemVars.begin(), ElemVars.end());
+      }
+      return Vec;
+    }
+
+    // TODO: more
+
+    return Vec;
+  }
+};
+
+struct PAGMappedLibrarySummary {
+  const library_summary::LLVMFunctionDataFlowFacts &Facts; // NOLINT
+
+  bool
+  mapFunctionSummary(const llvm::Function *Fun,
+                     std::invocable<uint32_t, library_summary::DataFlowFact,
+                                    pag::Edge> auto AddEdge) const {
+    const auto *LibSum = Facts.getFactsForFunctionOrNull(Fun);
+    if (!LibSum) {
+      return false;
+    }
+
+    const size_t NumParams = Fun->arg_size();
+
+    for (const auto &[ParamFact, Pts] : *LibSum) {
+      if (ParamFact >= NumParams ||
+          !Fun->getArg(ParamFact)->getType()->isPointerTy()) {
+        continue;
+      }
+
+      for (const auto &DestFact : Pts) {
+        auto E = DestFact.dyn_cast<library_summary::Parameter>()
+                     ? pag::Edge(pag::StorePOI{})
+                     : pag::Assign{};
+        std::invoke(AddEdge, ParamFact, DestFact, E);
+      }
+    }
+    return true;
+  }
+};
+
+} // namespace
+
+struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
+  const llvm::DataLayout &DL;           // NOLINT
+  ValueCompressor<v_t> &VC;             // NOLINT
+  const PAGMappedLibrarySummary &MLSum; // NOLINT
+
+  llvm::DenseMap<ValueId, ValueId> TheOneLoad{};
+  BitSet<ValueId> OnlyIncomingStoresAndOutgoingLoads{};
+  TypedVector<ValueId, llvm::SmallDenseMap<ValueId, Edge, 2>> IncomingStores{};
+  TypedVector<ValueId, llvm::SmallDenseSet<ValueId, 2>> OutgoingLoads{};
+  llvm::DenseMap<const llvm::Value *, llvm::SmallDenseMap<int64_t, ValueId>>
+      LocalGeps{};
+
+  [[nodiscard]] ValueId getVariable(PAGVariable V, LLVMPBStrategyRef Strategy) {
+    auto [Id, Inserted] = VC.insert(V);
+    if (Inserted) {
+      OnlyIncomingStoresAndOutgoingLoads.insert(Id);
+      IncomingStores.emplace_back();
+      OutgoingLoads.emplace_back();
+      Strategy.onAddValue(V, Id);
+    }
+
+    return Id;
+  }
+
+  void addAllIncomingStores(LLVMPBStrategyRef Strategy, ValueId To,
+                            llvm::SmallDenseMap<ValueId, Edge, 2> &Froms) {
+    for (auto [From, E] : Froms) {
+      Strategy.onAddEdge(From, To, E, nullptr);
+    }
+    Froms.clear();
+  }
+  void addAllOutgoingLoads(LLVMPBStrategyRef Strategy, ValueId From,
+                           llvm::SmallDenseSet<ValueId, 2> &Tos) {
+    for (auto To : Tos) {
+      Strategy.onAddEdge(From, To, Load{}, nullptr);
+    }
+    Tos.clear();
+  }
+
+  void eraseFromSimpleStoreLoad(LLVMPBStrategyRef Strategy, ValueId VId) {
+    if (OnlyIncomingStoresAndOutgoingLoads.tryErase(VId)) {
+      addAllIncomingStores(Strategy, VId, IncomingStores[VId]);
+      addAllOutgoingLoads(Strategy, VId, OutgoingLoads[VId]);
+    }
+  }
+
+  void addEdge(LLVMPBStrategyRef Strategy, ValueId From, ValueId To, Edge E,
+               const llvm::Instruction *AtInstruction) {
+    if (!E.isa<Store, StorePOI>()) {
+      eraseFromSimpleStoreLoad(Strategy, To);
+    } else if (OnlyIncomingStoresAndOutgoingLoads.contains(To)) {
+      eraseFromSimpleStoreLoad(Strategy, From);
+
+      // We delay store edges
+      IncomingStores[To].try_emplace(From, E);
+      return;
+    }
+
+    if (!E.isa<Load>()) {
+      eraseFromSimpleStoreLoad(Strategy, From);
+    } else if (OnlyIncomingStoresAndOutgoingLoads.contains(From)) {
+      eraseFromSimpleStoreLoad(Strategy, To);
+      // We delay load edges
+      OutgoingLoads[From].insert(To);
+      return;
+    }
+
+    Strategy.onAddEdge(From, To, E, AtInstruction);
+  }
+
+  void initializeGlobals(const LLVMProjectIRDB &IRDB,
+                         LLVMPBStrategyRef Strategy) {
+    GlobalCache GCache{IRDB.getModule()->getDataLayout()};
+
+    for (const auto &Glob : IRDB.getModule()->globals()) {
+      if (definitelyContainsNoPointer(Glob.getValueType())) {
+        continue;
+      }
+
+      if (Glob.hasInitializer()) {
+        initializeGlobal(GCache, Strategy, Glob);
+      }
+    }
+  }
+
+  void initializeGlobal(GlobalCache &GCache, LLVMPBStrategyRef Strategy,
+                        const llvm::GlobalVariable &Glob) {
+    auto GlobObj = getVariable(&Glob, Strategy);
+    auto Stores = GCache.getOrCreateGCacheEntry(
+        Strategy, Glob.getInitializer(),
+        [this](const llvm::Value *V, LLVMPBStrategyRef Strategy) {
+          return getVariable(V, Strategy);
+        });
+
+    for (auto Src : Stores) {
+      // NOTE: We don't consider this a POI for now; probably, that's fine
+      addEdge(Strategy, Src, GlobObj, Store{}, nullptr);
+    }
+  }
+
+  void initializeFunctions(const LLVMProjectIRDB &IRDB,
+                           LLVMPBStrategyRef Strategy) {
+    // XXX: Skip functions that have been proven unreachable previously
+
+    for (const auto *Fun : IRDB.getAllFunctions()) {
+      if (!Fun->isDeclaration()) {
+        initializeFun(Strategy, *Fun);
+      }
+    }
+
+    addDelayedEdges(Strategy);
+  }
+
+  void initializeFun(LLVMPBStrategyRef Strategy, const llvm::Function &Fun) {
+    // XXX: RPO Order to profit from OTF-merged values
+    for (const auto &BB : Fun) {
+      propagateBB(Strategy, BB);
+    }
+  }
+
+  void addDelayedEdges(LLVMPBStrategyRef Strategy) {
+    OnlyIncomingStoresAndOutgoingLoads.foreach ([this, &Strategy](auto VId) {
+      // TODO: Is this condition correct?
+      const bool NeedsStoreSafetyFallback =
+          OutgoingLoads[VId].empty() &&
+          llvm::any_of(VC.id2vars(VId), [](PAGVariable Var) {
+            return Var.isReturnVariable() ||
+                   isAddressTakenVariable(Var.valueOrNull());
+          });
+
+      for (auto [IncStore, _] : IncomingStores[VId]) {
+        for (auto OutLoad : OutgoingLoads[VId]) {
+          Strategy.onAddEdge(IncStore, OutLoad, Assign{}, nullptr);
+        }
+        if (NeedsStoreSafetyFallback) {
+          // Safety-fallback: we may have missed a use of the stored value
+          Strategy.onAddEdge(IncStore, VId, StorePOI{}, nullptr);
+        }
+      }
+      if (IncomingStores[VId].empty()) {
+        for (auto OutLoad : OutgoingLoads[VId]) {
+          Strategy.onAddEdge(VId, OutLoad, Load{}, nullptr);
+        }
+      }
+    });
+  }
+
+  void propagateBB(LLVMPBStrategyRef Strategy, const llvm::BasicBlock &BB) {
+    const auto *Inst = &BB.front();
+    if (Inst->isDebugOrPseudoInst()) {
+      Inst = Inst->getNextNonDebugInstruction();
+    }
+
+    for (; Inst; Inst = Inst->getNextNonDebugInstruction()) {
+      dispatch(Strategy, *Inst);
+    }
+  }
+
+  void dispatch(LLVMPBStrategyRef Strategy, const llvm::Instruction &I) {
+    if (const auto *Alloca = llvm::dyn_cast<llvm::AllocaInst>(&I)) {
+      return (void)getVariable(Alloca, Strategy);
+    }
+
+    if (const auto *Store = llvm::dyn_cast<llvm::StoreInst>(&I)) {
+      return handleStore(Strategy, Store);
+    }
+
+    if (const auto *Load = llvm::dyn_cast<llvm::LoadInst>(&I)) {
+      return handleLoad(Strategy, Load);
+    }
+
+    if (const auto *Cast = llvm::dyn_cast<llvm::CastInst>(&I)) {
+      return handleCast(Strategy, Cast);
+    }
+
+    if (const auto *GEP = llvm::dyn_cast<llvm::GEPOperator>(&I)) {
+      return handleGep(Strategy, GEP);
+    }
+
+    if (const auto *MemTrn = llvm::dyn_cast<llvm::MemTransferInst>(&I)) {
+      return handleMemTransfer(Strategy, MemTrn);
+    }
+
+    if (const auto *Call = llvm::dyn_cast<llvm::CallBase>(&I)) {
+      return handleCall(Strategy, Call);
+    }
+
+    if (const auto *Ret = llvm::dyn_cast<llvm::ReturnInst>(&I)) {
+      return handleReturn(Strategy, Ret);
+    }
+
+    if (const auto *Phi = llvm::dyn_cast<llvm::PHINode>(&I)) {
+      return handlePhi(Strategy, Phi);
+    }
+
+    if (const auto *Select = llvm::dyn_cast<llvm::SelectInst>(&I)) {
+      return handleSelect(Strategy, Select);
+    }
+
+    if (const auto *EV = llvm::dyn_cast<llvm::ExtractValueInst>(&I)) {
+      return handleExtractValue(Strategy, EV);
+    }
+
+    if (const auto *IV = llvm::dyn_cast<llvm::InsertValueInst>(&I)) {
+      return handleInsertValue(Strategy, IV);
+    }
+  }
+
+  static void handleOperand(const llvm::Value *RawOp,
+                            std::invocable<const llvm::Value *> auto Handler) {
+    RawOp = RawOp->stripPointerCastsAndAliases();
+    const auto *RawOpCExpr = llvm::dyn_cast<llvm::ConstantExpr>(RawOp);
+    if (!RawOpCExpr) [[likely]] {
+      // fast-path:
+      return (void)std::invoke(Handler, RawOp);
+    }
+
+    llvm::SmallDenseSet<const llvm::Value *> Seen = {RawOp};
+    llvm::SmallVector<const llvm::User *> WL = {RawOpCExpr};
+    do {
+      const auto *Curr = WL.pop_back_val();
+      for (const auto *Op : Curr->operand_values()) {
+        if (definitelyContainsNoPointer(Op) || !Seen.insert(Op).second) {
+          continue;
+        }
+
+        if (const auto *GObj = llvm::dyn_cast<llvm::GlobalObject>(Op)) {
+          std::invoke(Handler, GObj);
+          continue;
+        }
+
+        // TODO: Handle constant GEP!
+
+        if (const auto *OpUser = llvm::dyn_cast<llvm::User>(Op)) {
+          WL.push_back(OpUser);
+          continue;
+        }
+      }
+
+    } while (!WL.empty());
+  }
+
+  void handleStore(LLVMPBStrategyRef Strategy, const llvm::StoreInst *Store) {
+
+    if (definitelyContainsNoPointer(Store->getValueOperand())) {
+      return;
+    }
+
+    handleOperand(Store->getPointerOperand(), [&](const auto *PointerOp) {
+      auto PointerObj = getVariable(PointerOp, Strategy);
+      handleOperand(Store->getValueOperand(), [&](const auto *ValueOp) {
+        auto ValueObj = getVariable(ValueOp, Strategy);
+        addEdge(Strategy, ValueObj, PointerObj, StorePOI{}, Store);
+      });
+    });
+  }
+
+  void handleLoad(LLVMPBStrategyRef Strategy, const llvm::LoadInst *Ld) {
+    if (definitelyContainsNoPointer(Ld)) {
+      return;
+    }
+
+    handleOperand(Ld->getPointerOperand(), [&](const auto *PointerOp) {
+      auto PointerObj = getVariable(PointerOp, Strategy);
+      if (llvm::isa<llvm::Argument, llvm::Instruction>(PointerOp)) {
+        auto [It, Inserted] = TheOneLoad.try_emplace(PointerObj, ValueId{});
+
+        if (!Inserted) {
+          VC.addAlias(Ld, It->second);
+          return;
+        }
+
+        auto LoadObj = getVariable(Ld, Strategy);
+        It->second = LoadObj;
+        addEdge(Strategy, PointerObj, LoadObj, Load{}, Ld);
+        return;
+      }
+
+      auto LoadObj = getVariable(Ld, Strategy);
+      addEdge(Strategy, PointerObj, LoadObj, Load{}, Ld);
+    });
+  }
+
+  void handleCastImpl(LLVMPBStrategyRef Strategy, const llvm::User *Cast,
+                      const llvm::Value *Op) {
+    auto OperandObj = getVariable(Op, Strategy);
+
+    if (llvm::isa<llvm::GEPOperator>(Cast)) {
+      // accumulate all known offsets, since we have seen a non-constant GEP on
+      // this pointer-op:
+      if (const auto *LocalGeps = psr::getOrNull(this->LocalGeps, Op)) {
+        for (auto [_, Gep] : *LocalGeps) {
+          addEdge(Strategy, OperandObj, Gep, Assign{}, nullptr);
+        }
+        return;
+      }
+    }
+
+    VC.addAlias(Cast, OperandObj);
+  }
+
+  void handleCast(LLVMPBStrategyRef Strategy, const llvm::User *Cast) {
+    if (definitelyContainsNoPointer(Cast)) {
+      return;
+    }
+
+    handleOperand(Cast->getOperand(0),
+                  [&](const auto *Op) { handleCastImpl(Strategy, Cast, Op); });
+  }
+  void handleGep(LLVMPBStrategyRef Strategy, const llvm::GEPOperator *Gep) {
+    handleOperand(Gep->getPointerOperand(), [&](const auto *PointerOp) {
+      if (psr::isAllocaInstOrHeapAllocaFunction(PointerOp) &&
+          !isAddressTakenVariable(PointerOp) && Gep->hasAllConstantIndices() &&
+          !Gep->hasAllZeroIndices()) {
+        llvm::APInt Offset(64, 0);
+        if (Gep->accumulateConstantOffset(DL, Offset)) {
+          auto [It, Inserted] =
+              LocalGeps[PointerOp].try_emplace(Offset.getSExtValue());
+          if (!Inserted) {
+            VC.addAlias(Gep, It->second);
+            return;
+          }
+
+          auto GepObj = getVariable(Gep, Strategy);
+          It->second = GepObj;
+          // Do not add an edge! Geps should be decoupled!
+          return;
+        }
+
+        // fallthrough -- non-constant GEP
+      }
+
+      handleCastImpl(Strategy, Gep, PointerOp);
+    });
+  }
+
+  void handleMemTransfer(LLVMPBStrategyRef Strategy,
+                         const llvm::MemTransferInst *MemTrn) {
+
+    handleOperand(MemTrn->getDest(), [&](const auto *Dest) {
+      auto DestObj = getVariable(Dest, Strategy);
+
+      handleOperand(MemTrn->getSource(), [&](const auto *Src) {
+        auto SourceObj = getVariable(Src, Strategy);
+        addEdge(Strategy, SourceObj, DestObj, Copy{}, MemTrn);
+
+        const auto &DestGeps = getOrDefault(LocalGeps, Dest);
+        for (const auto &[Offset, SrcGep] : getOrDefault(LocalGeps, Src)) {
+          if (const auto *DestGep = getOrNull(DestGeps, Offset)) {
+            addEdge(Strategy, SrcGep, *DestGep, Copy{}, MemTrn);
+          } else {
+            addEdge(Strategy, SrcGep, DestObj, Copy{}, MemTrn);
+          }
+        }
+      });
+    });
+  }
+
+  void handleCallTarget(LLVMPBStrategyRef Strategy, const llvm::CallBase *Call,
+                        const llvm::Function *Callee,
+                        llvm::ArrayRef<llvm::SmallDenseSet<ValueId>> Args,
+                        std::optional<ValueId> CSVal) {
+    const bool HasLibrarySummary = MLSum.mapFunctionSummary(
+        Callee, [&](uint32_t ParamIdx, library_summary::DataFlowFact Dest,
+                    pag::Edge E) {
+          if (ParamIdx >= Args.size()) {
+            return;
+          }
+          const auto HandleArgs = [&](ValueId DestVal) {
+            for (auto FromVal : Args[ParamIdx]) {
+              addEdge(Strategy, FromVal, DestVal, E, Call);
+            }
+          };
+          if (const auto *DestParam =
+                  Dest.dyn_cast<library_summary::Parameter>()) {
+            if (DestParam->Index >= Args.size()) {
+              // safety fallback if library-summary is wrong
+              return;
+            }
+            for (const auto &DestVal : Args[DestParam->Index]) {
+              HandleArgs(DestVal);
+            }
+          } else {
+            if (CSVal) {
+              HandleArgs(*CSVal);
+            }
+          }
+        });
+    if (HasLibrarySummary) {
+      return;
+    }
+
+    if (Callee->isDeclaration()) {
+      return;
+    }
+
+    if (CSVal) {
+      auto RetObj = getVariable(PAGVariable::Return{Callee}, Strategy);
+      addEdge(Strategy, RetObj, *CSVal, Return{}, Call);
+    }
+
+    for (const auto &[Param, Arg] : llvm::zip(Callee->args(), Args)) {
+      if (Arg.empty()) {
+        continue;
+      }
+
+      // XXX: Check, whether Arg is an address-taken variable. Then we can
+      // differentiate between Call and CallPOI; not relevant for now, though,
+      // because we ignore call-pois
+      auto ParamObj = getVariable(&Param, Strategy);
+      for (auto ArgVal : Arg) {
+        addEdge(Strategy, ArgVal, ParamObj,
+                pag::Call{uint16_t(Param.getArgNo())}, Call);
+      }
+    }
+
+    // TODO: Varargs
+  }
+
+  void handleCall(LLVMPBStrategyRef Strategy, const llvm::CallBase *Call) {
+    const auto *FnPtr = Call->getCalledOperand()->stripPointerCastsAndAliases();
+
+    llvm::SmallVector<llvm::SmallDenseSet<ValueId>> Args;
+    for (const auto &Arg : Call->args()) {
+      auto &ArgVal = Args.emplace_back();
+      if (definitelyContainsNoPointer(Arg)) {
+        continue;
+      }
+
+      handleOperand(Arg.get(), [&](const auto *ArgOp) {
+        ArgVal.insert(getVariable(ArgOp, Strategy));
+      });
+    }
+
+    std::optional<ValueId> CSVal;
+    if (Call->getType()->isPointerTy()) {
+      CSVal = getVariable(Call, Strategy);
+    }
+
+    if (const auto *Callee = llvm::dyn_cast<llvm::Function>(FnPtr)) {
+      return handleCallTarget(Strategy, Call, Callee, Args, CSVal);
+    }
+
+    Strategy.withCalleesOfCallAt(Call, [&](const auto *Callee) {
+      handleCallTarget(Strategy, Call, Callee, Args, CSVal);
+    });
+  }
+
+  void handleReturn(LLVMPBStrategyRef Strategy, const llvm::ReturnInst *Ret) {
+    const auto *RetVal = Ret->getReturnValue();
+    if (!RetVal || definitelyContainsNoPointer(RetVal)) {
+      return;
+    }
+
+    auto RetObj =
+        getVariable(PAGVariable::Return{Ret->getFunction()}, Strategy);
+    handleOperand(RetVal, [&](const auto *ExitOp) {
+      auto ExitObj = getVariable(ExitOp, Strategy);
+      addEdge(Strategy, ExitObj, RetObj, Assign{}, Ret);
+    });
+  }
+
+  void handlePhi(LLVMPBStrategyRef Strategy, const llvm::PHINode *Phi) {
+    if (definitelyContainsNoPointer(Phi)) {
+      return;
+    }
+
+    auto PhiObj = getVariable(Phi, Strategy);
+
+    for (const auto &Inc : Phi->incoming_values()) {
+      if (definitelyContainsNoPointer(Inc)) {
+        continue;
+      }
+
+      // Here, we should make sure that all incoming BBs are already handled...
+
+      handleOperand(Inc.get(), [&](const auto *IncOp) {
+        auto IncObj = getVariable(IncOp, Strategy);
+        addEdge(Strategy, IncObj, PhiObj, Assign{}, Phi);
+      });
+    }
+  }
+
+  void handleSelect(LLVMPBStrategyRef Strategy,
+                    const llvm::SelectInst *Select) {
+    if (definitelyContainsNoPointer(Select)) {
+      return;
+    }
+
+    const auto *TrueVal = Select->getTrueValue()->stripPointerCastsAndAliases();
+    const auto *FalseVal =
+        Select->getFalseValue()->stripPointerCastsAndAliases();
+
+    auto SelectObj = getVariable(Select, Strategy);
+    // In the union-find, these are all merged; maybe be a bit smarter here...
+
+    if (!definitelyContainsNoPointer(TrueVal)) {
+      handleOperand(TrueVal, [&](const auto *TrueOp) {
+        auto TrueObj = getVariable(TrueOp, Strategy);
+        addEdge(Strategy, TrueObj, SelectObj, Assign{}, Select);
+      });
+    }
+    if (!definitelyContainsNoPointer(FalseVal)) {
+      handleOperand(FalseVal, [&](const auto *FalseOp) {
+        auto FalseObj = getVariable(FalseOp, Strategy);
+        addEdge(Strategy, FalseObj, SelectObj, Assign{}, Select);
+      });
+    }
+  }
+
+  void handleExtractValue(LLVMPBStrategyRef Strategy,
+                          const llvm::ExtractValueInst *EV) {
+    if (definitelyContainsNoPointer(EV)) {
+      return;
+    }
+
+    auto ResultObj = getVariable(EV, Strategy);
+    handleOperand(EV->getAggregateOperand(), [&](const auto *AggOp) {
+      auto AggObj = getVariable(AggOp, Strategy);
+      addEdge(Strategy, AggObj, ResultObj, Assign{}, EV);
+    });
+  }
+
+  void handleInsertValue(LLVMPBStrategyRef Strategy,
+                         const llvm::InsertValueInst *IV) {
+    if (definitelyContainsNoPointer(IV)) {
+      return;
+    }
+
+    auto ResultObj = getVariable(IV, Strategy);
+    if (!definitelyContainsNoPointer(IV->getAggregateOperand())) {
+      handleOperand(IV->getAggregateOperand(), [&](const auto *AggOp) {
+        auto AggObj = getVariable(AggOp, Strategy);
+        addEdge(Strategy, AggObj, ResultObj, Assign{}, IV);
+      });
+    }
+    if (!definitelyContainsNoPointer(IV->getInsertedValueOperand())) {
+      handleOperand(IV->getInsertedValueOperand(), [&](const auto *ValOp) {
+        auto ValObj = getVariable(ValOp, Strategy);
+        addEdge(Strategy, ValObj, ResultObj, Assign{}, IV);
+      });
+    }
+  }
+};
+
+static const auto &getMappedLibSum(
+    std::optional<library_summary::LLVMFunctionDataFlowFacts> &MLSumBuf,
+    const LLVMProjectIRDB &IRDB) {
+  MLSumBuf.emplace(library_summary::readFromFDFF(
+      getLibCSummary(),
+      [&IRDB](llvm::StringRef FName) { return IRDB.getFunction(FName); }));
+  return *MLSumBuf;
+}
+
+void psr::LLVMPAGBuilder::buildPAG(const LLVMProjectIRDB &IRDB,
+                                   ValueCompressor<v_t> &VC,
+                                   LLVMPBStrategyRef Strategy) {
+
+  std::optional<library_summary::LLVMFunctionDataFlowFacts> MLSumBuf{};
+  const auto &MLSum =
+      this->MLSum ? *this->MLSum : getMappedLibSum(MLSumBuf, IRDB);
+
+  PAGBuildData BData{
+      .DL = IRDB.getModule()->getDataLayout(),
+      .VC = VC,
+      .MLSum = {MLSum},
+  };
+
+  const size_t NumPossibleValues = Strategy.getNumPossibleValues(IRDB);
+  const size_t NumPresentValues = VC.size();
+
+  BData.IncomingStores.reserve(NumPossibleValues);
+  BData.IncomingStores.resize(NumPresentValues);
+
+  BData.OutgoingLoads.reserve(NumPossibleValues);
+  BData.OutgoingLoads.resize(NumPresentValues);
+
+  BData.OnlyIncomingStoresAndOutgoingLoads.reserve(NumPossibleValues);
+
+  BData.initializeGlobals(IRDB, Strategy);
+  BData.initializeFunctions(IRDB, Strategy);
+}
diff --git a/lib/PhasarLLVM/Pointer/LLVMUnionFindAA.cpp b/lib/PhasarLLVM/Pointer/LLVMUnionFindAA.cpp
new file mode 100644
index 0000000000..cd0a5ecb41
--- /dev/null
+++ b/lib/PhasarLLVM/Pointer/LLVMUnionFindAA.cpp
@@ -0,0 +1,169 @@
+#include "phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h"
+
+#include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
+#include "phasar/Pointer/RawAliasSet.h"
+#include "phasar/Pointer/UnionFindAA.h"
+#include "phasar/Utils/ValueCompressor.h"
+
+#include <utility>
+
+namespace psr {
+
+template class CallingContextSensUnionFindAA<LLVMPAGDomain>;
+template class IndirectionSensUnionFindAA<LLVMPAGDomain>;
+template class BottomupUnionFindAA<LLVMPAGDomain>;
+
+detail::LLVMLocalUnionFindAliasIteratorBase::
+    LLVMLocalUnionFindAliasIteratorBase(
+        const ValueCompressor<PAGVariable> &VC) {
+  RawAliasSet<ValueId> Globals;
+  for (const auto &[VId, Vars] : VC.id2vars().enumerate()) {
+    for (auto V : Vars) {
+      if (const auto *LLVMVar = V.valueOrNull()) {
+        if (const auto *Fun = psr::getFunction(LLVMVar)) {
+          GlobalsOrInFun[Fun].insert(VId);
+        } else {
+          Globals.insert(VId);
+        }
+      }
+    }
+  }
+
+  for (auto &[Fun, Vars] : GlobalsOrInFun) {
+    Vars |= Globals;
+  }
+}
+
+} // namespace psr
+
+using namespace psr;
+
+CallingContextSensUnionFindAAResult psr::computeCtxSensUnionFindAARaw(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC) {
+  auto Strategy = CallingContextSensUnionFindAA<LLVMPAGDomain>{
+      &CG,
+      &IRDB,
+  };
+  return computeUnionFindAARaw(IRDB, std::move(Strategy), std::move(VC));
+}
+
+BasicUnionFindAAResult psr::computeBotCtxSensUnionFindAARaw(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC) {
+  auto Strategy = BottomupUnionFindAA<LLVMPAGDomain>{
+      ReverseCGGraph{
+          &CG,
+          &IRDB,
+      },
+  };
+  return computeUnionFindAARaw(IRDB, std::move(Strategy), std::move(VC));
+}
+
+BasicUnionFindAAResult psr::computeIndSensUnionFindAARaw(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC) {
+  auto Strategy = pag::PBMixin{
+      IndirectionSensUnionFindAA<LLVMPAGDomain>{},
+      pag::LLVMCGProvider{&CG},
+  };
+  return computeUnionFindAARaw(IRDB, std::move(Strategy), std::move(VC));
+}
+
+UnionFindAAResultIntersection<CallingContextSensUnionFindAAResult,
+                              BasicUnionFindAAResult>
+psr::computeCtxIndSensUnionFindAARaw(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC) {
+  auto Strategy = UnionFindAACombinator{
+      CallingContextSensUnionFindAA<LLVMPAGDomain>{
+          &CG,
+          &IRDB,
+      },
+      IndirectionSensUnionFindAA<LLVMPAGDomain>{},
+  };
+  return computeUnionFindAARaw(IRDB, std::move(Strategy), std::move(VC));
+}
+
+UnionFindAAResultIntersection<BasicUnionFindAAResult, BasicUnionFindAAResult>
+psr::computeBotCtxIndSensUnionFindAARaw(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC) {
+  auto Strategy = UnionFindAACombinator{
+      BottomupUnionFindAA<LLVMPAGDomain>{
+          ReverseCGGraph{
+              &CG,
+              &IRDB,
+          },
+      },
+      IndirectionSensUnionFindAA<LLVMPAGDomain>{},
+  };
+  return computeUnionFindAARaw(IRDB, std::move(Strategy), std::move(VC));
+}
+
+LLVMUnionFindAliasIterator<CallingContextSensUnionFindAAResult>
+psr::computeCtxSensUnionFindAA(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC) {
+  auto Strategy = CallingContextSensUnionFindAA<LLVMPAGDomain>{
+      &CG,
+      &IRDB,
+  };
+  return computeUnionFindAA(IRDB, std::move(Strategy), std::move(VC));
+}
+
+LLVMUnionFindAliasIterator<BasicUnionFindAAResult>
+psr::computeBotCtxSensUnionFindAA(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC) {
+  auto Strategy = BottomupUnionFindAA<LLVMPAGDomain>{
+      ReverseCGGraph{
+          &CG,
+          &IRDB,
+      },
+  };
+  return computeUnionFindAA(IRDB, std::move(Strategy), std::move(VC));
+}
+
+LLVMUnionFindAliasIterator<BasicUnionFindAAResult>
+psr::computeIndSensUnionFindAA(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC) {
+  auto Strategy = pag::PBMixin{
+      IndirectionSensUnionFindAA<LLVMPAGDomain>{},
+      pag::LLVMCGProvider{&CG},
+  };
+  return computeUnionFindAA(IRDB, std::move(Strategy), std::move(VC));
+}
+
+LLVMUnionFindAliasIterator<UnionFindAAResultIntersection<
+    CallingContextSensUnionFindAAResult, BasicUnionFindAAResult>>
+psr::computeCtxIndSensUnionFindAA(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC) {
+  auto Strategy = UnionFindAACombinator{
+      CallingContextSensUnionFindAA<LLVMPAGDomain>{
+          &CG,
+          &IRDB,
+      },
+      IndirectionSensUnionFindAA<LLVMPAGDomain>{},
+  };
+  return computeUnionFindAA(IRDB, std::move(Strategy), std::move(VC));
+}
+
+LLVMUnionFindAliasIterator<UnionFindAAResultIntersection<
+    BasicUnionFindAAResult, BasicUnionFindAAResult>>
+psr::computeBotCtxIndSensUnionFindAA(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC) {
+  auto Strategy = UnionFindAACombinator{
+      BottomupUnionFindAA<LLVMPAGDomain>{
+          ReverseCGGraph{
+              &CG,
+              &IRDB,
+          },
+      },
+      IndirectionSensUnionFindAA<LLVMPAGDomain>{},
+  };
+  return computeUnionFindAA(IRDB, std::move(Strategy), std::move(VC));
+}
diff --git a/lib/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.cpp b/lib/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.cpp
new file mode 100644
index 0000000000..1b7d6064fe
--- /dev/null
+++ b/lib/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.cpp
@@ -0,0 +1,233 @@
+#include "phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h"
+
+#include "phasar/PhasarLLVM/ControlFlow/EntryFunctionUtils.h"
+#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCallGraph.h"
+#include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMAliasSet.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h"
+#include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
+#include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
+#include "phasar/Pointer/AliasInfoBase.h"
+#include "phasar/Pointer/RawAliasSet.h"
+#include "phasar/Utils/AnalysisProperties.h"
+#include "phasar/Utils/EnumFlags.h"
+#include "phasar/Utils/Fn.h"
+#include "phasar/Utils/MaybeUniquePtr.h"
+#include "phasar/Utils/StrongTypeDef.h"
+#include "phasar/Utils/Utilities.h"
+#include "phasar/Utils/ValueCompressor.h"
+
+#include "llvm/IR/Argument.h"
+#include "llvm/IR/InstrTypes.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/Support/Casting.h"
+
+#include <memory>
+
+using namespace psr;
+
+static_assert(IsAliasInfo<LLVMUnionFindAliasSet>);
+
+static inline bool isPotentialAllocSite(const llvm::Value *Val) {
+  if (!Val->getType()->isPointerTy()) {
+    return false;
+  }
+  if (llvm::isa<llvm::AllocaInst, llvm::Argument>(Val)) {
+    return true;
+  }
+  if (const auto *Call = llvm::dyn_cast<llvm::CallBase>(Val)) {
+    return Call->getCalledFunction() &&
+           psr::isHeapAllocatingFunction(Call->getCalledFunction());
+  }
+  return false;
+}
+
+template <template <typename, typename> typename AAResIterT, typename AAResT>
+struct [[clang::internal_linkage]] LLVMUnionFindAliasSet::UnionFindAAResultModel
+    : public UnionFindAAResultConcept,
+      public AAResIterT<UnionFindAAResultModel<AAResIterT, AAResT>, AAResT> {
+
+  using base_t = AAResIterT<UnionFindAAResultModel<AAResIterT, AAResT>, AAResT>;
+
+  template <typename... ArgsT>
+  constexpr UnionFindAAResultModel(
+      MaybeUniquePtr<const ValueCompressor<PAGVariable>> VC, ArgsT &&...Args)
+      : UnionFindAAResultConcept{std::move(VC)}, base_t{PSR_FWD(Args)...} {}
+
+  void forallAliasesOf(v_t Ptr, n_t Inst,
+                       llvm::function_ref<void(v_t)> Callback) override {
+    this->base_t::forallAliasesOf(Ptr, Inst, Callback);
+  }
+
+  AliasResult alias(v_t Ptr1, v_t Ptr2, n_t AtInstruction = nullptr) override {
+    return this->base_t::alias(Ptr1, Ptr2, AtInstruction);
+  }
+
+  AliasSetPtrTy constructAliasSet(ValueId ValId, n_t Inst,
+                                  AliasSetOwner<AliasSetTy> &Owner) override {
+    auto ASet = Owner.acquire();
+    try {
+      this->base_t::forallAliasesOf(
+          ValId, Inst,
+          [ASet{ASet.get()}](v_t Alias) -> void { ASet->insert(Alias); });
+      return ASet;
+    } catch (...) {
+      Owner.release(ASet.get());
+      throw;
+    }
+  }
+
+  AllocationSiteSetPtrTy constructReachableAllocSites(v_t V, ValueId ValId,
+                                                      bool IntraProcOnly,
+                                                      n_t Inst) override {
+    if (!this->AllocationSites) [[unlikely]] {
+      this->AllocationSites.emplace();
+      for (const auto &[VId, Vars] : this->VC->id2vars().enumerate()) {
+        for (const PAGVariable &Var : Vars) {
+          if (const auto *LLVMVar = Var.valueOrNull();
+              LLVMVar && isPotentialAllocSite(LLVMVar)) {
+            this->AllocationSites->insert(VId);
+            break;
+          }
+        }
+      }
+    }
+
+    auto RawAliases = [&]() -> RawAliasSet<ValueId> {
+      if constexpr (requires() { this->base_t::getRawAliasSet(ValId, Inst); }) {
+        return this->base_t::getRawAliasSet(ValId, Inst);
+      } else {
+        return this->base_t::getRawAliasSet(ValId);
+      }
+    }();
+    RawAliases &= *this->AllocationSites;
+
+    auto Ret = std::make_unique<AliasSetTy>();
+
+    RawAliases.foreach (llvmUnionFindAliasHandler(
+        *this->VC, [&Ret, V, IntraProcOnly](v_t Alias) {
+          if (psr::isInReachableAllocationSitesTy(V, Alias, IntraProcOnly)) {
+            Ret->insert(Alias);
+          }
+        }));
+
+    return Ret;
+  }
+
+  void print(llvm::raw_ostream &OS, Config Cfg) const override {
+    OS << "LLVMUnionFindAliasSet(" << to_string(Cfg.ALocality) << ", "
+       << to_string(Cfg.AType) << ") {\n";
+
+    for (auto ValId : iota<ValueId>(VC->size())) {
+      OS << "  #" << psr::to_underlying(ValId) << ": {";
+      bool First = true;
+      const auto &Aliases = this->base_t::getRawAliasSet(ValId);
+      Aliases.foreach ([&](auto AliasId) {
+        if (First) {
+          First = false;
+        } else {
+          OS << ", ";
+        }
+
+        OS << psr::to_underlying(AliasId);
+      });
+      OS << "}\n";
+    }
+    OS << "}\n";
+  };
+};
+
+LLVMUnionFindAliasSet::LLVMUnionFindAliasSet(const LLVMProjectIRDB *IRDB,
+                                             const LLVMBasedCallGraph &BaseCG,
+                                             Config Cfg,
+                                             ValueCompressor<PAGVariable> *VC)
+    : Cfg(Cfg) {
+  MaybeUniquePtr<ValueCompressor<PAGVariable>> VCOwn = VC;
+  if (!VC) {
+    VCOwn = std::make_unique<ValueCompressor<PAGVariable>>();
+  }
+
+  auto MakeAAResModel =
+      [&, IRDB, Cfg, VCOwn = std::move(VCOwn)](
+          auto AAResCtor) mutable -> std::unique_ptr<UnionFindAAResultConcept> {
+    auto AARes = AAResCtor(*IRDB, BaseCG, VCOwn.get());
+    using AAResT = decltype(AARes);
+
+    if (Cfg.ALocality == AnalysisLocality::FunctionLocal) {
+      const auto &VCRef = *VCOwn;
+      return std::make_unique<
+          UnionFindAAResultModel<LLVMLocalUnionFindAliasIteratorMixin, AAResT>>(
+          std::move(VCOwn), PSR_FWD(AARes), VCRef);
+    }
+
+    return std::make_unique<
+        UnionFindAAResultModel<LLVMUnionFindAliasIteratorMixin, AAResT>>(
+        std::move(VCOwn), PSR_FWD(AARes));
+  };
+
+  scope_exit ResizeAliasSetCache = [&] {
+    if (!AARes) {
+      // Something went wrong and we hopefully have an in-flight
+      // exception...
+      return;
+    }
+
+    AliasSets.resize(AARes->VC->size());
+  };
+
+  switch (Cfg.AType) {
+  case UnionFindAliasAnalysisType::CtxSens:
+    Props = AnalysisProperties::ContextSensitive;
+    AARes = MakeAAResModel(fn<computeCtxSensUnionFindAARaw>);
+    return;
+  case UnionFindAliasAnalysisType::IndSens:
+    Props = AnalysisProperties::FieldSensitive;
+    AARes = MakeAAResModel(fn<computeIndSensUnionFindAARaw>);
+    return;
+  case UnionFindAliasAnalysisType::CtxIndSens:
+    Props = AnalysisProperties::ContextSensitive |
+            AnalysisProperties::FieldSensitive;
+    AARes = MakeAAResModel(fn<computeCtxIndSensUnionFindAARaw>);
+    return;
+  case UnionFindAliasAnalysisType::BotCtxSens:
+    Props = AnalysisProperties::ContextSensitive;
+    AARes = MakeAAResModel(fn<computeBotCtxSensUnionFindAARaw>);
+    return;
+  case UnionFindAliasAnalysisType::BotCtxIndSens:
+    Props = AnalysisProperties::ContextSensitive |
+            AnalysisProperties::FieldSensitive;
+    AARes = MakeAAResModel(fn<computeBotCtxIndSensUnionFindAARaw>);
+    return;
+  }
+
+  llvm_unreachable(
+      "We should have handled all AnalysisType values in the switch above");
+}
+
+auto LLVMUnionFindAliasSet::getEmptyAliasSet() -> BoxedPtr<AliasSetTy> {
+  static AliasSetTy EmptySet{};
+  static AliasSetTy *EmptySetPtr = &EmptySet;
+  return &EmptySetPtr;
+}
+
+void LLVMUnionFindAliasSet::print(llvm::raw_ostream &OS) const {
+  assert(isValid());
+  AARes->print(OS, Cfg);
+}
+
+void LLVMUnionFindAliasSet::printAsJson(llvm::raw_ostream &OS) const {
+  // TODO
+  OS << "{}\n";
+}
+
+[[nodiscard]] llvm::StringRef
+psr::to_string(LLVMUnionFindAliasSet::AnalysisLocality Loc) noexcept {
+  switch (Loc) {
+  case LLVMUnionFindAliasSet::AnalysisLocality::Global:
+    return "global";
+  case LLVMUnionFindAliasSet::AnalysisLocality::FunctionLocal:
+    return "local";
+  }
+  llvm_unreachable(
+      "All analysis-localities should be handled in the switch above");
+}
diff --git a/lib/PhasarLLVM/Pointer/SVF/InitSVF.h b/lib/PhasarLLVM/Pointer/SVF/InitSVF.h
index cb7eb120b2..0395115eae 100644
--- a/lib/PhasarLLVM/Pointer/SVF/InitSVF.h
+++ b/lib/PhasarLLVM/Pointer/SVF/InitSVF.h
@@ -1,5 +1,14 @@
 #pragma once
 
+/******************************************************************************
+ * Copyright (c) 2025 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
 #include "llvm/Support/Compiler.h"
 
 namespace psr {
diff --git a/lib/PhasarLLVM/Utils/LLVMShorthands.cpp b/lib/PhasarLLVM/Utils/LLVMShorthands.cpp
index 88d5971f43..adca056732 100644
--- a/lib/PhasarLLVM/Utils/LLVMShorthands.cpp
+++ b/lib/PhasarLLVM/Utils/LLVMShorthands.cpp
@@ -17,6 +17,7 @@
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
 
 #include "phasar/Config/Configuration.h"
+#include "phasar/Utils/Fn.h"
 #include "phasar/Utils/LibrarySummary.h"
 #include "phasar/Utils/Utilities.h"
 
@@ -34,6 +35,7 @@
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/ModuleSlotTracker.h"
+#include "llvm/IR/Operator.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
@@ -165,6 +167,9 @@ std::string psr::llvmIRToString(const llvm::Value *V) {
   if (const auto *F = llvm::dyn_cast<llvm::Function>(V)) {
     return "fun @" + F->getName().str();
   }
+  if (const auto *BB = llvm::dyn_cast<llvm::BasicBlock>(V)) {
+    return "block " + BB->getName().str();
+  }
 
   std::string IRBuffer;
   llvm::raw_string_ostream RSO(IRBuffer);
@@ -493,6 +498,63 @@ bool psr::isGuardVariable(const llvm::Value *V) {
   return false;
 }
 
+static bool isAllocationSiteOrSimilar(const llvm::Value *V) {
+  if (const auto *Arg = llvm::dyn_cast<llvm::Argument>(V)) {
+    return Arg->hasStructRetAttr();
+  }
+  return isAllocaInstOrHeapAllocaFunction(V);
+}
+
+bool psr::isAddressTakenVariable(const llvm::Value *Var) noexcept {
+  if (!Var) {
+    return false;
+  }
+  if (!isAllocationSiteOrSimilar(Var)) {
+    return true;
+  }
+
+  llvm::SmallVector<const llvm::Value *> WL = {Var};
+  llvm::SmallDenseSet<const llvm::Value *> Seen = {Var};
+
+  while (!WL.empty()) {
+    const auto *CurrVal = WL.pop_back_val();
+
+    for (const auto &Use : CurrVal->uses()) {
+      if (llvm::isa<llvm::LoadInst>(Use.getUser())) {
+        continue;
+      }
+      if (const auto *Store = llvm::dyn_cast<llvm::StoreInst>(Use.getUser())) {
+        if (Store->getPointerOperand() == Use) {
+          continue;
+        }
+      } else if (llvm::isa<llvm::DbgInfoIntrinsic>(Use.getUser())) {
+        continue;
+      } else if (llvm::isa<llvm::CastInst>(Use.getUser())) {
+        if (!CurrVal->getType()->isPointerTy()) {
+          return true; // ptrtoint
+        }
+
+        if (!Seen.insert(Use.getUser()).second) {
+          WL.push_back(Use.getUser());
+        }
+
+        continue;
+      } else if (const auto *GEP =
+                     llvm::dyn_cast<llvm::GEPOperator>(Use.getUser())) {
+        if (Use == GEP->getPointerOperand() && !Seen.insert(GEP).second) {
+          WL.push_back(GEP);
+        }
+
+        continue;
+      }
+
+      return true;
+    }
+  }
+
+  return false;
+}
+
 bool psr::isStaticVariableLazyInitializationBranch(
     const llvm::BranchInst *Inst) {
   if (Inst->isUnconditional()) {
@@ -523,6 +585,20 @@ bool psr::isStaticVariableLazyInitializationBranch(
   return false;
 }
 
+[[nodiscard]] bool
+psr::detail::definitelyContainsNoPointerImpl(const llvm::Type *Ty) noexcept {
+  if (const auto *Arr = llvm::dyn_cast<llvm::ArrayType>(Ty)) {
+    return definitelyContainsNoPointerFast(Arr->getElementType());
+  }
+
+  if (const auto *Struct = llvm::dyn_cast<llvm::StructType>(Ty)) {
+    return llvm::all_of(Struct->elements(),
+                        fn<definitelyContainsNoPointerFast>);
+  }
+
+  return false;
+}
+
 bool psr::isVarAnnotationIntrinsic(const llvm::Function *F) {
   static constexpr llvm::StringLiteral KVarAnnotationName(
       "llvm.var.annotation");
diff --git a/lib/PhasarLLVM/Utils/Utils.cppm b/lib/PhasarLLVM/Utils/Utils.cppm
index 44043bc45d..964a3ab8ec 100644
--- a/lib/PhasarLLVM/Utils/Utils.cppm
+++ b/lib/PhasarLLVM/Utils/Utils.cppm
@@ -5,6 +5,7 @@ module;
 #include "phasar/PhasarLLVM/Utils/DataFlowAnalysisType.h"
 #include "phasar/PhasarLLVM/Utils/LLVMBasedContainerConfig.h"
 #include "phasar/PhasarLLVM/Utils/LLVMCXXShorthands.h"
+#include "phasar/PhasarLLVM/Utils/LLVMFunctionDataFlowFacts.h"
 #include "phasar/PhasarLLVM/Utils/LLVMIRToSrc.h"
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
 #include "phasar/PhasarLLVM/Utils/LLVMSourceManager.h"
@@ -74,3 +75,8 @@ using psr::SourceCodeInfo;
 using psr::SourceMgrPrinter;
 using psr::to_json;
 } // namespace psr
+
+export namespace psr::library_summary {
+using psr::library_summary::LLVMFunctionDataFlowFacts;
+using psr::library_summary::readFromFDFF;
+} // namespace psr::library_summary
diff --git a/lib/Pointer/UnionFindAA.cpp b/lib/Pointer/UnionFindAA.cpp
new file mode 100644
index 0000000000..a14d6cfcdf
--- /dev/null
+++ b/lib/Pointer/UnionFindAA.cpp
@@ -0,0 +1,28 @@
+
+#include "phasar/Pointer/UnionFindAA.h"
+
+#include "phasar/Utils/StrongTypeDef.h" // for to_underlying
+
+using namespace psr;
+
+void psr::UnionFindAAResultBase::dump(llvm::raw_ostream &OS,
+                                      uint32_t Indent) const {
+  OS.indent(Indent) << "UnionFindAAResult {\n";
+
+  for (const auto &[RepId, Aliases] : BackwardView.enumerate()) {
+    OS.indent(Indent + 2) << "#" << psr::to_underlying(RepId) << ": <";
+    bool First = true;
+    Aliases.foreach ([&](auto AliasId) {
+      if (First) {
+        First = false;
+      } else {
+        OS << ", ";
+      }
+
+      OS << psr::to_underlying(AliasId);
+    });
+    OS << ">\n";
+  }
+
+  OS.indent(Indent) << "}\n";
+}
diff --git a/lib/Utils/IO.cpp b/lib/Utils/IO.cpp
index b016db47d4..05f1514302 100644
--- a/lib/Utils/IO.cpp
+++ b/lib/Utils/IO.cpp
@@ -87,3 +87,20 @@ psr::openFileStream(const llvm::Twine &Filename) {
   }
   return OFS;
 }
+
+std::unique_ptr<llvm::raw_ostream>
+psr::openFileForWrite(const llvm::Twine &FilePath) {
+  llvm::SmallString<256> Buf;
+  auto FileName = FilePath.toStringRef(Buf);
+
+  std::error_code EC;
+  auto Ret = std::make_unique<llvm::raw_fd_ostream>(FileName, EC);
+  if (EC) {
+    llvm::errs() << "[ERROR]: Failed to open file '" << FileName
+                 << "' for writing:\n";
+    llvm::errs() << "  > " << EC.message() << '\n';
+    Ret.reset();
+  }
+
+  return Ret;
+}
diff --git a/lib/PhasarLLVM/DataFlow/IfdsIde/LibCSummary.cpp b/lib/Utils/LibCSummary.cpp
similarity index 99%
rename from lib/PhasarLLVM/DataFlow/IfdsIde/LibCSummary.cpp
rename to lib/Utils/LibCSummary.cpp
index 4dff8c690c..ff9ee0094b 100644
--- a/lib/PhasarLLVM/DataFlow/IfdsIde/LibCSummary.cpp
+++ b/lib/Utils/LibCSummary.cpp
@@ -1,6 +1,6 @@
-#include "phasar/PhasarLLVM/DataFlow/IfdsIde/LibCSummary.h"
+#include "phasar/Utils/LibCSummary.h"
 
-#include "phasar/PhasarLLVM/DataFlow/IfdsIde/FunctionDataFlowFacts.h"
+#include "phasar/Utils/FunctionDataFlowFacts.h"
 
 using namespace psr;
 using namespace psr::library_summary;
diff --git a/lib/Utils/Utils.cppm b/lib/Utils/Utils.cppm
index f75c6aa46f..42f1f1af2e 100644
--- a/lib/Utils/Utils.cppm
+++ b/lib/Utils/Utils.cppm
@@ -20,11 +20,13 @@ module;
 #include "phasar/Utils/EnumFlags.h"
 #include "phasar/Utils/EquivalenceClassMap.h"
 #include "phasar/Utils/ErrorHandling.h"
+#include "phasar/Utils/FunctionDataFlowFacts.h"
 #include "phasar/Utils/GraphTraits.h"
 #include "phasar/Utils/IO.h"
 #include "phasar/Utils/InitPhasar.h"
 #include "phasar/Utils/IotaIterator.h"
 #include "phasar/Utils/JoinLattice.h"
+#include "phasar/Utils/LibCSummary.h"
 #include "phasar/Utils/Macros.h"
 #include "phasar/Utils/MaybeUniquePtr.h"
 #include "phasar/Utils/NullAnalysisPrinter.h"
@@ -168,6 +170,7 @@ using psr::DummyUnorderedTable1d;
 using psr::ElementType;
 using psr::FalseFn;
 using psr::forward_like;
+using psr::getLibCSummary;
 using psr::has_adl_to_string_v;
 using psr::has_erase_iterator_v;
 using psr::has_getAsJson;
@@ -221,3 +224,10 @@ using psr::UnorderedTable1d;
 using psr::variant_idx;
 
 } // namespace psr
+
+export namespace psr::library_summary {
+using psr::library_summary::DataFlowFact;
+using psr::library_summary::FunctionDataFlowFacts;
+using psr::library_summary::Parameter;
+using psr::library_summary::ReturnValue;
+} // namespace psr::library_summary
diff --git a/test/llvm_test_code/pointers/CMakeLists.txt b/test/llvm_test_code/pointers/CMakeLists.txt
index 8201a4fbfb..0802f9e736 100644
--- a/test/llvm_test_code/pointers/CMakeLists.txt
+++ b/test/llvm_test_code/pointers/CMakeLists.txt
@@ -1,14 +1,54 @@
 set(lca_files
-  basic_01.cpp
+  basic_01.c
+  basic_02.c
+  basic_03.c
+  basic_04.c
   call_01.cpp
   dynamic_01.cpp
   global_01.cpp
   inter_dynamic_01.cpp
   inter_dynamic_02.cpp
+  context_01.c
+  context_02.c
+  context_03.c
+  context_04_0.c
+  context_04_1.c
+  context_05_0.c
+  context_05_1.c
+  context_06_0.c
+  context_06_1.c
+  context_07.c
+  context_08.c
+  context_09_0.c
+  context_09_1.c
+  context_10_0.c
+  context_10_1.c
+  context_11_0.c
+  context_11_1.c
+  context_12_0.c
+  context_12_1.c
+  context_13_0.c
+  context_13_1.c
+  context_14_0.c
+  context_14_1.c
+  context_14_2.c
+  indirection_01.c
+  indirection_02.c
+  indirection_03.c
+  indirection_04.c
+  indirection_05.c
+  indirection_06.c
+  indirection_07.c
+  indirection_08.cpp
+  indirection_09.cpp
+  indirection_10.cpp
 )
 
 set(lca_files_mem2reg
-  basic_01.cpp
+  basic_01.c
+  basic_02.c
+  basic_03.c
+  basic_04.c
   dynamic_01.cpp
   inter_dynamic_01.cpp
   inter_dynamic_02.cpp
diff --git a/test/llvm_test_code/pointers/basic_01.cpp b/test/llvm_test_code/pointers/basic_01.c
similarity index 100%
rename from test/llvm_test_code/pointers/basic_01.cpp
rename to test/llvm_test_code/pointers/basic_01.c
diff --git a/test/llvm_test_code/pointers/basic_02.c b/test/llvm_test_code/pointers/basic_02.c
new file mode 100644
index 0000000000..aa3ea971de
--- /dev/null
+++ b/test/llvm_test_code/pointers/basic_02.c
@@ -0,0 +1,7 @@
+
+int main() {
+  int i;
+  int *p = &i;
+  int **q = &p;
+  **q = 13;
+}
diff --git a/test/llvm_test_code/pointers/basic_03.c b/test/llvm_test_code/pointers/basic_03.c
new file mode 100644
index 0000000000..0f2c01ef95
--- /dev/null
+++ b/test/llvm_test_code/pointers/basic_03.c
@@ -0,0 +1,10 @@
+
+int Func() { return 1; }
+
+int main() {
+  int (*FuncPtr)();
+
+  FuncPtr = &Func;
+
+  return FuncPtr();
+}
diff --git a/test/llvm_test_code/pointers/basic_04.c b/test/llvm_test_code/pointers/basic_04.c
new file mode 100644
index 0000000000..eed0db4bd4
--- /dev/null
+++ b/test/llvm_test_code/pointers/basic_04.c
@@ -0,0 +1,12 @@
+
+int Func() { return 1; }
+
+int main() {
+  int (*FuncPtr)();
+  int (**FuncPtr2)();
+
+  FuncPtr = &Func;
+  FuncPtr2 = &FuncPtr;
+
+  return (*FuncPtr2)();
+}
diff --git a/test/llvm_test_code/pointers/context_01.c b/test/llvm_test_code/pointers/context_01.c
new file mode 100644
index 0000000000..66962033a2
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_01.c
@@ -0,0 +1,12 @@
+
+int *id(int *p) { return p; }
+
+int main() {
+  int x = 42;
+  int y = 43;
+
+  int *xx = id(&x);
+  int *yy = id(&y);
+
+  return *xx;
+}
diff --git a/test/llvm_test_code/pointers/context_02.c b/test/llvm_test_code/pointers/context_02.c
new file mode 100644
index 0000000000..542f953fda
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_02.c
@@ -0,0 +1,15 @@
+
+int *id1(int *p) { return p; }
+int *id2(int *q) { return q; }
+
+int main() {
+  int x = 42;
+  int y = 43;
+
+  int *xx1 = id1(&x);
+  int *xx2 = id1(&x);
+  int *yy1 = id2(&y);
+  int *yy2 = id2(&y);
+
+  return *xx1;
+}
diff --git a/test/llvm_test_code/pointers/context_03.c b/test/llvm_test_code/pointers/context_03.c
new file mode 100644
index 0000000000..c390e0dea9
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_03.c
@@ -0,0 +1,12 @@
+
+int *id1(int *p) { return p; }
+int *id2(int *q) { return id1(q); }
+
+int main() {
+  int x = 42;
+
+  int *xx1 = id2(&x);
+  int *xx2 = id2(&x);
+
+  return *xx1;
+}
diff --git a/test/llvm_test_code/pointers/context_04_0.c b/test/llvm_test_code/pointers/context_04_0.c
new file mode 100644
index 0000000000..b4badf43a6
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_04_0.c
@@ -0,0 +1,13 @@
+
+int *id1(int *p) { return p; }
+int *id2(int *q) { return id1(q); }
+int *id3(int *r) { return id2(r); }
+
+int main() {
+  int x = 42;
+
+  int *xx1 = id3(&x);
+  int *xx2 = id3(&x);
+
+  return *xx1;
+}
diff --git a/test/llvm_test_code/pointers/context_04_1.c b/test/llvm_test_code/pointers/context_04_1.c
new file mode 100644
index 0000000000..5ee815e778
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_04_1.c
@@ -0,0 +1,16 @@
+
+int *id1(int *p) { return p; }
+int *id2(int *q) { return id1(q); }
+int *id3(int *r) { return id2(r); }
+
+int main() {
+  int x = 4;
+  int y = 2;
+
+  int *xx1 = id3(&x);
+  int *xx2 = id3(&x);
+  int *yy1 = id3(&y);
+  int *yy2 = id3(&y);
+
+  return *xx1;
+}
diff --git a/test/llvm_test_code/pointers/context_05_0.c b/test/llvm_test_code/pointers/context_05_0.c
new file mode 100644
index 0000000000..cbfb72270d
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_05_0.c
@@ -0,0 +1,14 @@
+
+int *id1(int *p) { return p; }
+int *id2(int *q) { return id1(q); }
+int *id3(int *r) { return id2(r); }
+int *id4(int *s) { return id3(s); }
+
+int main() {
+  int x = 42;
+
+  int *xx = id4(&x);
+  int *yy = id4(&x);
+
+  return *xx;
+}
diff --git a/test/llvm_test_code/pointers/context_05_1.c b/test/llvm_test_code/pointers/context_05_1.c
new file mode 100644
index 0000000000..d0bd55e5a7
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_05_1.c
@@ -0,0 +1,17 @@
+
+int *id1(int *p) { return p; }
+int *id2(int *q) { return id1(q); }
+int *id3(int *r) { return id2(r); }
+int *id4(int *s) { return id3(s); }
+
+int main() {
+  int x = 4;
+  int y = 2;
+
+  int *xx1 = id4(&x);
+  int *xx2 = id4(&x);
+  int *yy1 = id4(&y);
+  int *yy2 = id4(&y);
+
+  return *xx2;
+}
diff --git a/test/llvm_test_code/pointers/context_06_0.c b/test/llvm_test_code/pointers/context_06_0.c
new file mode 100644
index 0000000000..ff8a990cf2
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_06_0.c
@@ -0,0 +1,15 @@
+
+int *id1(int *p) { return p; }
+int *id2(int *q) { return id1(q); }
+int *id3(int *r) { return id2(r); }
+int *id4(int *s) { return id3(s); }
+int *id5(int *t) { return id4(t); }
+
+int main() {
+  int x = 42;
+
+  int *xx = id5(&x);
+  int *yy = id5(&x);
+
+  return *xx;
+}
diff --git a/test/llvm_test_code/pointers/context_06_1.c b/test/llvm_test_code/pointers/context_06_1.c
new file mode 100644
index 0000000000..6ae198a51a
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_06_1.c
@@ -0,0 +1,18 @@
+
+int *id1(int *p) { return p; }
+int *id2(int *q) { return id1(q); }
+int *id3(int *r) { return id2(r); }
+int *id4(int *s) { return id3(s); }
+int *id5(int *t) { return id4(t); }
+
+int main() {
+  int x = 4;
+  int y = 2;
+
+  int *xx1 = id5(&x);
+  int *xx2 = id5(&x);
+  int *yy1 = id5(&y);
+  int *yy2 = id5(&y);
+
+  return *yy1;
+}
diff --git a/test/llvm_test_code/pointers/context_07.c b/test/llvm_test_code/pointers/context_07.c
new file mode 100644
index 0000000000..04724b7ca0
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_07.c
@@ -0,0 +1,15 @@
+
+int *buzz(int *s) { return s; }
+int *baz(int *r) { return buzz(r); }
+int *bar(int *q) { return baz(q); }
+int *foo(int *p) { return bar(p); }
+
+int main() {
+  int x = 42;
+  int y = 43;
+
+  int *xx = foo(&x);
+  int *yy = foo(&y);
+
+  return *xx;
+}
diff --git a/test/llvm_test_code/pointers/context_08.c b/test/llvm_test_code/pointers/context_08.c
new file mode 100644
index 0000000000..c311df1886
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_08.c
@@ -0,0 +1,22 @@
+
+int *selfRecursion(int *Ptr) {
+  if (*Ptr <= 0) {
+    return Ptr;
+  }
+
+  *Ptr = *Ptr - 1;
+  return selfRecursion(Ptr);
+}
+
+int main() {
+  int k = 1;
+  int *kptr = &k;
+
+  int *x = selfRecursion(kptr);
+
+  k = 1;
+
+  int *y = selfRecursion(kptr);
+
+  return *x;
+}
diff --git a/test/llvm_test_code/pointers/context_09_0.c b/test/llvm_test_code/pointers/context_09_0.c
new file mode 100644
index 0000000000..a43381e368
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_09_0.c
@@ -0,0 +1,19 @@
+
+int *selfRecursion(int *Ptr) {
+  if (*Ptr <= 0) {
+    return Ptr;
+  }
+
+  *Ptr = *Ptr - 1;
+  return selfRecursion(Ptr);
+}
+
+int main() {
+  int k = 4;
+  int l = 4;
+
+  int *x = selfRecursion(&k);
+  int *y = selfRecursion(&l);
+
+  return *y;
+}
diff --git a/test/llvm_test_code/pointers/context_09_1.c b/test/llvm_test_code/pointers/context_09_1.c
new file mode 100644
index 0000000000..b05dc51d20
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_09_1.c
@@ -0,0 +1,23 @@
+
+int *selfRecursion(int *Ptr) {
+  if (*Ptr <= 0) {
+    return Ptr;
+  }
+
+  *Ptr = *Ptr - 1;
+  return selfRecursion(Ptr);
+}
+
+int main() {
+  int k = 4;
+  int l = 4;
+
+  int *xx1 = selfRecursion(&k);
+  k = 4;
+  int *xx2 = selfRecursion(&k);
+  int *yy1 = selfRecursion(&l);
+  l = 4;
+  int *yy2 = selfRecursion(&l);
+
+  return *yy2;
+}
diff --git a/test/llvm_test_code/pointers/context_10_0.c b/test/llvm_test_code/pointers/context_10_0.c
new file mode 100644
index 0000000000..785bb151b2
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_10_0.c
@@ -0,0 +1,33 @@
+
+int *Back(int *Ptr);
+
+int *Forth(int *Ptr) {
+  if (*Ptr > 0) {
+    *Ptr = *Ptr - 1;
+    return Back(Ptr);
+  }
+
+  return Ptr;
+}
+
+int *Back(int *Ptr) {
+  if (*Ptr > 0) {
+    *Ptr = *Ptr - 1;
+    return Forth(Ptr);
+  }
+
+  return Ptr;
+}
+
+// Mutual recursion test
+int main() {
+  int k = 2;
+
+  int *x = Back(&k);
+
+  k = 2;
+
+  int *y = Back(&k);
+
+  return *x;
+}
diff --git a/test/llvm_test_code/pointers/context_10_1.c b/test/llvm_test_code/pointers/context_10_1.c
new file mode 100644
index 0000000000..294729cd17
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_10_1.c
@@ -0,0 +1,36 @@
+
+int *Back(int *Ptr);
+
+int *Forth(int *Ptr) {
+  if (*Ptr > 0) {
+    *Ptr = *Ptr - 1;
+    return Back(Ptr);
+  }
+
+  return Ptr;
+}
+
+int *Back(int *Ptr) {
+  if (*Ptr > 0) {
+    *Ptr = *Ptr - 1;
+    return Forth(Ptr);
+  }
+
+  return Ptr;
+}
+
+// Mutual recursion test
+int main() {
+  int k = 2;
+  int l = 2;
+
+  int *xx1 = Back(&k);
+  k = 2;
+  int *xx2 = Back(&k);
+
+  int *yy1 = Back(&l);
+  l = 4;
+  int *yy2 = Back(&l);
+
+  return *xx1;
+}
diff --git a/test/llvm_test_code/pointers/context_11_0.c b/test/llvm_test_code/pointers/context_11_0.c
new file mode 100644
index 0000000000..e5e3f0b5e9
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_11_0.c
@@ -0,0 +1,40 @@
+
+int *Back(int *Ptr);
+int *Stop(int *Ptr);
+
+int *Forth(int *Ptr) {
+  if (*Ptr > 0) {
+    *Ptr = *Ptr - 1;
+    return Stop(Ptr);
+  }
+
+  return Ptr;
+}
+
+int *Back(int *Ptr) {
+  if (*Ptr > 0) {
+    *Ptr = *Ptr - 1;
+    return Stop(Ptr);
+  }
+
+  return Ptr;
+}
+
+int *Stop(int *Ptr) {
+  if (*Ptr % 2 == 1) {
+    return Forth(Ptr);
+  }
+
+  return Back(Ptr);
+}
+
+// Mutual recursion test
+int main() {
+  int k = 2;
+  int l = 3;
+
+  int *x = Back(&k);
+  int *y = Forth(&l);
+
+  return *x;
+}
diff --git a/test/llvm_test_code/pointers/context_11_1.c b/test/llvm_test_code/pointers/context_11_1.c
new file mode 100644
index 0000000000..f320b5e7df
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_11_1.c
@@ -0,0 +1,42 @@
+
+int *Back(int *Ptr);
+int *Stop(int *Ptr);
+
+int *Forth(int *Ptr) {
+  if (*Ptr > 0) {
+    *Ptr = *Ptr - 1;
+    return Stop(Ptr);
+  }
+
+  return Ptr;
+}
+
+int *Back(int *Ptr) {
+  if (*Ptr > 0) {
+    *Ptr = *Ptr - 1;
+    return Stop(Ptr);
+  }
+
+  return Ptr;
+}
+
+int *Stop(int *Ptr) {
+  if (*Ptr % 2 == 1) {
+    return Forth(Ptr);
+  }
+
+  return Back(Ptr);
+}
+
+// Mutual recursion test
+int main() {
+  int k = 2;
+  int l = 2;
+
+  int *xx1 = Back(&k);
+  int *xx2 = Back(&k);
+  int *yy1 = Forth(&l);
+  int *yy2 = Forth(&l);
+
+  return *xx2;
+}
diff --git a/test/llvm_test_code/pointers/context_12_0.c b/test/llvm_test_code/pointers/context_12_0.c
new file mode 100644
index 0000000000..c689896661
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_12_0.c
@@ -0,0 +1,14 @@
+
+int *argretq(int *p, int *q) { return q; }
+
+int main() {
+  int x = 42;
+  int y = 43;
+
+  int *xx1 = argretq(&y, &x);
+  int *xx2 = argretq(&y, &x);
+  int *yy1 = argretq(&x, &y);
+  int *yy2 = argretq(&x, &y);
+
+  return *xx1;
+}
diff --git a/test/llvm_test_code/pointers/context_12_1.c b/test/llvm_test_code/pointers/context_12_1.c
new file mode 100644
index 0000000000..36eded1211
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_12_1.c
@@ -0,0 +1,12 @@
+
+int *argretq(int *p, int *q) { return q; }
+
+int main() {
+  int x = 42;
+  int y = 43;
+
+  int *xx1 = argretq(&y, &x);
+  int *yy1 = argretq(&x, &y);
+
+  return *xx1;
+}
diff --git a/test/llvm_test_code/pointers/context_13_0.c b/test/llvm_test_code/pointers/context_13_0.c
new file mode 100644
index 0000000000..2bd9aff23e
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_13_0.c
@@ -0,0 +1,18 @@
+
+int *argretq(int *p, int *q, int *r) { return q; }
+
+int main() {
+  int x = 42;
+  int y = 43;
+
+  int *xx1 = argretq(&x, &x, &x);
+  int *xx2 = argretq(&x, &x, &y);
+  int *xx3 = argretq(&y, &x, &y);
+  int *xx4 = argretq(&y, &x, &x);
+  int *yy1 = argretq(&x, &y, &x);
+  int *yy2 = argretq(&x, &y, &y);
+  int *yy3 = argretq(&y, &y, &y);
+  int *yy4 = argretq(&y, &y, &x);
+
+  return *xx1;
+}
diff --git a/test/llvm_test_code/pointers/context_13_1.c b/test/llvm_test_code/pointers/context_13_1.c
new file mode 100644
index 0000000000..3771792d29
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_13_1.c
@@ -0,0 +1,12 @@
+
+int *argretq(int *p, int *q, int *r) { return q; }
+
+int main() {
+  int x = 42;
+  int y = 43;
+
+  int *xx1 = argretq(&x, &x, &x);
+  int *yy1 = argretq(&y, &y, &y);
+
+  return *yy1;
+}
diff --git a/test/llvm_test_code/pointers/context_14_0.c b/test/llvm_test_code/pointers/context_14_0.c
new file mode 100644
index 0000000000..fd110be6aa
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_14_0.c
@@ -0,0 +1,12 @@
+
+int ret0() { return 0; }
+
+int callback(int (*Func)()) { return Func(); }
+
+int main() {
+  int (*FuncPtr)() = &ret0;
+
+  int Zero = callback(FuncPtr);
+
+  return 0;
+}
diff --git a/test/llvm_test_code/pointers/context_14_1.c b/test/llvm_test_code/pointers/context_14_1.c
new file mode 100644
index 0000000000..fb04c335a8
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_14_1.c
@@ -0,0 +1,16 @@
+
+int ret0() { return 0; }
+
+int ret1() { return 1; }
+
+int (*callback(int (*Func)()))() { return Func; }
+
+int main() {
+  int (*FuncPtrZero)() = &ret0;
+  int (*FuncPtrOne)() = &ret1;
+
+  FuncPtrZero = callback(&ret1);
+  FuncPtrOne = callback(&ret0);
+
+  return 0;
+}
diff --git a/test/llvm_test_code/pointers/context_14_2.c b/test/llvm_test_code/pointers/context_14_2.c
new file mode 100644
index 0000000000..aa0b519768
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_14_2.c
@@ -0,0 +1,20 @@
+
+int ret0() { return 0; }
+
+int ret1() { return 1; }
+
+int ret2() { return 1; }
+
+int (*callback(int (*Func)()))() { return Func; }
+
+int main() {
+  int (*FuncPtrZero)() = &ret0;
+  int (*FuncPtrOne)() = &ret1;
+  int (*FuncPtrTwo)() = &ret2;
+
+  FuncPtrZero = callback(&ret2);
+  FuncPtrOne = callback(&ret0);
+  FuncPtrTwo = callback(&ret1);
+
+  return 0;
+}
diff --git a/test/llvm_test_code/pointers/indirection_01.c b/test/llvm_test_code/pointers/indirection_01.c
new file mode 100644
index 0000000000..04cbec9efb
--- /dev/null
+++ b/test/llvm_test_code/pointers/indirection_01.c
@@ -0,0 +1,14 @@
+
+typedef struct _LinkedList {
+  int Val;
+  struct _LinkedList *Next;
+} LinkedList;
+
+int main() {
+  LinkedList Foo;
+  Foo = (LinkedList){0, &Foo};
+
+  LinkedList *Alias = Foo.Next;
+
+  return 0;
+}
diff --git a/test/llvm_test_code/pointers/indirection_02.c b/test/llvm_test_code/pointers/indirection_02.c
new file mode 100644
index 0000000000..f73aee5e16
--- /dev/null
+++ b/test/llvm_test_code/pointers/indirection_02.c
@@ -0,0 +1,26 @@
+
+typedef struct _LinkedList {
+  int Val;
+  struct _LinkedList *Next;
+} LinkedList;
+
+int main() {
+  LinkedList Foo;
+  Foo = (LinkedList){0, &Foo};
+
+  LinkedList Bar;
+  Bar = (LinkedList){42, &Foo};
+
+  LinkedList Baz = Bar;
+  LinkedList Boar = Baz;
+
+  Boar.Next = &Bar;
+  Baz.Next = &Boar;
+
+  LinkedList *AliasOne = Foo.Next;
+  LinkedList *AliasTwo = Bar.Next;
+  LinkedList *AliasThree = Baz.Next;
+  LinkedList *AliasFour = Boar.Next;
+
+  return 0;
+}
diff --git a/test/llvm_test_code/pointers/indirection_03.c b/test/llvm_test_code/pointers/indirection_03.c
new file mode 100644
index 0000000000..7ab9f3f11e
--- /dev/null
+++ b/test/llvm_test_code/pointers/indirection_03.c
@@ -0,0 +1,27 @@
+
+typedef struct _LinkedListOne {
+  int Val;
+  struct _LinkedListOne *Next;
+} LinkedListOne;
+
+typedef struct _LinkedListTwo {
+  int Val;
+  struct _LinkedListOne *Next;
+} LinkedListTwo;
+
+int main() {
+  LinkedListOne Foo;
+  Foo = (LinkedListOne){0, &Foo};
+  LinkedListTwo Bar;
+  Bar = (LinkedListTwo){42, &Foo};
+
+  LinkedListOne Baz = Foo;
+  LinkedListTwo Boar = Bar;
+
+  LinkedListOne *AliasOne = Foo.Next;
+  LinkedListOne *AliasTwo = Bar.Next;
+  LinkedListOne *AliasThree = Baz.Next;
+  LinkedListOne *AliasFour = Boar.Next;
+
+  return 0;
+}
diff --git a/test/llvm_test_code/pointers/indirection_04.c b/test/llvm_test_code/pointers/indirection_04.c
new file mode 100644
index 0000000000..1427dfcdb8
--- /dev/null
+++ b/test/llvm_test_code/pointers/indirection_04.c
@@ -0,0 +1,37 @@
+
+typedef struct _LinkedListOne {
+  int Val;
+  struct _LinkedListOne *Next;
+} LinkedListOne;
+
+typedef struct _LinkedListTwo {
+  int Val;
+  struct _LinkedListOne *Next;
+} LinkedListTwo;
+
+typedef struct _LinkedListThree {
+  int Val;
+  struct _LinkedListTwo *Next;
+} LinkedListThree;
+
+int main() {
+  LinkedListOne Foo;
+  Foo = (LinkedListOne){0, &Foo};
+  LinkedListTwo Bar;
+  Bar = (LinkedListTwo){42, &Foo};
+  LinkedListThree Baz;
+  Baz = (LinkedListThree){42, &Bar};
+
+  LinkedListOne One = Foo;
+  LinkedListTwo Two = Bar;
+  LinkedListThree Three = Baz;
+
+  LinkedListOne *AliasOne = One.Next;
+  LinkedListOne *AliasTwo = Two.Next;
+  LinkedListTwo *AliasThree = Three.Next;
+  LinkedListOne *AliasFour = Foo.Next;
+  LinkedListOne *AliasFive = Bar.Next;
+  LinkedListTwo *AliasSix = Baz.Next;
+
+  return 0;
+}
diff --git a/test/llvm_test_code/pointers/indirection_05.c b/test/llvm_test_code/pointers/indirection_05.c
new file mode 100644
index 0000000000..0259262280
--- /dev/null
+++ b/test/llvm_test_code/pointers/indirection_05.c
@@ -0,0 +1,47 @@
+
+typedef struct _LinkedListOne {
+  int Val;
+  struct _LinkedListOne *Next;
+} LinkedListOne;
+
+typedef struct _LinkedListTwo {
+  int Val;
+  struct _LinkedListOne *Next;
+} LinkedListTwo;
+
+typedef struct _LinkedListThree {
+  int Val;
+  struct _LinkedListTwo *Next;
+} LinkedListThree;
+
+typedef struct _LinkedListFour {
+  int Val;
+  struct _LinkedListThree *Next;
+} LinkedListFour;
+
+int main() {
+  LinkedListOne Foo;
+  Foo = (LinkedListOne){0, &Foo};
+  LinkedListTwo Bar;
+  Bar = (LinkedListTwo){42, &Foo};
+  LinkedListThree Baz;
+  Baz = (LinkedListThree){42, &Bar};
+  LinkedListFour Boar;
+  Boar = (LinkedListFour){42, &Baz};
+
+  LinkedListOne One = Foo;
+  LinkedListTwo Two = Bar;
+  LinkedListThree Three = Baz;
+  LinkedListFour Four = Boar;
+
+  LinkedListOne *AliasOne = One.Next;
+  LinkedListOne *AliasTwo = Two.Next;
+  LinkedListTwo *AliasThree = Three.Next;
+  LinkedListThree *AliasFour = Four.Next;
+  LinkedListOne *AliasFive = Foo.Next;
+  LinkedListOne *AliasSix = Bar.Next;
+  LinkedListTwo *AliasSeven = Baz.Next;
+  LinkedListThree *AliasEight = Boar.Next;
+
+  return 0;
+}
diff --git a/test/llvm_test_code/pointers/indirection_06.c b/test/llvm_test_code/pointers/indirection_06.c
new file mode 100644
index 0000000000..6bb0ce57c1
--- /dev/null
+++ b/test/llvm_test_code/pointers/indirection_06.c
@@ -0,0 +1,57 @@
+
+typedef struct _LinkedListOne {
+  int Val;
+  struct _LinkedListOne *Next;
+} LinkedListOne;
+
+typedef struct _LinkedListTwo {
+  int Val;
+  struct _LinkedListOne *Next;
+} LinkedListTwo;
+
+typedef struct _LinkedListThree {
+  int Val;
+  struct _LinkedListTwo *Next;
+} LinkedListThree;
+
+typedef struct _LinkedListFour {
+  int Val;
+  struct _LinkedListThree *Next;
+} LinkedListFour;
+
+typedef struct _LinkedListFive {
+  int Val;
+  struct _LinkedListFour *Next;
+} LinkedListFive;
+
+int main() {
+  LinkedListOne Foo;
+  Foo = (LinkedListOne){0, &Foo};
+  LinkedListTwo Bar;
+  Bar = (LinkedListTwo){42, &Foo};
+  LinkedListThree Baz;
+  Baz = (LinkedListThree){42, &Bar};
+  LinkedListFour Boar;
+  Boar = (LinkedListFour){42, &Baz};
+  LinkedListFive Far;
+  Far = (LinkedListFive){42, &Boar};
+
+  LinkedListOne One = Foo;
+  LinkedListTwo Two = Bar;
+  LinkedListThree Three = Baz;
+  LinkedListFour Four = Boar;
+  LinkedListFive Five = Far;
+
+  LinkedListOne *AliasOne = One.Next;
+  LinkedListOne *AliasTwo = Two.Next;
+  LinkedListTwo *AliasThree = Three.Next;
+  LinkedListThree *AliasFour = Four.Next;
+  LinkedListFour *AliasFive = Five.Next;
+  LinkedListOne *AliasSix = Foo.Next;
+  LinkedListOne *AliasSeven = Bar.Next;
+  LinkedListTwo *AliasEight = Baz.Next;
+  LinkedListThree *AliasNine = Boar.Next;
+  LinkedListFour *AliasTen = Far.Next;
+
+  return 0;
+}
diff --git a/test/llvm_test_code/pointers/indirection_07.c b/test/llvm_test_code/pointers/indirection_07.c
new file mode 100644
index 0000000000..495be86420
--- /dev/null
+++ b/test/llvm_test_code/pointers/indirection_07.c
@@ -0,0 +1,67 @@
+
+typedef struct _LinkedListOne {
+  int Val;
+  struct _LinkedListOne *Next;
+} LinkedListOne;
+
+typedef struct _LinkedListTwo {
+  int Val;
+  struct _LinkedListOne *Next;
+} LinkedListTwo;
+
+typedef struct _LinkedListThree {
+  int Val;
+  struct _LinkedListTwo *Next;
+} LinkedListThree;
+
+typedef struct _LinkedListFour {
+  int Val;
+  struct _LinkedListThree *Next;
+} LinkedListFour;
+
+typedef struct _LinkedListFive {
+  int Val;
+  struct _LinkedListFour *Next;
+} LinkedListFive;
+
+typedef struct _LinkedListSix {
+  int Val;
+  struct _LinkedListFive *Next;
+} LinkedListSix;
+
+int main() {
+  LinkedListOne Foo;
+  Foo = (LinkedListOne){0, &Foo};
+  LinkedListTwo Bar;
+  Bar = (LinkedListTwo){42, &Foo};
+  LinkedListThree Baz;
+  Baz = (LinkedListThree){42, &Bar};
+  LinkedListFour Boar;
+  Boar = (LinkedListFour){42, &Baz};
+  LinkedListFive Far;
+  Far = (LinkedListFive){42, &Boar};
+  LinkedListSix Faz;
+  Faz = (LinkedListSix){42, &Far};
+
+  LinkedListOne One = Foo;
+  LinkedListTwo Two = Bar;
+  LinkedListThree Three = Baz;
+  LinkedListFour Four = Boar;
+  LinkedListFive Five = Far;
+  LinkedListSix Six = Faz;
+
+  LinkedListOne *AliasOne = One.Next;
+  LinkedListOne *AliasTwo = Two.Next;
+  LinkedListTwo *AliasThree = Three.Next;
+  LinkedListThree *AliasFour = Four.Next;
+  LinkedListFour *AliasFive = Five.Next;
+  LinkedListFive *AliasSix = Six.Next;
+  LinkedListOne *AliasSeven = Foo.Next;
+  LinkedListOne *AliasEight = Bar.Next;
+  LinkedListTwo *AliasNine = Baz.Next;
+  LinkedListThree *AliasTen = Boar.Next;
+  LinkedListFour *AliasEleven = Far.Next;
+  LinkedListFive *AliasTwelve = Faz.Next;
+
+  return 0;
+}
diff --git a/test/llvm_test_code/pointers/indirection_08.cpp b/test/llvm_test_code/pointers/indirection_08.cpp
new file mode 100644
index 0000000000..be6f36f071
--- /dev/null
+++ b/test/llvm_test_code/pointers/indirection_08.cpp
@@ -0,0 +1,21 @@
+
+class Foo {
+public:
+  virtual int Func() { return 0; };
+};
+
+class Bar : public Foo {
+public:
+  int Func() override { return 1; };
+};
+
+int main() {
+  Foo First{};
+  Bar Second{};
+
+  Foo &SecondAlias = Second;
+
+  SecondAlias.Func();
+
+  return 0;
+}
diff --git a/test/llvm_test_code/pointers/indirection_09.cpp b/test/llvm_test_code/pointers/indirection_09.cpp
new file mode 100644
index 0000000000..41ae31ee0c
--- /dev/null
+++ b/test/llvm_test_code/pointers/indirection_09.cpp
@@ -0,0 +1,26 @@
+bool Bool = true;
+
+class Foo {
+public:
+  virtual int Func() { return 0; };
+};
+
+class Bar : public Foo {
+public:
+  int Func() override { return 1; };
+};
+
+class Baz : public Bar {
+public:
+  int Func() override { return 2; };
+};
+
+int main() {
+  Foo First{};
+  Bar Second{};
+  Baz Third{};
+
+  Foo &FooRef = Bool ? Second : Third;
+
+  return FooRef.Func();
+}
diff --git a/test/llvm_test_code/pointers/indirection_10.cpp b/test/llvm_test_code/pointers/indirection_10.cpp
new file mode 100644
index 0000000000..c744b1126f
--- /dev/null
+++ b/test/llvm_test_code/pointers/indirection_10.cpp
@@ -0,0 +1,28 @@
+
+class Foo {
+public:
+  virtual int Func() { return 0; };
+};
+
+class Bar : public Foo {
+public:
+  Foo *FooPtr;
+  int Func() override { return 1; };
+};
+
+class Baz : public Bar {
+public:
+  Foo *FooPtr;
+  int Func() override { return FooPtr->Func(); };
+};
+
+int main() {
+  Foo First{};
+  Bar Second{};
+
+  Foo &SecondAlias = Second;
+
+  SecondAlias.Func();
+
+  return 0;
+}
diff --git a/tools/phasar-cli/Controller/AnalysisControllerInternalIDE.h b/tools/phasar-cli/Controller/AnalysisControllerInternalIDE.h
index 789157a75e..80b9c3ef82 100644
--- a/tools/phasar-cli/Controller/AnalysisControllerInternalIDE.h
+++ b/tools/phasar-cli/Controller/AnalysisControllerInternalIDE.h
@@ -56,7 +56,7 @@ template <typename SolverTy, typename ProblemTy, typename... ArgTys>
 static void executeSparseIfdsIdeAnalysis(AnalysisController &Data,
                                          ArgTys &&...Args) {
 
-  SparseLLVMBasedICFGView SVFG(&Data.HA->getICFG(), &Data.HA->getAliasInfo());
+  SparseLLVMBasedICFGView SVFG(&Data.HA->getICFG(), Data.HA->getAliasInfo());
   executeIfdsIdeAnalysisImpl<SolverTy, ProblemTy>(
       Data, SVFG, std::forward<ArgTys>(Args)...);
 }
diff --git a/tools/phasar-cli/phasar-cli.cpp b/tools/phasar-cli/phasar-cli.cpp
index 0169441aae..e5d5e90d6e 100644
--- a/tools/phasar-cli/phasar-cli.cpp
+++ b/tools/phasar-cli/phasar-cli.cpp
@@ -13,10 +13,11 @@
 #include "phasar/ControlFlow/CallGraphData.h"
 #include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
 #include "phasar/PhasarLLVM/HelperAnalyses.h"
+#include "phasar/PhasarLLVM/HelperAnalysisConfig.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasSetData.h"
 #include "phasar/PhasarLLVM/Utils/DataFlowAnalysisType.h"
 #include "phasar/Pointer/AliasAnalysisType.h"
-#include "phasar/Utils/IO.h"
+#include "phasar/Pointer/UnionFindAliasAnalysisType.h"
 #include "phasar/Utils/InitPhasar.h"
 #include "phasar/Utils/Logger.h"
 #include "phasar/Utils/Soundness.h"
@@ -118,6 +119,16 @@ cl::opt<AliasAnalysisType> AliasTypeOpt(
 cl::alias AliasTypeAlias("P", cl::aliasopt(AliasTypeOpt),
                          cl::desc("Alias for --alias-analysis"),
                          cl::cat(PsrCat));
+cl::opt<UnionFindAliasAnalysisType> UFAliasTypeOpt(
+    "union-find-aa",
+    cl::desc(
+        "The union-find alias analysis type to use (default: ctx-ind-sens)"),
+    cl::init(UnionFindAliasAnalysisType::CtxIndSens), cl::cat(PsrCat),
+    values({
+#define UNIONFIND_ALIAS_ANALYSIS_TYPE(NAME, CMDFLAG, DESC)                     \
+  clEnumValN(UnionFindAliasAnalysisType::NAME, CMDFLAG, DESC),
+#include "phasar/Pointer/UnionFindAAType.def"
+    }));
 
 cl::opt<CallGraphAnalysisType>
     CGTypeOpt("call-graph-analysis",
@@ -460,27 +471,32 @@ int main(int Argc, const char **Argv) {
     EntryOpt.push_back("main");
   }
 
-  // setup IRDB as source code manager
-  HelperAnalyses HA(std::move(ModuleOpt.getValue()),
-                    std::move(PrecomputedAliasSet), AliasTypeOpt,
-                    !AnalysisController::needsToEmitPTA(EmitterOptions),
-                    EntryOpt, std::move(PrecomputedCallGraph), CGTypeOpt,
-                    SoundnessOpt, AutoGlobalsOpt);
+  HelperAnalysisConfig HAConfig{
+      .PrecomputedCG = std::move(PrecomputedCallGraph),
+      .PTATy = AliasTypeOpt,
+      .UFAATy = UFAliasTypeOpt,
+      .CGTy = CGTypeOpt,
+      .SoundnessLevel = SoundnessOpt,
+      .AutoGlobalSupport = AutoGlobalsOpt,
+      .AllowLazyPTS = !AnalysisController::needsToEmitPTA(EmitterOptions),
+  };
+  HelperAnalyses HA(std::move(ModuleOpt.getValue()), EntryOpt,
+                    std::move(HAConfig));
   if (!HA.getProjectIRDB().isValid()) {
     // Note: Error message has already been printed
     return 1;
   }
 
   AnalysisController Controller{
-      &HA,
-      DataFlowAnalysisOpt,
-      {AnalysisConfigOpt.getValue()},
-      EntryOpt,
-      StrategyOpt,
-      EmitterOptions,
-      SolverConfig,
-      ProjectIdOpt.getValue(),
-      OutDirOpt.getValue(),
+      .HA = &HA,
+      .DataFlowAnalyses = DataFlowAnalysisOpt,
+      .AnalysisConfigs = {AnalysisConfigOpt.getValue()},
+      .EntryPoints = EntryOpt,
+      .Strategy = StrategyOpt,
+      .EmitterOptions = EmitterOptions,
+      .SolverConfig = SolverConfig,
+      .ProjectID = ProjectIdOpt.getValue(),
+      .ResultDirectory = OutDirOpt.getValue(),
   };
   if (!OutDirOpt.empty()) {
     // create directory for results
diff --git a/tools/ptaben/AliasQueryType.cpp b/tools/ptaben/AliasQueryType.cpp
new file mode 100755
index 0000000000..22fec3d15a
--- /dev/null
+++ b/tools/ptaben/AliasQueryType.cpp
@@ -0,0 +1,85 @@
+#include "AliasQueryType.h"
+
+#include "phasar/Pointer/AliasResult.h"
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/ErrorHandling.h"
+
+#include <array>
+
+using namespace psr;
+
+llvm::StringRef ptaben::to_string(AliasQueryType QueryType) noexcept {
+  switch (QueryType) {
+#define ALIAS_QUERY_TYPE(NAME)                                                 \
+  case AliasQueryType::NAME:                                                   \
+    return #NAME;
+#include "AliasQueryType.inc"
+  }
+  llvm_unreachable(
+      "All AliasQueryType variants should be handled in the switch above");
+}
+
+static constexpr size_t NumQueryTypes = 0
+#define ALIAS_QUERY_TYPE(NAME) +1
+#include "AliasQueryType.inc"
+    ;
+
+struct NamedQuery {
+  llvm::StringRef Name{};
+  ptaben::AliasQueryType QueryType{};
+};
+
+static constexpr std::array<NamedQuery, NumQueryTypes>
+getSortedQueryTypes() noexcept {
+  using namespace psr;
+  std::array<NamedQuery, NumQueryTypes> AllQueries = {{
+#define ALIAS_QUERY_TYPE(NAME) {#NAME, ptaben::AliasQueryType::NAME},
+#include "AliasQueryType.inc"
+  }};
+
+  // std::sort is not constexpr
+  for (size_t I = 0; I < AllQueries.size(); ++I) {
+    auto Max = I;
+    for (size_t J = I + 1; J < AllQueries.size(); ++J) {
+      if (AllQueries[J].Name.size() > AllQueries[Max].Name.size())
+        Max = J;
+    }
+    auto Tmp = AllQueries[I];
+    AllQueries[I] = AllQueries[Max];
+    AllQueries[Max] = Tmp;
+  }
+
+  return AllQueries;
+}
+
+auto ptaben::parseAliasQueryType(llvm::StringRef Str) noexcept
+    -> std::optional<AliasQueryType> {
+  static constexpr auto AllQueries = getSortedQueryTypes();
+
+  for (const auto &NQ : AllQueries) {
+    if (Str.contains(NQ.Name)) {
+      return NQ.QueryType;
+    }
+  }
+
+  return std::nullopt;
+}
+
+auto ptaben::getExpectedAliasResult(AliasQueryType QT) noexcept -> AliasResult {
+  switch (QT) {
+  case AliasQueryType::MAYALIAS:
+  case AliasQueryType::EXPECTEDFAILMAYALIAS:
+  case AliasQueryType::PARTIALALIAS:
+    return AliasResult::MayAlias;
+  case AliasQueryType::MUSTALIAS:
+  case AliasQueryType::EXPECTEDFAILMUSTALIAS:
+    return AliasResult::MustAlias;
+  case AliasQueryType::NOALIAS:
+  case AliasQueryType::EXPECTEDFAILNOALIAS:
+    return AliasResult::NoAlias;
+  }
+
+  llvm_unreachable(
+      "All alias query types should be handled in the switch above");
+}
diff --git a/tools/ptaben/AliasQueryType.h b/tools/ptaben/AliasQueryType.h
new file mode 100755
index 0000000000..443851b8c3
--- /dev/null
+++ b/tools/ptaben/AliasQueryType.h
@@ -0,0 +1,30 @@
+#pragma once
+
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#include "phasar/Pointer/AliasResult.h"
+
+#include "llvm/ADT/StringRef.h"
+
+#include <optional>
+
+namespace psr::ptaben {
+enum class AliasQueryType {
+#define ALIAS_QUERY_TYPE(NAME) NAME,
+#include "AliasQueryType.inc"
+};
+
+[[nodiscard]] llvm::StringRef to_string(AliasQueryType QueryType) noexcept;
+[[nodiscard]] std::optional<AliasQueryType>
+parseAliasQueryType(llvm::StringRef Str) noexcept;
+
+[[nodiscard]] AliasResult getExpectedAliasResult(AliasQueryType QT) noexcept;
+
+} // namespace psr::ptaben
diff --git a/tools/ptaben/AliasQueryType.inc b/tools/ptaben/AliasQueryType.inc
new file mode 100755
index 0000000000..755ace23c4
--- /dev/null
+++ b/tools/ptaben/AliasQueryType.inc
@@ -0,0 +1,13 @@
+#ifndef ALIAS_QUERY_TYPE
+#error "You have to #define ALIAS_QUERY_TYPE(NAME) before including AliasQueryType.inc"
+#endif
+
+ALIAS_QUERY_TYPE(MAYALIAS)
+ALIAS_QUERY_TYPE(MUSTALIAS)
+ALIAS_QUERY_TYPE(NOALIAS)
+ALIAS_QUERY_TYPE(PARTIALALIAS)
+ALIAS_QUERY_TYPE(EXPECTEDFAILMAYALIAS)
+ALIAS_QUERY_TYPE(EXPECTEDFAILMUSTALIAS)
+ALIAS_QUERY_TYPE(EXPECTEDFAILNOALIAS)
+
+#undef ALIAS_QUERY_TYPE
diff --git a/tools/ptaben/PTAResult.cpp b/tools/ptaben/PTAResult.cpp
new file mode 100644
index 0000000000..445410c776
--- /dev/null
+++ b/tools/ptaben/PTAResult.cpp
@@ -0,0 +1,6 @@
+#include "PTAResult.h"
+
+llvm::raw_ostream &psr::ptaben::operator<<(llvm::raw_ostream &OS,
+                                           PTAResult Res) {
+  return OS << uint64_t(Res.Query) << ", " << to_string(Res.Result);
+}
diff --git a/tools/ptaben/PTAResult.h b/tools/ptaben/PTAResult.h
new file mode 100755
index 0000000000..429b990ff2
--- /dev/null
+++ b/tools/ptaben/PTAResult.h
@@ -0,0 +1,27 @@
+#pragma once
+
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#include "phasar/Pointer/AliasResult.h"
+
+#include "llvm/Support/raw_ostream.h"
+
+#include "QueryId.h"
+
+namespace psr::ptaben {
+
+struct PTAResult {
+  QueryId Query{};
+  AliasResult Result{};
+};
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, PTAResult Res);
+
+} // namespace psr::ptaben
diff --git a/tools/ptaben/PTAUtils.cpp b/tools/ptaben/PTAUtils.cpp
new file mode 100755
index 0000000000..e200fc2bce
--- /dev/null
+++ b/tools/ptaben/PTAUtils.cpp
@@ -0,0 +1,128 @@
+#include "PTAUtils.h"
+
+#include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
+#include "phasar/Pointer/AliasResult.h"
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/IR/InstIterator.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/Module.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/SHA256.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include "AliasQueryType.h"
+
+#include <cstdint>
+
+using namespace psr;
+
+bool ptaben::isSoundResult(const QueryResult &QR) noexcept {
+  auto Res = QR.Result;
+  auto ExpectedRes = getExpectedAliasResult(QR.QueryType);
+
+  return Res == ExpectedRes || Res == AliasResult::MayAlias;
+}
+
+llvm::raw_ostream &ptaben::operator<<(llvm::raw_ostream &OS,
+                                      const QueryResult &Result) {
+  OS << "Query at " << psr::llvmIRToString(Result.Inst) << " expected "
+     << to_string(Result.QueryType) << ", but got " << to_string(Result.Result);
+  return OS;
+}
+
+llvm::raw_ostream &ptaben::operator<<(llvm::raw_ostream &OS,
+                                      const QueryLocation &Result) {
+  return OS << "Query at " << psr::llvmIRToString(Result.Inst);
+}
+
+static ptaben::QueryId getQueryId(llvm::StringRef FileName, uint32_t SeqNo) {
+  llvm::SHA256 Hasher;
+  Hasher.update(FileName);
+
+  {
+    std::array<uint8_t, 4> Buf{};
+    llvm::support::endian::write32(Buf.data(), SeqNo,
+                                   llvm::support::endianness::little);
+    Hasher.update(Buf);
+  }
+
+  auto Hash = Hasher.final();
+
+  auto QId = llvm::support::endian::read64(Hash.data(),
+                                           llvm::support::endianness::little);
+
+  return ptaben::QueryId(QId);
+}
+
+void ptaben::findAllQueryLocations(
+    const llvm::Module &Mod, llvm::SmallVectorImpl<QueryLocation> &Locs,
+    llvm::SmallVectorImpl<QuerySrcCodeLocation> *SrcLocs) {
+  const auto &FilePath = Mod.getSourceFileName();
+  auto FileName = llvm::sys::path::filename(FilePath);
+  uint32_t Ctr = 0;
+
+  for (const auto &Fun : Mod.functions()) {
+    for (const auto &Inst : llvm::instructions(Fun)) {
+      if (const auto *Call = llvm::dyn_cast<llvm::CallBase>(&Inst);
+          Call && Call->getCalledFunction()) {
+        if (auto QueryType =
+                parseAliasQueryType(Call->getCalledFunction()->getName())) {
+          auto QId = getQueryId(FileName, Ctr++);
+          Locs.push_back(QueryLocation{QId, Call, *QueryType});
+
+          if (SrcLocs) {
+            SrcLocs->push_back(QuerySrcCodeLocation{FilePath, Ctr});
+          }
+        }
+      }
+    }
+  }
+}
+
+bool ptaben::verifyAnalysisResult(AliasResult Res,
+                                  const QueryLocation &QueryLoc) {
+  switch (QueryLoc.QueryType) {
+    using enum ptaben::AliasQueryType;
+  case EXPECTEDFAILMAYALIAS:
+    if (Res != psr::AliasResult::MayAlias) {
+      llvm::outs() << "[INFO]: Failed EXPECTEDFAIL_MAYALIAS at" << QueryLoc
+                   << '\n';
+    }
+    return true;
+  case PARTIALALIAS:
+    // We don't support partial alias. Use may alias instead.
+    [[fallthrough]];
+  case MAYALIAS:
+    if (Res == psr::AliasResult::MayAlias) {
+      return true;
+    }
+    break;
+
+  case EXPECTEDFAILMUSTALIAS:
+    if (Res != psr::AliasResult::MustAlias) {
+      llvm::outs() << "[INFO]: Failed EXPECTEDFAIL_MUSTALIAS at" << QueryLoc
+                   << '\n';
+    }
+    return true;
+  case MUSTALIAS:
+    if (Res == psr::AliasResult::MustAlias) {
+      return true;
+    }
+    break;
+
+  case EXPECTEDFAILNOALIAS:
+    if (Res != psr::AliasResult::NoAlias) {
+      llvm::outs() << "[INFO]: Failed EXPECTEDFAIL_NOALIAS at" << QueryLoc
+                   << '\n';
+    }
+    return true;
+  case NOALIAS:
+    if (Res == psr::AliasResult::NoAlias) {
+      return true;
+    }
+    break;
+  }
+
+  return false;
+}
diff --git a/tools/ptaben/PTAUtils.h b/tools/ptaben/PTAUtils.h
new file mode 100755
index 0000000000..e9e920ac40
--- /dev/null
+++ b/tools/ptaben/PTAUtils.h
@@ -0,0 +1,87 @@
+#pragma once
+
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#include "phasar/Pointer/AliasResult.h"
+
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Twine.h"
+#include "llvm/Support/FileSystem.h"
+
+#include "QueryLocation.h"
+
+#include <functional>
+#include <type_traits>
+
+namespace llvm {
+class Module;
+class Value;
+class Instruction;
+class raw_ostream;
+} // namespace llvm
+
+namespace psr::ptaben {
+struct QueryResult : QueryLocation {
+  AliasResult Result{};
+};
+
+struct QuerySrcCodeLocation {
+  std::string FileName{};
+  size_t QueryIndex{};
+};
+
+[[nodiscard]] bool isSoundResult(const QueryResult &QR) noexcept;
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const QueryResult &Result);
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+                              const QueryLocation &Result);
+
+void findAllQueryLocations(
+    const llvm::Module &Mod, llvm::SmallVectorImpl<QueryLocation> &Locs,
+    llvm::SmallVectorImpl<QuerySrcCodeLocation> *SrcLocs = nullptr);
+
+[[nodiscard]] bool verifyAnalysisResult(AliasResult Res,
+                                        const QueryLocation &QueryLoc);
+
+template <typename CheckFn>
+std::enable_if_t<std::is_invocable_r_v<bool, CheckFn, llvm::StringRef>>
+checkDir(const llvm::Twine &DirName,
+         llvm::SmallVectorImpl<std::string> &Failures, CheckFn Check) {
+  std::error_code EC;
+  llvm::sys::fs::recursive_directory_iterator It(DirName, EC, false);
+  llvm::sys::fs::recursive_directory_iterator End;
+
+  size_t NumTests = 0;
+
+  static constexpr auto IsLLVMIRFile = [](llvm::StringRef Path) {
+    return Path.endswith(".ll") || Path.endswith(".bc");
+  };
+
+  for (; It != End && !EC; It.increment(EC)) {
+    auto Ty = It->type();
+    llvm::StringRef Path = It->path();
+    if (Ty == llvm::sys::fs::file_type::regular_file && IsLLVMIRFile(Path)) {
+      ++NumTests;
+
+      if (!std::invoke(Check, Path)) {
+        Failures.push_back(Path.str());
+      }
+    }
+  }
+
+  llvm::outs() << "Analyzed " << NumTests << " Benchmark files\n";
+
+  if (EC) {
+    llvm::errs() << "[ERROR]: " << EC.message() << '\n';
+  }
+}
+} // namespace psr::ptaben
diff --git a/tools/ptaben/QueryId.h b/tools/ptaben/QueryId.h
new file mode 100755
index 0000000000..972df391b5
--- /dev/null
+++ b/tools/ptaben/QueryId.h
@@ -0,0 +1,17 @@
+#pragma once
+
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#include <cstdint>
+
+namespace psr::ptaben {
+enum class [[clang::enum_extensibility(open)]] QueryId : uint64_t {};
+
+} // namespace psr::ptaben
diff --git a/tools/ptaben/QueryLocation.h b/tools/ptaben/QueryLocation.h
new file mode 100755
index 0000000000..368247a0ea
--- /dev/null
+++ b/tools/ptaben/QueryLocation.h
@@ -0,0 +1,26 @@
+#pragma once
+
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#include "AliasQueryType.h"
+#include "QueryId.h"
+
+namespace llvm {
+class Instruction;
+} // namespace llvm
+
+namespace psr::ptaben {
+
+struct QueryLocation {
+  QueryId Id{};
+  const llvm::Instruction *Inst{};
+  AliasQueryType QueryType{};
+};
+} // namespace psr::ptaben
diff --git a/tools/ptaben/QuerySer.h b/tools/ptaben/QuerySer.h
new file mode 100755
index 0000000000..55ee864f3d
--- /dev/null
+++ b/tools/ptaben/QuerySer.h
@@ -0,0 +1,29 @@
+#pragma once
+
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#include "llvm/Support/raw_ostream.h"
+
+#include "PTAUtils.h"
+#include "QueryLocation.h"
+
+namespace psr::ptaben {
+
+class QuerySerializer {
+public:
+  explicit QuerySerializer(llvm::raw_ostream *OS);
+
+  void handleQuery(const QueryLocation &QueryLoc,
+                   const QuerySrcCodeLocation &QuerySrcLoc);
+
+private:
+  llvm::raw_ostream *OS{};
+};
+} // namespace psr::ptaben
diff --git a/tools/ptaben/QuerySerializer.cpp b/tools/ptaben/QuerySerializer.cpp
new file mode 100755
index 0000000000..32c19565c5
--- /dev/null
+++ b/tools/ptaben/QuerySerializer.cpp
@@ -0,0 +1,16 @@
+#include "AliasQueryType.h"
+#include "PTAUtils.h"
+#include "QuerySer.h"
+
+using namespace psr::ptaben;
+
+QuerySerializer::QuerySerializer(llvm::raw_ostream *OS) : OS(OS) {
+  assert(OS != nullptr);
+  *OS << "Query, QueryType, FileName, Index\n";
+}
+
+void QuerySerializer::handleQuery(const QueryLocation &QueryLoc,
+                                  const QuerySrcCodeLocation &QuerySrcLoc) {
+  *OS << uint64_t(QueryLoc.Id) << ", " << to_string(QueryLoc.QueryType) << ", "
+      << QuerySrcLoc.FileName << ", " << QuerySrcLoc.QueryIndex << '\n';
+}
diff --git a/tools/ptaben/README.md b/tools/ptaben/README.md
new file mode 100644
index 0000000000..8fdb75307f
--- /dev/null
+++ b/tools/ptaben/README.md
@@ -0,0 +1,28 @@
+# PTABen Benchmark Tool
+
+A sample tool that can be used to benchmark PhASAR's alias analyses against SVF's [Test Suite](https://github.com/SVF-tools/Test-Suite).
+
+To use this tool, we expect that you have a folder with the compiled LLVM bitcode of the relevant PTABen benchmark files that you care about.
+Just provide the path to that folder to `tools/ptaben/ptaben`. It will run the alias analyses on each LLVM bitcode file in that folder (and subfolders) and output a .csv file per alias analysis + one for the ground-truth.
+
+## Supported Analyses
+
+Currently, the benchmark tool supports the following analyses:
+
+- LLVM's CFLAndersen analysis, wrapped into `psr::LLVMAliasSet`
+- LLVM's CFLSteensgaard analysis, wrapped into `psr::LLVMAliasSet`
+- PhASAR's context-sensitive union-find analysis (same as if passing `--alias-analysis=union-find --union-find-aa=ctx-sens` to `phasar-cli`)
+- PhASAR's indirection-sensitive union-find analysis (same as if passing `--alias-analysis=union-find --union-find-aa=ind-sens` to `phasar-cli`)
+- PhASAR's bottom-up context-sensitive union-find analysis (same as if passing `--alias-analysis=union-find --union-find-aa=botctx-sens` to `phasar-cli`)
+- PhASAR's context-sensitive indirection-sensitive union-find analysis (same as if passing `--alias-analysis=union-find --union-find-aa=ctx-ind-sens` to `phasar-cli`)
+- PhASAR's bottom-up context-sensitive indirection-sensitive union-find analysis (same as if passing `--alias-analysis=union-find --union-find-aa=botctx-ind-sens` to `phasar-cli`)
+
+Of course, you can extend this tool and provide your own analyses here.
+
+## Preliminary Results
+
+|           | anders | steens | ctx-sens | bot-sens | ind-sens | ctx-ind-sens | bot-ctx-ind-sens |
+|-----------|--------|--------|----------|----------|----------|--------------|------------------|
+| precision | 0.712  | 0.709  | 0.803    | 0.800    | 0.681    | 0.803        | 0.800            |
+| recall    | 0.961  | 0.975  | 0.929    | 0.667    | 0.960    | 0.929        | 0.667            |
+| f1score   | 0.818  | 0.821  | 0.862    | 0.728    | 0.796    | 0.862        | 0.728            |
diff --git a/tools/ptaben/ResultCollector.cpp b/tools/ptaben/ResultCollector.cpp
new file mode 100755
index 0000000000..173276c93c
--- /dev/null
+++ b/tools/ptaben/ResultCollector.cpp
@@ -0,0 +1,12 @@
+#include "ResultsCollector.h"
+
+using namespace psr::ptaben;
+
+ResultCollector::ResultCollector(llvm::raw_ostream *OS,
+                                 llvm::StringRef ResultName)
+    : OS(OS) {
+  assert(OS != nullptr);
+  *OS << "Query, " << ResultName << '\n';
+}
+
+void ResultCollector::handleResult(PTAResult Result) { *OS << Result << '\n'; }
diff --git a/tools/ptaben/ResultsCollector.h b/tools/ptaben/ResultsCollector.h
new file mode 100755
index 0000000000..273098e44f
--- /dev/null
+++ b/tools/ptaben/ResultsCollector.h
@@ -0,0 +1,26 @@
+#pragma once
+
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#include "llvm/Support/raw_ostream.h"
+
+#include "PTAResult.h"
+
+namespace psr::ptaben {
+class ResultCollector {
+public:
+  explicit ResultCollector(llvm::raw_ostream *OS, llvm::StringRef ResultName);
+
+  void handleResult(PTAResult Result);
+
+private:
+  llvm::raw_ostream *OS{};
+};
+}; // namespace psr::ptaben
diff --git a/tools/ptaben/ptaben_benchmark_tool.cpp b/tools/ptaben/ptaben_benchmark_tool.cpp
new file mode 100644
index 0000000000..a59feaa4e7
--- /dev/null
+++ b/tools/ptaben/ptaben_benchmark_tool.cpp
@@ -0,0 +1,199 @@
+#include "phasar/PhasarLLVM/ControlFlow/EntryFunctionUtils.h"
+#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCallGraph.h"
+#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCallGraphBuilder.h"
+#include "phasar/PhasarLLVM/ControlFlow/LLVMVFTableProvider.h"
+#include "phasar/PhasarLLVM/ControlFlow/Resolver/RTAResolver.h"
+#include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMAliasSet.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h"
+#include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
+#include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
+#include "phasar/Pointer/AliasAnalysisType.h"
+#include "phasar/Pointer/AliasResult.h"
+#include "phasar/Pointer/UnionFindAliasAnalysisType.h"
+#include "phasar/Utils/IO.h"
+
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/IR/Instruction.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include "PTAUtils.h"
+#include "QuerySer.h"
+#include "ResultsCollector.h"
+
+#include <string>
+
+namespace cl = llvm::cl;
+
+static cl::OptionCategory PTABenCat("PTABen Benhchmark Tool");
+
+static cl::opt<std::string> IRPath(cl::Positional, cl::Required,
+                                   cl::desc("ptaben-ir-directory"),
+                                   cl::cat(PTABenCat));
+static cl::opt<std::string>
+    QueryTablePath("queries-table",
+                   cl::desc("The Output-Path to the queries table"),
+                   cl::init("queries.csv"), cl::cat(PTABenCat));
+static cl::opt<std::string>
+    AndersTablePath("anders-table",
+                    cl::desc("The Output-Path to the anders output table"),
+                    cl::init("anders-results.csv"), cl::cat(PTABenCat));
+static cl::opt<std::string>
+    SteensTablePath("steens-table",
+                    cl::desc("The Output-Path to the steens output table"),
+                    cl::init("steens-results.csv"), cl::cat(PTABenCat));
+static cl::opt<std::string>
+    CtxTablePath("ctx-table",
+                 cl::desc("The Output-Path to the ctx output table"),
+                 cl::init("ctx-results.csv"), cl::cat(PTABenCat));
+static cl::opt<std::string>
+    BotTablePath("bot-table",
+                 cl::desc("The Output-Path to the bot output table"),
+                 cl::init("bot-results.csv"), cl::cat(PTABenCat));
+static cl::opt<std::string>
+    IndTablePath("ind-table",
+                 cl::desc("The Output-Path to the ind output table"),
+                 cl::init("ind-results.csv"), cl::cat(PTABenCat));
+static cl::opt<std::string>
+    CtxIndTablePath("ctx-ind-table",
+                    cl::desc("The Output-Path to the ctx-ind output table"),
+                    cl::init("ctx-ind-results.csv"), cl::cat(PTABenCat));
+static cl::opt<std::string> BotCtxIndTablePath(
+    "bot-ctx-ind-table",
+    cl::desc("The Output-Path to the bot-ctx-ind output table"),
+    cl::init("bot-ctx-ind-results.csv"), cl::cat(PTABenCat));
+
+static psr::AliasResult
+checkLLVMQueryLoc(psr::LLVMAliasInfoRef ComputedAliasResult,
+                  const llvm::Instruction *QueryInst) {
+  const auto *Ptr1 = QueryInst->getOperand(0);
+  const auto *Ptr2 = QueryInst->getOperand(1);
+
+  return ComputedAliasResult.alias(Ptr1, Ptr2, QueryInst);
+}
+
+static void
+performAndersAnalysis(psr::LLVMProjectIRDB &IRDB,
+                      llvm::ArrayRef<psr::ptaben::QueryLocation> QueryLocs,
+                      psr::ptaben::ResultCollector &RC) {
+  psr::LLVMAliasSet AliasSet(&IRDB, false, psr::AliasAnalysisType::CFLAnders);
+
+  for (const auto &Loc : QueryLocs) {
+    auto Res = checkLLVMQueryLoc(&AliasSet, Loc.Inst);
+    RC.handleResult(psr::ptaben::PTAResult{.Query = Loc.Id, .Result = Res});
+  }
+}
+
+static void
+performSteensAnalysis(psr::LLVMProjectIRDB &IRDB,
+                      llvm::ArrayRef<psr::ptaben::QueryLocation> QueryLocs,
+                      psr::ptaben::ResultCollector &RC) {
+  psr::LLVMAliasSet AliasSet(&IRDB, false, psr::AliasAnalysisType::CFLSteens);
+
+  for (const auto &Loc : QueryLocs) {
+    auto Res = checkLLVMQueryLoc(&AliasSet, Loc.Inst);
+    RC.handleResult(psr::ptaben::PTAResult{.Query = Loc.Id, .Result = Res});
+  }
+}
+
+static void performUnionFindAliasAnalysis(
+    psr::LLVMProjectIRDB &IRDB, const psr::LLVMBasedCallGraph &BaseCG,
+    llvm::ArrayRef<psr::ptaben::QueryLocation> QueryLocs,
+    psr::ptaben::ResultCollector &RC, psr::UnionFindAliasAnalysisType AType) {
+  auto AliasSet = psr::LLVMUnionFindAliasSet(
+      &IRDB, BaseCG,
+      psr::LLVMUnionFindAliasSet::Config{
+          .AType = AType,
+          .ALocality = psr::LLVMUnionFindAliasSet::AnalysisLocality::Global,
+      });
+
+  for (const auto &Loc : QueryLocs) {
+    auto Res = checkLLVMQueryLoc(&AliasSet, Loc.Inst);
+    RC.handleResult(psr::ptaben::PTAResult{.Query = Loc.Id, .Result = Res});
+  }
+}
+
+static auto openFileOrExit(llvm::StringRef Filepath) {
+  auto File = psr::openFileForWrite(Filepath);
+  if (!File) {
+    std::exit(1);
+  }
+  return File;
+}
+
+int main(int Argc, char *Argv[]) {
+  cl::HideUnrelatedOptions(PTABenCat);
+  cl::ParseCommandLineOptions(Argc, Argv);
+
+  auto QFile = openFileOrExit(QueryTablePath);
+  auto AndersFile = openFileOrExit(AndersTablePath);
+  auto SteensFile = openFileOrExit(SteensTablePath);
+  auto CtxFile = openFileOrExit(CtxTablePath);
+  auto BotFile = openFileOrExit(BotTablePath);
+  auto IndFile = openFileOrExit(IndTablePath);
+  auto CtxIndFile = openFileOrExit(CtxIndTablePath);
+  auto BotCtxIndFile = openFileOrExit(BotCtxIndTablePath);
+
+  psr::ptaben::QuerySerializer QSer(QFile.get());
+  psr::ptaben::ResultCollector AndersSer(AndersFile.get(), "AndersResult");
+  psr::ptaben::ResultCollector SteensSer(SteensFile.get(), "SteensResult");
+  psr::ptaben::ResultCollector CtxSer(CtxFile.get(), "CtxResult");
+  psr::ptaben::ResultCollector BotSer(BotFile.get(), "BotResult");
+  psr::ptaben::ResultCollector IndSer(IndFile.get(), "IndResult");
+  psr::ptaben::ResultCollector CtxIndSer(CtxIndFile.get(), "CtxIndResult");
+  psr::ptaben::ResultCollector BotCtxIndSer(BotCtxIndFile.get(),
+                                            "BotCtxIndResult");
+
+  llvm::SmallVector<std::string, 4> Failures;
+  psr::ptaben::checkDir(IRPath, Failures, [&](llvm::StringRef FileName) {
+    llvm::errs() << "Analyzing " << FileName << '\n';
+
+    psr::LLVMProjectIRDB IRDB(FileName);
+    auto *Mod = IRDB.getModule();
+    if (!Mod) {
+      return false;
+    }
+
+    llvm::SmallVector<psr::ptaben::QueryLocation, 4> QueryLocs;
+    llvm::SmallVector<psr::ptaben::QuerySrcCodeLocation> QuerySrcLocs;
+    psr::ptaben::findAllQueryLocations(*Mod, QueryLocs, &QuerySrcLocs);
+
+    if (QueryLocs.empty()) {
+      llvm::errs()
+          << "[NOTE]: File does not contain any alias queries. Skip it.\n";
+      return true;
+    }
+
+    for (const auto &[QLoc, QSrcLoc] : llvm::zip(QueryLocs, QuerySrcLocs)) {
+      QSer.handleQuery(QLoc, QSrcLoc);
+    }
+
+    using psr::UnionFindAliasAnalysisType;
+
+    performAndersAnalysis(IRDB, QueryLocs, AndersSer);
+    performSteensAnalysis(IRDB, QueryLocs, SteensSer);
+
+    auto VTP = psr::LLVMVFTableProvider(IRDB);
+    auto TH = psr::DIBasedTypeHierarchy(IRDB);
+    auto Res = psr::RTAResolver(&IRDB, &VTP, &TH);
+    const auto BaseCG = buildLLVMBasedCallGraph(
+        IRDB, Res, getEntryFunctions(IRDB, psr::getDefaultEntryPoints(IRDB)));
+
+    performUnionFindAliasAnalysis(IRDB, BaseCG, QueryLocs, CtxSer,
+                                  UnionFindAliasAnalysisType::CtxSens);
+    performUnionFindAliasAnalysis(IRDB, BaseCG, QueryLocs, BotSer,
+                                  UnionFindAliasAnalysisType::BotCtxSens);
+    performUnionFindAliasAnalysis(IRDB, BaseCG, QueryLocs, IndSer,
+                                  UnionFindAliasAnalysisType::IndSens);
+    performUnionFindAliasAnalysis(IRDB, BaseCG, QueryLocs, CtxIndSer,
+                                  UnionFindAliasAnalysisType::CtxIndSens);
+    performUnionFindAliasAnalysis(IRDB, BaseCG, QueryLocs, BotCtxIndSer,
+                                  UnionFindAliasAnalysisType::BotCtxIndSens);
+
+    return true;
+  });
+}
diff --git a/unittests/PhasarLLVM/Pointer/CMakeLists.txt b/unittests/PhasarLLVM/Pointer/CMakeLists.txt
index 290062d69e..7a8857df82 100644
--- a/unittests/PhasarLLVM/Pointer/CMakeLists.txt
+++ b/unittests/PhasarLLVM/Pointer/CMakeLists.txt
@@ -2,6 +2,7 @@ set(PointerFlowSources
 	LLVMAliasSetTest.cpp
 	LLVMAliasSetSerializationTest.cpp
 	FilteredLLVMAliasSetTest.cpp
+	LLVMUnionFindAATest.cpp
 )
 
 if (PHASAR_USE_SVF)
diff --git a/unittests/PhasarLLVM/Pointer/LLVMAliasSetSerializationTest.cpp b/unittests/PhasarLLVM/Pointer/LLVMAliasSetSerializationTest.cpp
index 496aeff6b1..7755eddc6c 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMAliasSetSerializationTest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMAliasSetSerializationTest.cpp
@@ -94,7 +94,7 @@ static void analyze(llvm::StringRef File, const GroundTruthTy &Gt,
 }
 
 TEST(LLVMAliasSetSerializationTest, Ser_Intra01) {
-  analyze("pointers/basic_01_cpp.ll", {{{"1"}, {"0", "3"}}, {"main"}});
+  analyze("pointers/basic_01_c.ll", {{{"1"}, {"0", "3"}}, {"main"}});
 }
 
 TEST(LLVMAliasSetSerializationTest, Ser_Inter01) {
diff --git a/unittests/PhasarLLVM/Pointer/LLVMAliasSetTest.cpp b/unittests/PhasarLLVM/Pointer/LLVMAliasSetTest.cpp
index 15208cccc5..88e9abcb44 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMAliasSetTest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMAliasSetTest.cpp
@@ -18,8 +18,7 @@ using namespace psr;
 
 TEST(LLVMAliasSet, Intra_01) {
   ValueAnnotationPass::resetValueID();
-  LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles +
-                       "pointers/basic_01_cpp.ll");
+  LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles + "pointers/basic_01_c.ll");
 
   LLVMAliasSet PTS(&IRDB, false);
   const auto *Main = IRDB.getFunctionDefinition("main");
diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
new file mode 100644
index 0000000000..1ef4b9b867
--- /dev/null
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -0,0 +1,7318 @@
+#include "phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h"
+
+#include "phasar/ControlFlow/CallGraphAnalysisType.h"
+#include "phasar/ControlFlow/CallGraphBase.h"
+#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCallGraph.h"
+#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCallGraphBuilder.h"
+#include "phasar/PhasarLLVM/ControlFlow/LLVMVFTableProvider.h"
+#include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h"
+#include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
+#include "phasar/Pointer/BottomupUnionFindAA.h"
+#include "phasar/Pointer/PointerAssignmentGraph.h"
+#include "phasar/Pointer/RawAliasSet.h"
+#include "phasar/Pointer/UnionFindAA.h"
+#include "phasar/Utils/ValueCompressor.h"
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/IR/Instruction.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include "SrcCodeLocationEntry.h"
+#include "TestConfig.h"
+#include "gtest/gtest.h"
+
+#include <map>
+#include <source_location>
+#include <vector>
+
+namespace {
+using namespace psr;
+
+constexpr auto PathToLLFiles = PHASAR_BUILD_SUBFOLDER("pointers/");
+
+[[nodiscard]] ValueId asId(const ValueCompressor<PAGVariable> &VC,
+                           const LLVMProjectIRDB &IRDB,
+                           unittest::TestingSrcLocation Var) {
+
+  const auto *LLVMVar = unittest::testingLocInIR(Var, IRDB);
+  return VC.getOrNull(LLVMVar).value();
+}
+
+[[nodiscard]] RawAliasSet<ValueId>
+asIdBased(const ValueCompressor<PAGVariable> &VC, const LLVMProjectIRDB &IRDB,
+          llvm::ArrayRef<unittest::TestingSrcLocation> AliasSet) {
+  RawAliasSet<ValueId> Ret;
+
+  for (auto Var : AliasSet) {
+    const auto *LLVMVar = unittest::testingLocInIR(Var, IRDB);
+    Ret.insert(VC.getOrNull(LLVMVar).value());
+  }
+
+  return Ret;
+}
+
+[[nodiscard]] std::string stringifyVal(const ValueCompressor<PAGVariable> &VC,
+                                       ValueId Id) {
+  std::string Ret;
+  llvm::raw_string_ostream ROS(Ret);
+
+  ROS << "{ ";
+
+  const auto &LLVMVars = VC.id2vars(Id);
+  llvm::interleaveComma(LLVMVars, ROS, [&](PAGVariable Var) {
+    // XXX: Should we map back to TestingSrcLocation?
+    ROS << to_string(Var);
+  });
+
+  ROS << " }";
+
+  return Ret;
+}
+
+using GTMap = std::map<unittest::TestingSrcLocation,
+                       std::vector<unittest::TestingSrcLocation>>;
+
+void doAnalysisAndCompareResults(
+    const llvm::Twine &IRFile, const GTMap &ExpectedResults,
+    std::invocable<const LLVMProjectIRDB &, const LLVMBasedCallGraph &> auto
+        AABuilder,
+    std::source_location Loc = std::source_location::current()) {
+
+  auto IRDB = LLVMProjectIRDB::loadOrExit(PathToLLFiles + IRFile);
+  auto TH = DIBasedTypeHierarchy(IRDB);
+  auto VTP = LLVMVFTableProvider(IRDB);
+  auto BaseCG = buildLLVMBasedCallGraph(IRDB, CallGraphAnalysisType::RTA,
+                                        {"main"}, TH, VTP);
+
+  ValueCompressor<PAGVariable> VC;
+  UnionFindAAResult auto Results =
+      computeUnionFindAARaw(IRDB, AABuilder(IRDB, BaseCG), &VC);
+
+  for (const auto &[PtrVar, ExpectedAliasVars] : ExpectedResults) {
+    const auto PtrId = asId(VC, IRDB, PtrVar);
+    const auto ExpectedAliasIds = asIdBased(VC, IRDB, ExpectedAliasVars);
+
+    const RawAliasSet<ValueId> &ComputedAliasIds =
+        Results.getRawAliasSet(PtrId);
+
+    ExpectedAliasIds.foreach ([&](ValueId VId) {
+      if (!ComputedAliasIds.contains(VId)) {
+        ADD_FAILURE_AT(Loc.file_name(), Loc.line())
+            << "Did not compute expected alias of " << PtrVar << ": "
+            << stringifyVal(VC, VId);
+      }
+    });
+
+    ComputedAliasIds.foreach ([&](ValueId VId) {
+      if (ExpectedAliasIds.contains(VId)) {
+        return;
+      }
+
+      const auto &Vars = VC.id2vars(VId);
+      if (llvm::any_of(Vars, [](PAGVariable Var) {
+            if (Var.isReturnVariable()) {
+              return true;
+            }
+
+            if (llvm::isa<llvm::LoadInst>(Var.valueOrNull())) {
+              return true;
+            }
+
+            return false;
+          })) {
+        return;
+      }
+      ADD_FAILURE_AT(Loc.file_name(), Loc.line())
+          << "Computed unexpected alias of " << PtrVar << ": "
+          << stringifyVal(VC, VId);
+    });
+  }
+
+  if (::testing::Test::HasFailure()) {
+    llvm::errs() << "ValueCompressor: {\n";
+    for (const auto &[VId, Values] : VC.id2vars().enumerate()) {
+      llvm::errs() << "  #" << uint32_t(VId) << ":\n";
+      for (const auto Val : Values) {
+        llvm::errs() << "    " << to_string(Val) << '\n';
+      }
+    }
+    llvm::errs() << "}\n";
+    Results.dump();
+  }
+}
+
+using namespace psr::unittest;
+
+constexpr auto ContextAABuilder = [](const auto &IRDB, const auto &CG) {
+  return CallingContextSensUnionFindAA<LLVMPAGDomain>{
+      &CG,
+      &IRDB,
+  };
+};
+
+constexpr auto IndAABuilder = [](const auto & /*IRDB*/, const auto &CG) {
+  auto Ret = pag::PBMixin{
+      IndirectionSensUnionFindAA<LLVMPAGDomain>{},
+      pag::LLVMCGProvider{&CG},
+  };
+
+  static_assert(pag::PBStrategy<decltype(Ret)>);
+  return Ret;
+};
+
+constexpr auto BotAABuilder = [](const auto &IRDB, const auto &CG) {
+  auto Ret = BottomupUnionFindAA<LLVMPAGDomain>{
+      ReverseCGGraph{
+          &CG,
+          &IRDB,
+      },
+  };
+
+  static_assert(pag::PBStrategy<decltype(Ret)>);
+  return Ret;
+};
+
+[[maybe_unused]] constexpr auto TracingBuilder = [](auto &&Builder) {
+  return [Builder = PSR_FWD(Builder)](const auto &IRDB, const auto &CG) {
+    return pag::PBStrategyCombinator{
+        std::invoke(Builder, IRDB, CG),
+        pag::TracingPBStrategy{},
+    };
+  };
+};
+
+TEST(CtxSensUnionFindAATest, Basic01) {
+  GTMap GT = {{LineColFunOp{.Line = 3,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 3,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 5,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+  doAnalysisAndCompareResults("basic_01_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Basic02) {
+  GTMap GT = {{LineColFunOp{.Line = 3,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 3,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 4,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 6,
+                                .Col = 4,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+                   LineColFunOp{.Line = 6,
+                                .Col = 5,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 5,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 5,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("basic_02_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Basic03) {
+  GTMap GT = {{LineColFunOp{.Line = 5,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 5,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("basic_03_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Basic04) {
+  GTMap GT = {{LineColFunOp{.Line = 5,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   FuncByName{.NameOfFunction = "Func"},
+                   LineColFunOp{.Line = 5,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 11,
+                                .Col = 11,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+                   LineColFunOp{.Line = 11,
+                                .Col = 12,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("basic_04_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context01) {
+  GTMap GT = {{LineColFunOp{.Line = 5,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {ArgInFun{.Idx = 0, .InFunction = "id"},
+                LineColFunOp{.Line = 2,
+                             .Col = 26,
+                             .InFunction = "id",
+                             .OpCode = llvm::Instruction::Load},
+                RetVal{.InFunction = "id"},
+                LineColFunOp{.Line = 5,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 6,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   ArgInFun{.Idx = 0, .InFunction = "id"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 26,
+                                .InFunction = "id",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id"},
+                   LineColFunOp{.Line = 6,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   ArgInFun{.Idx = 0, .InFunction = "id"},
+               }},
+              {LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("context_01_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context02) {
+  GTMap GT = {{LineColFunOp{.Line = 6,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   ArgInFun{.Idx = 0, .InFunction = "id1"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 27,
+                                .InFunction = "id1",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id1"},
+                   LineColFunOp{.Line = 6,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 14,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 7,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   ArgInFun{.Idx = 0, .InFunction = "id2"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 27,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id2"},
+                   LineColFunOp{.Line = 7,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+               }},
+              {LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 10,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 10,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 11,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_02_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context03) {
+  GTMap GT = {{LineColFunOp{.Line = 6,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   ArgInFun{.Idx = 0, .InFunction = "id1"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 0,
+                                .InFunction = "id1",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id1"},
+                   ArgInFun{.Idx = 0, .InFunction = "id2"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 0,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 3,
+                                .Col = 31,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id2"},
+                   LineColFunOp{.Line = 6,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_03_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context04_0) {
+  GTMap GT = {{LineColFunOp{.Line = 7,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   ArgInFun{.Idx = 0, .InFunction = "id1"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 0,
+                                .InFunction = "id1",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id1"},
+                   ArgInFun{.Idx = 0, .InFunction = "id2"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 0,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 3,
+                                .Col = 31,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id2"},
+                   ArgInFun{.Idx = 0, .InFunction = "id3"},
+                   LineColFunOp{.Line = 4,
+                                .Col = 0,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 4,
+                                .Col = 31,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id3"},
+                   LineColFunOp{.Line = 7,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 10,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 10,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_04_0_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context04_1) {
+  GTMap GT = {{LineColFunOp{.Line = 7,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   ArgInFun{.Idx = 0, .InFunction = "id1"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 0,
+                                .InFunction = "id1",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id1"},
+                   ArgInFun{.Idx = 0, .InFunction = "id2"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 0,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 3,
+                                .Col = 31,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id2"},
+                   ArgInFun{.Idx = 0, .InFunction = "id3"},
+                   LineColFunOp{.Line = 4,
+                                .Col = 0,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 4,
+                                .Col = 31,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id3"},
+                   LineColFunOp{.Line = 7,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 13,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 15,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 10,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 10,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 11,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_04_1_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context05_0) {
+  GTMap GT = {{LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   ArgInFun{.Idx = 0, .InFunction = "id1"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 0,
+                                .InFunction = "id1",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id1"},
+                   ArgInFun{.Idx = 0, .InFunction = "id2"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 0,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 3,
+                                .Col = 31,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id2"},
+                   ArgInFun{.Idx = 0, .InFunction = "id3"},
+                   LineColFunOp{.Line = 4,
+                                .Col = 0,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 4,
+                                .Col = 31,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id3"},
+                   ArgInFun{.Idx = 0, .InFunction = "id4"},
+                   LineColFunOp{.Line = 5,
+                                .Col = 0,
+                                .InFunction = "id4",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 5,
+                                .Col = 31,
+                                .InFunction = "id4",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id4"},
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 13,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 10,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 10,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 11,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_05_0_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context05_1) {
+  GTMap GT = {{LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   ArgInFun{.Idx = 0, .InFunction = "id1"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 0,
+                                .InFunction = "id1",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id1"},
+                   ArgInFun{.Idx = 0, .InFunction = "id2"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 0,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 3,
+                                .Col = 31,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id2"},
+                   ArgInFun{.Idx = 0, .InFunction = "id3"},
+                   LineColFunOp{.Line = 4,
+                                .Col = 0,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 4,
+                                .Col = 31,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id3"},
+                   ArgInFun{.Idx = 0, .InFunction = "id4"},
+                   LineColFunOp{.Line = 5,
+                                .Col = 0,
+                                .InFunction = "id4",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 5,
+                                .Col = 31,
+                                .InFunction = "id4",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id4"},
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 13,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 14,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 16,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 11,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 14,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_05_1_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context06_0) {
+  GTMap GT = {{LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   ArgInFun{.Idx = 0, .InFunction = "id1"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 0,
+                                .InFunction = "id1",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id1"},
+                   ArgInFun{.Idx = 0, .InFunction = "id2"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 0,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 3,
+                                .Col = 31,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id2"},
+                   ArgInFun{.Idx = 0, .InFunction = "id3"},
+                   LineColFunOp{.Line = 4,
+                                .Col = 0,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 4,
+                                .Col = 31,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id3"},
+                   ArgInFun{.Idx = 0, .InFunction = "id4"},
+                   LineColFunOp{.Line = 5,
+                                .Col = 0,
+                                .InFunction = "id4",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 5,
+                                .Col = 31,
+                                .InFunction = "id4",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id4"},
+                   ArgInFun{.Idx = 0, .InFunction = "id5"},
+                   LineColFunOp{.Line = 6,
+                                .Col = 0,
+                                .InFunction = "id5",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 6,
+                                .Col = 31,
+                                .InFunction = "id5",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id5"},
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 14,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 11,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_06_0_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context06_1) {
+  GTMap GT = {{LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {ArgInFun{.Idx = 0, .InFunction = "id1"},
+                LineColFunOp{.Line = 2,
+                             .Col = 0,
+                             .InFunction = "id1",
+                             .OpCode = llvm::Instruction::Load},
+                RetVal{.InFunction = "id1"},
+                ArgInFun{.Idx = 0, .InFunction = "id2"},
+                LineColFunOp{.Line = 3,
+                             .Col = 0,
+                             .InFunction = "id2",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 3,
+                             .Col = 31,
+                             .InFunction = "id2",
+                             .OpCode = llvm::Instruction::Load},
+                RetVal{.InFunction = "id2"},
+                ArgInFun{.Idx = 0, .InFunction = "id3"},
+                LineColFunOp{.Line = 4,
+                             .Col = 0,
+                             .InFunction = "id3",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 4,
+                             .Col = 31,
+                             .InFunction = "id3",
+                             .OpCode = llvm::Instruction::Load},
+                RetVal{.InFunction = "id3"},
+                ArgInFun{.Idx = 0, .InFunction = "id4"},
+                LineColFunOp{.Line = 5,
+                             .Col = 0,
+                             .InFunction = "id4",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 5,
+                             .Col = 31,
+                             .InFunction = "id4",
+                             .OpCode = llvm::Instruction::Load},
+                RetVal{.InFunction = "id4"},
+                ArgInFun{.Idx = 0, .InFunction = "id5"},
+                LineColFunOp{.Line = 6,
+                             .Col = 0,
+                             .InFunction = "id5",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 6,
+                             .Col = 31,
+                             .InFunction = "id5",
+                             .OpCode = llvm::Instruction::Load},
+                RetVal{.InFunction = "id5"},
+                LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 10,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 17,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 14,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 15,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_06_1_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context07) {
+  GTMap GT = {{LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   ArgInFun{.Idx = 0, .InFunction = "buzz"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 0,
+                                .InFunction = "buzz",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "buzz"},
+                   ArgInFun{.Idx = 0, .InFunction = "baz"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 0,
+                                .InFunction = "baz",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 3,
+                                .Col = 32,
+                                .InFunction = "baz",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "baz"},
+                   ArgInFun{.Idx = 0, .InFunction = "bar"},
+                   LineColFunOp{.Line = 4,
+                                .Col = 0,
+                                .InFunction = "bar",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 4,
+                                .Col = 31,
+                                .InFunction = "bar",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "bar"},
+                   ArgInFun{.Idx = 0, .InFunction = "foo"},
+                   LineColFunOp{.Line = 5,
+                                .Col = 0,
+                                .InFunction = "foo",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 5,
+                                .Col = 31,
+                                .InFunction = "foo",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "foo"},
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 14,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 11,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_07_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context08) {
+  GTMap GT = {{LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   ArgInFun{.Idx = 0, .InFunction = "selfRecursion"},
+                   LineColFunOp{.Line = 4,
+                                .Col = 0,
+                                .InFunction = "selfRecursion",
+                                .OpCode = llvm::Instruction::Load},
+                   LineColFunOp{.Line = 7,
+                                .Col = 0,
+                                .InFunction = "selfRecursion",
+                                .OpCode = llvm::Instruction::Load},
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "selfRecursion",
+                                .OpCode = llvm::Instruction::Load},
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "selfRecursion",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "selfRecursion"},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 15,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 19,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 21,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 15,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 19,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 19,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_08_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context09_0) {
+  GTMap GT = {{LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {ArgInFun{.Idx = 0, .InFunction = "selfRecursion"},
+                LineColFunOp{.Line = 4,
+                             .Col = 0,
+                             .InFunction = "selfRecursion",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 7,
+                             .Col = 0,
+                             .InFunction = "selfRecursion",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "selfRecursion",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "selfRecursion",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "selfRecursion"},
+                LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 16,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 18,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 15,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 16,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 16,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_09_0_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context09_1) {
+  GTMap GT = {
+      {LineColFunOp{.Line = 12,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {ArgInFun{.Idx = 0, .InFunction = "selfRecursion"},
+        LineColFunOp{.Line = 4,
+                     .Col = 0,
+                     .InFunction = "selfRecursion",
+                     .OpCode = llvm::Instruction::Load},
+        LineColFunOp{.Line = 7,
+                     .Col = 0,
+                     .InFunction = "selfRecursion",
+                     .OpCode = llvm::Instruction::Load},
+        LineColFunOp{.Line = 8,
+                     .Col = 0,
+                     .InFunction = "selfRecursion",
+                     .OpCode = llvm::Instruction::Load},
+        LineColFunOp{.Line = 8,
+                     .Col = 0,
+                     .InFunction = "selfRecursion",
+                     .OpCode = llvm::Instruction::Call},
+        RetVal{.InFunction = "selfRecursion"},
+        LineColFunOp{.Line = 12,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca},
+        LineColFunOp{.Line = 13,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca},
+        LineColFunOp{.Line = 15,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Call},
+        LineColFunOp{.Line = 17,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Call},
+        LineColFunOp{.Line = 18,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Call},
+        LineColFunOp{.Line = 20,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Call},
+        LineColFunOp{.Line = 22,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Load}}},
+      {LineColFunOp{.Line = 15,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {LineColFunOp{.Line = 15,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca}}},
+      {LineColFunOp{.Line = 17,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {LineColFunOp{.Line = 17,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca}}},
+      {LineColFunOp{.Line = 18,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {LineColFunOp{.Line = 18,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca}}},
+      {LineColFunOp{.Line = 20,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {LineColFunOp{.Line = 20,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca}}},
+  };
+
+  doAnalysisAndCompareResults("context_09_1_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context10_0) {
+  GTMap GT = {
+      {LineColFunOp{.Line = 24,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {ArgInFun{.Idx = 0, .InFunction = "Forth"},
+        LineColFunOp{.Line = 6,
+                     .Col = 0,
+                     .InFunction = "Forth",
+                     .OpCode = llvm::Instruction::Load},
+        LineColFunOp{.Line = 7,
+                     .Col = 0,
+                     .InFunction = "Forth",
+                     .OpCode = llvm::Instruction::Load},
+        LineColFunOp{.Line = 7,
+                     .Col = 0,
+                     .InFunction = "Forth",
+                     .OpCode = llvm::Instruction::Call},
+        LineColFunOp{.Line = 10,
+                     .Col = 0,
+                     .InFunction = "Forth",
+                     .OpCode = llvm::Instruction::Load},
+        RetVal{.InFunction = "Forth"}, ArgInFun{.Idx = 0, .InFunction = "Back"},
+        LineColFunOp{.Line = 15,
+                     .Col = 0,
+                     .InFunction = "Back",
+                     .OpCode = llvm::Instruction::Load},
+        LineColFunOp{.Line = 16,
+                     .Col = 0,
+                     .InFunction = "Back",
+                     .OpCode = llvm::Instruction::Load},
+        LineColFunOp{.Line = 16,
+                     .Col = 0,
+                     .InFunction = "Back",
+                     .OpCode = llvm::Instruction::Call},
+        LineColFunOp{.Line = 19,
+                     .Col = 0,
+                     .InFunction = "Back",
+                     .OpCode = llvm::Instruction::Load},
+        RetVal{.InFunction = "Back"},
+        LineColFunOp{.Line = 24,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca},
+        LineColFunOp{.Line = 26,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Call},
+        LineColFunOp{.Line = 30,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Call},
+        LineColFunOp{.Line = 32,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Load}}},
+      {LineColFunOp{.Line = 26,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {LineColFunOp{.Line = 26,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca}}},
+      {LineColFunOp{.Line = 30,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {LineColFunOp{.Line = 30,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_10_0_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context10_1) {
+  GTMap GT = {
+      {LineColFunOp{.Line = 24,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {ArgInFun{.Idx = 0, .InFunction = "Forth"},
+        LineColFunOp{.Line = 6,
+                     .Col = 0,
+                     .InFunction = "Forth",
+                     .OpCode = llvm::Instruction::Load},
+        LineColFunOp{.Line = 7,
+                     .Col = 0,
+                     .InFunction = "Forth",
+                     .OpCode = llvm::Instruction::Load},
+        LineColFunOp{.Line = 7,
+                     .Col = 0,
+                     .InFunction = "Forth",
+                     .OpCode = llvm::Instruction::Call},
+        LineColFunOp{.Line = 10,
+                     .Col = 0,
+                     .InFunction = "Forth",
+                     .OpCode = llvm::Instruction::Load},
+        RetVal{.InFunction = "Forth"}, ArgInFun{.Idx = 0, .InFunction = "Back"},
+        LineColFunOp{.Line = 15,
+                     .Col = 0,
+                     .InFunction = "Back",
+                     .OpCode = llvm::Instruction::Load},
+        LineColFunOp{.Line = 16,
+                     .Col = 0,
+                     .InFunction = "Back",
+                     .OpCode = llvm::Instruction::Load},
+        LineColFunOp{.Line = 16,
+                     .Col = 0,
+                     .InFunction = "Back",
+                     .OpCode = llvm::Instruction::Call},
+        LineColFunOp{.Line = 19,
+                     .Col = 0,
+                     .InFunction = "Back",
+                     .OpCode = llvm::Instruction::Load},
+        RetVal{.InFunction = "Back"},
+        LineColFunOp{.Line = 24,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca},
+        LineColFunOp{.Line = 25,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca},
+        LineColFunOp{.Line = 27,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Call},
+        LineColFunOp{.Line = 29,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Call},
+        LineColFunOp{.Line = 31,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Call},
+        LineColFunOp{.Line = 33,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Call},
+        LineColFunOp{.Line = 35,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Load}}},
+      {LineColFunOp{.Line = 27,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {LineColFunOp{.Line = 27,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca}}},
+      {LineColFunOp{.Line = 29,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {LineColFunOp{.Line = 29,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca}}},
+      {LineColFunOp{.Line = 31,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {LineColFunOp{.Line = 31,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca}}},
+      {LineColFunOp{.Line = 33,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {LineColFunOp{.Line = 33,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_10_1_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context11_0) {
+  GTMap GT{{LineColFunOp{.Line = 33,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {ArgInFun{.Idx = 0, .InFunction = "Forth"},
+             LineColFunOp{.Line = 7,
+                          .Col = 0,
+                          .InFunction = "Forth",
+                          .OpCode = llvm::Instruction::Load},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "Forth",
+                          .OpCode = llvm::Instruction::Load},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "Forth",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "Forth",
+                          .OpCode = llvm::Instruction::Load},
+             RetVal{.InFunction = "Forth"},
+             ArgInFun{.Idx = 0, .InFunction = "Back"},
+             LineColFunOp{.Line = 16,
+                          .Col = 0,
+                          .InFunction = "Back",
+                          .OpCode = llvm::Instruction::Load},
+             LineColFunOp{.Line = 17,
+                          .Col = 0,
+                          .InFunction = "Back",
+                          .OpCode = llvm::Instruction::Load},
+             LineColFunOp{.Line = 17,
+                          .Col = 0,
+                          .InFunction = "Back",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 20,
+                          .Col = 0,
+                          .InFunction = "Back",
+                          .OpCode = llvm::Instruction::Load},
+             RetVal{.InFunction = "Back"},
+             ArgInFun{.Idx = 0, .InFunction = "Stop"},
+             LineColFunOp{.Line = 25,
+                          .Col = 0,
+                          .InFunction = "Stop",
+                          .OpCode = llvm::Instruction::Load},
+             LineColFunOp{.Line = 25,
+                          .Col = 0,
+                          .InFunction = "Stop",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 28,
+                          .Col = 0,
+                          .InFunction = "Stop",
+                          .OpCode = llvm::Instruction::Load},
+             LineColFunOp{.Line = 28,
+                          .Col = 0,
+                          .InFunction = "Stop",
+                          .OpCode = llvm::Instruction::Call},
+             RetVal{.InFunction = "Stop"},
+             LineColFunOp{.Line = 33,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 34,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 36,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 37,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 39,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 36,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 36,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 37,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 37,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_11_0_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context11_1) {
+  GTMap GT{{LineColFunOp{.Line = 33,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {ArgInFun{.Idx = 0, .InFunction = "Forth"},
+             LineColFunOp{.Line = 7,
+                          .Col = 0,
+                          .InFunction = "Forth",
+                          .OpCode = llvm::Instruction::Load},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "Forth",
+                          .OpCode = llvm::Instruction::Load},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "Forth",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "Forth",
+                          .OpCode = llvm::Instruction::Load},
+             RetVal{.InFunction = "Forth"},
+             ArgInFun{.Idx = 0, .InFunction = "Back"},
+             LineColFunOp{.Line = 16,
+                          .Col = 0,
+                          .InFunction = "Back",
+                          .OpCode = llvm::Instruction::Load},
+             LineColFunOp{.Line = 17,
+                          .Col = 0,
+                          .InFunction = "Back",
+                          .OpCode = llvm::Instruction::Load},
+             LineColFunOp{.Line = 17,
+                          .Col = 0,
+                          .InFunction = "Back",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 20,
+                          .Col = 0,
+                          .InFunction = "Back",
+                          .OpCode = llvm::Instruction::Load},
+             RetVal{.InFunction = "Back"},
+             ArgInFun{.Idx = 0, .InFunction = "Stop"},
+             LineColFunOp{.Line = 25,
+                          .Col = 0,
+                          .InFunction = "Stop",
+                          .OpCode = llvm::Instruction::Load},
+             LineColFunOp{.Line = 25,
+                          .Col = 0,
+                          .InFunction = "Stop",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 28,
+                          .Col = 0,
+                          .InFunction = "Stop",
+                          .OpCode = llvm::Instruction::Load},
+             LineColFunOp{.Line = 28,
+                          .Col = 0,
+                          .InFunction = "Stop",
+                          .OpCode = llvm::Instruction::Call},
+             RetVal{.InFunction = "Stop"},
+             LineColFunOp{.Line = 33,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 34,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 36,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 37,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 38,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 39,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 41,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 36,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 36,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 37,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 37,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 38,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 38,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 39,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 39,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_11_1_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context12_0) {
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {ArgInFun{.Idx = 0, .InFunction = "argretq"},
+             ArgInFun{.Idx = 1, .InFunction = "argretq"},
+             LineColFunOp{.Line = 2,
+                          .Col = 0,
+                          .InFunction = "argretq",
+                          .OpCode = llvm::Instruction::Load},
+             RetVal{.InFunction = "argretq"},
+             LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 9,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 13,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 6,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {ArgInFun{.Idx = 0, .InFunction = "argretq"},
+             ArgInFun{.Idx = 1, .InFunction = "argretq"},
+             LineColFunOp{.Line = 2,
+                          .Col = 0,
+                          .InFunction = "argretq",
+                          .OpCode = llvm::Instruction::Load},
+             RetVal{.InFunction = "argretq"},
+             LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 10,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_12_0_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context12_1) {
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {ArgInFun{.Idx = 0, .InFunction = "argretq"},
+             ArgInFun{.Idx = 1, .InFunction = "argretq"},
+             LineColFunOp{.Line = 2,
+                          .Col = 0,
+                          .InFunction = "argretq",
+                          .OpCode = llvm::Instruction::Load},
+             RetVal{.InFunction = "argretq"},
+             LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 6,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {ArgInFun{.Idx = 0, .InFunction = "argretq"},
+             ArgInFun{.Idx = 1, .InFunction = "argretq"},
+             LineColFunOp{.Line = 2,
+                          .Col = 0,
+                          .InFunction = "argretq",
+                          .OpCode = llvm::Instruction::Load},
+             RetVal{.InFunction = "argretq"},
+             LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 9,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_12_1_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context13_0) {
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {ArgInFun{.Idx = 0, .InFunction = "argretq"},
+             ArgInFun{.Idx = 1, .InFunction = "argretq"},
+             ArgInFun{.Idx = 2, .InFunction = "argretq"},
+             LineColFunOp{.Line = 2,
+                          .Col = 0,
+                          .InFunction = "argretq",
+                          .OpCode = llvm::Instruction::Load},
+             RetVal{.InFunction = "argretq"},
+             LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 9,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 10,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 17,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 6,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {ArgInFun{.Idx = 0, .InFunction = "argretq"},
+             ArgInFun{.Idx = 1, .InFunction = "argretq"},
+             ArgInFun{.Idx = 2, .InFunction = "argretq"},
+             LineColFunOp{.Line = 2,
+                          .Col = 0,
+                          .InFunction = "argretq",
+                          .OpCode = llvm::Instruction::Load},
+             RetVal{.InFunction = "argretq"},
+             LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 12,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 13,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 14,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 15,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_13_0_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context13_1) {
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {ArgInFun{.Idx = 0, .InFunction = "argretq"},
+             ArgInFun{.Idx = 1, .InFunction = "argretq"},
+             ArgInFun{.Idx = 2, .InFunction = "argretq"},
+             LineColFunOp{.Line = 2,
+                          .Col = 0,
+                          .InFunction = "argretq",
+                          .OpCode = llvm::Instruction::Load},
+             RetVal{.InFunction = "argretq"},
+             LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call}}},
+           {LineColFunOp{.Line = 6,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {ArgInFun{.Idx = 0, .InFunction = "argretq"},
+             ArgInFun{.Idx = 1, .InFunction = "argretq"},
+             ArgInFun{.Idx = 2, .InFunction = "argretq"},
+             LineColFunOp{.Line = 2,
+                          .Col = 0,
+                          .InFunction = "argretq",
+                          .OpCode = llvm::Instruction::Load},
+             RetVal{.InFunction = "argretq"},
+             LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 9,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}}};
+
+  doAnalysisAndCompareResults("context_13_1_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context14_0) {
+  GTMap GT{{LineColFunOp{.Line = 7,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 7,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_14_0_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context14_1) {
+  GTMap GT{{LineColFunOp{.Line = 9,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 9,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_14_1_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context14_2) {
+  GTMap GT{{LineColFunOp{.Line = 11,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("context_14_2_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Indirection01) {
+  GTMap GT = {{LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 11,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_01_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Indirection02) {
+  GTMap GT = {{LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 9,
+                             .Col = 21,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 21,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 20,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 21,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 21,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 22,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 23,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_02_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Indirection03) {
+  GTMap GT = {{LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 16,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 18,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 19,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 21,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 24,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 21,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 21,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 22,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 23,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 24,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 24,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_03_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Indirection04) {
+  GTMap GT = {{LineColFunOp{.Line = 18,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 18,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 19,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 21,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 25,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 26,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 27,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 29,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 30,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 31,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 29,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 29,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 30,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 30,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 31,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 31,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 32,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 33,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 34,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_04_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Indirection05) {
+  GTMap GT = {{LineColFunOp{.Line = 23,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 24,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 25,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 26,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 27,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 28,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 29,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 30,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 35,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 37,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 38,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 39,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 40,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 41,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 42,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 43,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 44,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 37,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 37,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 38,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 38,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 39,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 39,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 40,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 40,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 41,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 41,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 42,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 42,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 43,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 43,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 44,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 44,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_05_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Indirection06) {
+  GTMap GT = {{LineColFunOp{.Line = 28,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 28,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 29,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 30,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 31,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 35,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 36,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 37,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 39,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 40,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 41,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 42,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 43,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 45,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 46,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 47,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 48,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 49,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 50,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 51,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 52,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 53,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 54,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 45,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 45,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 46,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 46,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 47,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 47,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 48,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 48,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 49,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 49,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 50,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 50,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 51,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 51,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 52,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 52,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 53,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 53,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 54,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 54,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_06_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Indirection07) {
+  GTMap GT = {{LineColFunOp{.Line = 33,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 35,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 36,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 37,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 38,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 39,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 40,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 41,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 42,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 43,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 44,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 46,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 47,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 48,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 49,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 50,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 51,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 53,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 54,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 55,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 56,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 57,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 58,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 59,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 60,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 61,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 62,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 63,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 64,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 53,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 53,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 54,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 54,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 55,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 55,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 56,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 56,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 57,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 57,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 58,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 58,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 59,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 59,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 60,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 60,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 61,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 61,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 62,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 62,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 63,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 63,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 64,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 64,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_07_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Indirection08) {
+  GTMap GT = {{LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {ArgInFun{.Idx = 0, .InFunction = "_ZN3FooC2Ev"},
+                ArgInFun{.Idx = 0, .InFunction = "_ZN3BarC2Ev"},
+                ArgInFun{.Idx = 0, .InFunction = "_ZN3Foo4FuncEv"},
+                ArgInFun{.Idx = 0, .InFunction = "_ZN3Bar4FuncEv"},
+                GlobalVar{.Name = "_ZTV3Foo"},
+                GlobalVar{.Name = "_ZTVN10__cxxabiv117__class_type_infoE"},
+                GlobalVar{.Name = "_ZTS3Foo"}, GlobalVar{.Name = "_ZTI3Foo"},
+                GlobalVar{.Name = "_ZTV3Bar"},
+                GlobalVar{.Name = "_ZTVN10__cxxabiv120__si_class_type_infoE"},
+                GlobalVar{.Name = "_ZTS3Bar"}, GlobalVar{.Name = "_ZTI3Bar"},
+                FuncByName{.NameOfFunction = "_ZN3Foo4FuncEv"},
+                FuncByName{.NameOfFunction = "_ZN3Bar4FuncEv"},
+                LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 16,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 16,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_08_cpp_dbg.ll", GT,
+                              ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Indirection09) {
+  GTMap GT = {{LineColFunOp{.Line = 19,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {ArgInFun{.Idx = 0, .InFunction = "_ZN3FooC2Ev"},
+                ArgInFun{.Idx = 0, .InFunction = "_ZN3BarC2Ev"},
+                ArgInFun{.Idx = 0, .InFunction = "_ZN3BazC2Ev"},
+                ArgInFun{.Idx = 0, .InFunction = "_ZN3Foo4FuncEv"},
+                ArgInFun{.Idx = 0, .InFunction = "_ZN3Bar4FuncEv"},
+                ArgInFun{.Idx = 0, .InFunction = "_ZN3Baz4FuncEv"},
+                GlobalVar{.Name = "_ZTV3Foo"},
+                GlobalVar{.Name = "_ZTVN10__cxxabiv117__class_type_infoE"},
+                GlobalVar{.Name = "_ZTS3Foo"},
+                GlobalVar{.Name = "_ZTI3Foo"},
+                GlobalVar{.Name = "_ZTV3Bar"},
+                GlobalVar{.Name = "_ZTVN10__cxxabiv120__si_class_type_infoE"},
+                GlobalVar{.Name = "_ZTS3Bar"},
+                GlobalVar{.Name = "_ZTI3Bar"},
+                GlobalVar{.Name = "_ZTV3Baz"},
+                GlobalVar{.Name = "_ZTS3Baz"},
+                GlobalVar{.Name = "_ZTI3Baz"},
+                FuncByName{.NameOfFunction = "_ZN3Foo4FuncEv"},
+                FuncByName{.NameOfFunction = "_ZN3Bar4FuncEv"},
+                FuncByName{.NameOfFunction = "_ZN3Baz4FuncEv"},
+                LineColFunOp{.Line = 19,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 21,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 23,
+                             .Col = 17,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::PHI}}},
+              {LineColFunOp{.Line = 23,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_09_cpp_dbg.ll", GT,
+                              ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Indirection10) {
+  GTMap GT = {{LineColFunOp{.Line = 20,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {ArgInFun{.Idx = 0, .InFunction = "_ZN3FooC2Ev"},
+                ArgInFun{.Idx = 0, .InFunction = "_ZN3BarC2Ev"},
+                ArgInFun{.Idx = 0, .InFunction = "_ZN3Foo4FuncEv"},
+                ArgInFun{.Idx = 0, .InFunction = "_ZN3Bar4FuncEv"},
+                GlobalVar{.Name = "_ZTV3Foo"},
+                GlobalVar{.Name = "_ZTVN10__cxxabiv117__class_type_infoE"},
+                GlobalVar{.Name = "_ZTS3Foo"}, GlobalVar{.Name = "_ZTI3Foo"},
+                GlobalVar{.Name = "_ZTV3Bar"},
+                GlobalVar{.Name = "_ZTVN10__cxxabiv120__si_class_type_infoE"},
+                GlobalVar{.Name = "_ZTS3Bar"}, GlobalVar{.Name = "_ZTI3Bar"},
+                FuncByName{.NameOfFunction = "_ZN3Foo4FuncEv"},
+                FuncByName{.NameOfFunction = "_ZN3Bar4FuncEv"},
+                LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 21,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 23,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_10_cpp_dbg.ll", GT,
+                              ContextAABuilder);
+}
+
+TEST(BotUnionFindAATest, Basic01) {
+  GTMap GT = {{LineColFunOp{.Line = 3,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 3,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 5,
+                             .Col = 4,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 4,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 4,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("basic_01_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(BotUnionFindAATest, Basic02) {
+  GTMap GT = {{LineColFunOp{.Line = 3,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 3,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 4,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 6,
+                             .Col = 5,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 4,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 3,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 4,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("basic_02_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(BotUnionFindAATest, Basic03) {
+  GTMap GT = {{LineColFunOp{.Line = 5,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 5,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("basic_03_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(BotUnionFindAATest, Basic04) {
+  GTMap GT = {{LineColFunOp{.Line = 5,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {FuncByName{.NameOfFunction = "Func"},
+                LineColFunOp{.Line = 5,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 6,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 6,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("basic_04_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context01) {
+  GTMap GT = {
+      {LineColFunOp{.Line = 5,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 5,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 8,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 11,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Load},
+       }},
+      {LineColFunOp{.Line = 6,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 6,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 9,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+       }},
+  };
+
+  doAnalysisAndCompareResults("context_01_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context02) {
+  GTMap GT = {
+      {LineColFunOp{.Line = 6,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 6,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 9,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 10,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 14,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Load},
+       }},
+      {LineColFunOp{.Line = 7,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 7,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 11,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 12,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+       }},
+  };
+
+  doAnalysisAndCompareResults("context_02_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context03) {
+  GTMap GT = {{LineColFunOp{.Line = 6,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 6,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_03_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context04_0) {
+  GTMap GT = {{LineColFunOp{.Line = 7,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 7,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_04_0_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context04_1) {
+  GTMap GT = {{LineColFunOp{.Line = 7,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 7,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 15,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_04_1_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context05_0) {
+  GTMap GT = {{LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 13,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_05_0_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context05_1) {
+  GTMap GT = {{LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 16,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_05_1_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context06_0) {
+  GTMap GT = {{LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 14,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_06_0_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context06_1) {
+  GTMap GT = {{LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call}}},
+              {LineColFunOp{.Line = 10,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 14,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 15,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 17,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_06_1_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context07) {
+  GTMap GT = {
+      {LineColFunOp{.Line = 8,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 8,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 11,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 14,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Load},
+       }},
+      {LineColFunOp{.Line = 9,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 9,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 12,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+       }},
+  };
+
+  doAnalysisAndCompareResults("context_07_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context08) {
+  GTMap GT = {{LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 15,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 19,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 21,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_08_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context09_0) {
+  GTMap GT = {{LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call}}},
+              {LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 16,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 18,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}}};
+
+  doAnalysisAndCompareResults("context_09_0_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context09_1) {
+  GTMap GT = {{LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 17,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call}}},
+              {LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 18,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}}};
+
+  doAnalysisAndCompareResults("context_09_1_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context10_0) {
+  GTMap GT = {{LineColFunOp{.Line = 24,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 24,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 26,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 30,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}}};
+
+  doAnalysisAndCompareResults("context_10_0_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context10_1) {
+  GTMap GT = {
+      {LineColFunOp{.Line = 24,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 24,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 27,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 29,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 35,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Load},
+       }},
+      {LineColFunOp{.Line = 25,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 25,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 31,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 33,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+       }},
+  };
+
+  doAnalysisAndCompareResults("context_10_1_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context11_0) {
+  GTMap GT{{LineColFunOp{.Line = 33,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 36,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 39,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 39,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+            }},
+           {LineColFunOp{.Line = 34,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 37,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+            }}};
+
+  doAnalysisAndCompareResults("context_11_0_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context11_1) {
+  GTMap GT{{LineColFunOp{.Line = 33,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 33,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 36,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 37,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 41,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 34,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 34,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 38,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 39,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_11_1_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context12_0) {
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 9,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 13,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+
+           {LineColFunOp{.Line = 6,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 10,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_12_0_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context12_1) {
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 6,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 9,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_12_1_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context13_0) {
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 9,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 10,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 17,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 6,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 12,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 13,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 14,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 15,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_13_0_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context13_1) {
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call}}},
+           {LineColFunOp{.Line = 6,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 9,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}}};
+
+  doAnalysisAndCompareResults("context_13_1_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Indirection01) {
+  GTMap GT = {{LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 11,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_01_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Indirection02) {
+  GTMap GT = {{LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 21,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 20,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 21,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 21,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 22,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 23,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_02_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Indirection03) {
+  GTMap GT = {{LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 16,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 18,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 19,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 21,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 24,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 21,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 21,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 22,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 23,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 24,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 24,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_03_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Indirection04) {
+  GTMap GT = {{LineColFunOp{.Line = 18,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 18,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 19,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 21,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 25,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 26,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 27,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 29,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 30,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 31,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 29,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 29,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 30,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 30,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 31,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 31,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 32,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 33,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 34,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_04_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Indirection05) {
+  GTMap GT = {{LineColFunOp{.Line = 23,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 24,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 25,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 26,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 27,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 28,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 29,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 30,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 35,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 37,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 38,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 39,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 40,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 41,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 42,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 43,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 44,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 37,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 37,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 38,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 38,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 39,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 39,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 40,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 40,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 41,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 41,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 42,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 42,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 43,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 43,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 44,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 44,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_05_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Indirection06) {
+  GTMap GT = {{LineColFunOp{.Line = 28,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 28,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 29,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 30,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 31,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 35,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 36,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 37,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 39,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 40,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 41,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 42,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 43,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 45,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 46,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 47,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 48,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 49,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 50,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 51,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 52,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 53,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 54,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 45,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 45,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 46,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 46,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 47,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 47,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 48,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 48,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 49,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 49,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 50,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 50,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 51,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 51,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 52,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 52,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 53,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 53,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 54,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 54,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_06_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Indirection07) {
+  GTMap GT = {{LineColFunOp{.Line = 33,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 35,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 36,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 37,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 38,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 39,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 40,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 41,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 42,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 43,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 44,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 46,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 47,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 48,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 49,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 50,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 51,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 53,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 54,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 55,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 56,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 57,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 58,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 59,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 60,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 61,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 62,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 63,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 64,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 53,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 53,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 54,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 54,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 55,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 55,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 56,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 56,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 57,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 57,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 58,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 58,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 59,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 59,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 60,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 60,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 61,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 61,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 62,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 62,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 63,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 63,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 64,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 64,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_07_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Indirection08) {
+  GTMap GT = {{LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 16,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 16,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_08_cpp_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Indirection09) {
+  GTMap GT = {{LineColFunOp{.Line = 19,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 19,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 23,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_09_cpp_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Indirection10) {
+  GTMap GT = {{LineColFunOp{.Line = 19,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 19,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 23,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_10_cpp_dbg.ll", GT, BotAABuilder);
+}
+
+// IndirectionSensUnionFindAA Tests
+
+TEST(IndirectionSensUnionFindAATest, Basic01) {
+  GTMap GT = {{LineColFunOp{.Line = 3,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 3,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("basic_01_c_dbg.ll", GT, IndAABuilder);
+
+  psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
+                                      "IndirectionSensUnionFindAA");
+}
+
+TEST(IndirectionSensUnionFindAATest, Basic02) {
+  GTMap GT = {{
+                  LineColFunOp{.Line = 3,
+                               .Col = 0,
+                               .InFunction = "main",
+                               .OpCode = llvm::Instruction::Alloca},
+                  {LineColFunOp{.Line = 3,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 6,
+                                .Col = 4,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load}},
+              },
+              {
+                  LineColFunOp{.Line = 4,
+                               .Col = 0,
+                               .InFunction = "main",
+                               .OpCode = llvm::Instruction::Alloca},
+                  {LineColFunOp{.Line = 4,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 6,
+                                .Col = 5,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load}},
+              },
+              {
+                  LineColFunOp{.Line = 4,
+                               .Col = 0,
+                               .InFunction = "main",
+                               .OpCode = llvm::Instruction::Alloca},
+                  {LineColFunOp{.Line = 4,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 6,
+                                .Col = 5,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load}},
+              }};
+
+  doAnalysisAndCompareResults("basic_02_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Basic03) {
+  GTMap GT = {{LineColFunOp{.Line = 5,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 5,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("basic_03_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Basic04) {
+  GTMap GT = {{LineColFunOp{.Line = 5,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 5,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("basic_04_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context01) {
+  GTMap GT = {{LineColFunOp{.Line = 5,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {ArgInFun{.Idx = 0, .InFunction = "id"},
+                LineColFunOp{.Line = 2,
+                             .Col = 26,
+                             .InFunction = "id",
+                             .OpCode = llvm::Instruction::Load},
+                RetVal{.InFunction = "id"},
+                LineColFunOp{.Line = 5,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 6,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 8,
+                             .Col = 13,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 9,
+                             .Col = 13,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 11,
+                             .Col = 11,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("context_01_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context02) {
+  GTMap GT = {{LineColFunOp{.Line = 6,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   ArgInFun{.Idx = 0, .InFunction = "id1"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 27,
+                                .InFunction = "id1",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id1"},
+                   LineColFunOp{.Line = 6,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 14,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 7,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   ArgInFun{.Idx = 0, .InFunction = "id2"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 27,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id2"},
+                   LineColFunOp{.Line = 7,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+               }},
+              {LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 10,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 10,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 11,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_02_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context03) {
+  GTMap GT = {{LineColFunOp{.Line = 6,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   ArgInFun{.Idx = 0, .InFunction = "id1"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 27,
+                                .InFunction = "id1",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id1"},
+                   ArgInFun{.Idx = 0, .InFunction = "id2"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 27,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id2"},
+                   LineColFunOp{.Line = 6,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_03_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context04_0) {
+  GTMap GT = {{LineColFunOp{.Line = 7,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   ArgInFun{.Idx = 0, .InFunction = "id1"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 27,
+                                .InFunction = "id1",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id1"},
+                   ArgInFun{.Idx = 0, .InFunction = "id2"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 27,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id2"},
+                   ArgInFun{.Idx = 0, .InFunction = "id3"},
+                   LineColFunOp{.Line = 4,
+                                .Col = 27,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id3"},
+                   LineColFunOp{.Line = 7,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 10,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 10,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_04_0_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context04_1) {
+  GTMap GT = {{LineColFunOp{.Line = 7,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   ArgInFun{.Idx = 0, .InFunction = "id1"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 27,
+                                .InFunction = "id1",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id1"},
+                   ArgInFun{.Idx = 0, .InFunction = "id2"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 27,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id2"},
+                   ArgInFun{.Idx = 0, .InFunction = "id3"},
+                   LineColFunOp{.Line = 4,
+                                .Col = 27,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id3"},
+                   LineColFunOp{.Line = 7,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 13,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 15,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 10,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 10,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 11,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_04_1_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context05_0) {
+  GTMap GT = {{LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   ArgInFun{.Idx = 0, .InFunction = "id1"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 27,
+                                .InFunction = "id1",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id1"},
+                   ArgInFun{.Idx = 0, .InFunction = "id2"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 27,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id2"},
+                   ArgInFun{.Idx = 0, .InFunction = "id3"},
+                   LineColFunOp{.Line = 4,
+                                .Col = 27,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id3"},
+                   ArgInFun{.Idx = 0, .InFunction = "id4"},
+                   LineColFunOp{.Line = 5,
+                                .Col = 27,
+                                .InFunction = "id4",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id4"},
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 13,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 10,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 10,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 11,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_05_0_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context05_1) {
+  GTMap GT = {{LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   ArgInFun{.Idx = 0, .InFunction = "id1"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 27,
+                                .InFunction = "id1",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id1"},
+                   ArgInFun{.Idx = 0, .InFunction = "id2"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 27,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id2"},
+                   ArgInFun{.Idx = 0, .InFunction = "id3"},
+                   LineColFunOp{.Line = 4,
+                                .Col = 27,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id3"},
+                   ArgInFun{.Idx = 0, .InFunction = "id4"},
+                   LineColFunOp{.Line = 5,
+                                .Col = 27,
+                                .InFunction = "id4",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id4"},
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 13,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 14,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 16,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 11,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 14,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_05_1_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context06_0) {
+  GTMap GT = {{LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   ArgInFun{.Idx = 0, .InFunction = "id1"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 27,
+                                .InFunction = "id1",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id1"},
+                   ArgInFun{.Idx = 0, .InFunction = "id2"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 27,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id2"},
+                   ArgInFun{.Idx = 0, .InFunction = "id3"},
+                   LineColFunOp{.Line = 4,
+                                .Col = 27,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id3"},
+                   ArgInFun{.Idx = 0, .InFunction = "id4"},
+                   LineColFunOp{.Line = 5,
+                                .Col = 27,
+                                .InFunction = "id4",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id4"},
+                   ArgInFun{.Idx = 0, .InFunction = "id5"},
+                   LineColFunOp{.Line = 6,
+                                .Col = 27,
+                                .InFunction = "id5",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id5"},
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 14,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 11,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_06_0_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context06_1) {
+  GTMap GT = {{LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {ArgInFun{.Idx = 0, .InFunction = "id1"},
+                LineColFunOp{.Line = 2,
+                             .Col = 27,
+                             .InFunction = "id1",
+                             .OpCode = llvm::Instruction::Load},
+                RetVal{.InFunction = "id1"},
+                ArgInFun{.Idx = 0, .InFunction = "id2"},
+                LineColFunOp{.Line = 3,
+                             .Col = 27,
+                             .InFunction = "id2",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "id2"},
+                ArgInFun{.Idx = 0, .InFunction = "id3"},
+                LineColFunOp{.Line = 4,
+                             .Col = 27,
+                             .InFunction = "id3",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "id3"},
+                ArgInFun{.Idx = 0, .InFunction = "id4"},
+                LineColFunOp{.Line = 5,
+                             .Col = 27,
+                             .InFunction = "id4",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "id4"},
+                ArgInFun{.Idx = 0, .InFunction = "id5"},
+                LineColFunOp{.Line = 6,
+                             .Col = 27,
+                             .InFunction = "id5",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "id5"},
+                LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 10,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 17,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 14,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 15,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_06_1_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context07) {
+  GTMap GT = {
+      {LineColFunOp{.Line = 8,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           ArgInFun{.Idx = 0, .InFunction = "buzz"},
+           LineColFunOp{.Line = 2,
+                        .Col = 28,
+                        .InFunction = "buzz",
+                        .OpCode = llvm::Instruction::Load},
+           RetVal{.InFunction = "buzz"},
+           ArgInFun{.Idx = 0, .InFunction = "baz"},
+           LineColFunOp{.Line = 3,
+                        .Col = 27,
+                        .InFunction = "baz",
+                        .OpCode = llvm::Instruction::Call},
+           RetVal{.InFunction = "baz"},
+           ArgInFun{.Idx = 0, .InFunction = "bar"},
+           LineColFunOp{.Line = 4,
+                        .Col = 27,
+                        .InFunction = "bar",
+                        .OpCode = llvm::Instruction::Call},
+           RetVal{.InFunction = "bar"},
+           ArgInFun{.Idx = 0, .InFunction = "foo"},
+           LineColFunOp{.Line = 5,
+                        .Col = 27,
+                        .InFunction = "foo",
+                        .OpCode = llvm::Instruction::Call},
+           RetVal{.InFunction = "foo"},
+           LineColFunOp{.Line = 8,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 9,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 11,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 12,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 14,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Load},
+       }},
+      {LineColFunOp{.Line = 11,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {LineColFunOp{.Line = 11,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca}}},
+      {LineColFunOp{.Line = 12,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {LineColFunOp{.Line = 12,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca}}},
+  };
+
+  doAnalysisAndCompareResults("context_07_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context08) {
+  GTMap GT = {{LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   ArgInFun{.Idx = 0, .InFunction = "selfRecursion"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 8,
+                                .InFunction = "selfRecursion",
+                                .OpCode = llvm::Instruction::Load},
+                   LineColFunOp{.Line = 4,
+                                .Col = 12,
+                                .InFunction = "selfRecursion",
+                                .OpCode = llvm::Instruction::Load},
+                   LineColFunOp{.Line = 7,
+                                .Col = 11,
+                                .InFunction = "selfRecursion",
+                                .OpCode = llvm::Instruction::Load},
+                   LineColFunOp{.Line = 8,
+                                .Col = 10,
+                                .InFunction = "selfRecursion",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "selfRecursion"},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 15,
+                                .Col = 12,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 19,
+                                .Col = 12,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 21,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
+                                      "IndirectionSensUnionFindAA");
+
+  doAnalysisAndCompareResults("context_08_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context09_0) {
+  GTMap GT{{LineColFunOp{.Line = 12,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                ArgInFun{.Idx = 0, .InFunction = "selfRecursion"},
+                LineColFunOp{.Line = 3,
+                             .Col = 8,
+                             .InFunction = "selfRecursion",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 4,
+                             .Col = 12,
+                             .InFunction = "selfRecursion",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 7,
+                             .Col = 11,
+                             .InFunction = "selfRecursion",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 8,
+                             .Col = 10,
+                             .InFunction = "selfRecursion",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "selfRecursion"},
+                LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 15,
+                             .Col = 12,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 16,
+                             .Col = 12,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 18,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+            }},
+           {LineColFunOp{.Line = 15,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 16,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 16,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("context_09_0_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context09_1) {
+  GTMap GT{{LineColFunOp{.Line = 12,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                ArgInFun{.Idx = 0, .InFunction = "selfRecursion"},
+                LineColFunOp{.Line = 3,
+                             .Col = 8,
+                             .InFunction = "selfRecursion",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 4,
+                             .Col = 12,
+                             .InFunction = "selfRecursion",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 7,
+                             .Col = 11,
+                             .InFunction = "selfRecursion",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 8,
+                             .Col = 10,
+                             .InFunction = "selfRecursion",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "selfRecursion"},
+                LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 15,
+                             .Col = 14,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 17,
+                             .Col = 14,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 18,
+                             .Col = 14,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 20,
+                             .Col = 14,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+            }},
+           {LineColFunOp{.Line = 15,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 17,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 17,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 18,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 18,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 20,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("context_09_1_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context10_0) {
+  GTMap GT{{LineColFunOp{.Line = 24,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                ArgInFun{.Idx = 0, .InFunction = "Forth"},
+                LineColFunOp{.Line = 5,
+                             .Col = 8,
+                             .InFunction = "Forth",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 6,
+                             .Col = 13,
+                             .InFunction = "Forth",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 7,
+                             .Col = 12,
+                             .InFunction = "Forth",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "Forth"},
+                ArgInFun{.Idx = 0, .InFunction = "Back"},
+                LineColFunOp{.Line = 14,
+                             .Col = 8,
+                             .InFunction = "Back",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 15,
+                             .Col = 13,
+                             .InFunction = "Back",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 16,
+                             .Col = 12,
+                             .InFunction = "Back",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "Back"},
+                LineColFunOp{.Line = 24,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 26,
+                             .Col = 12,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 30,
+                             .Col = 12,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+            }},
+           {LineColFunOp{.Line = 26,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 26,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 30,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 30,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("context_10_0_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context10_1) {
+  GTMap GT{{LineColFunOp{.Line = 24,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                ArgInFun{.Idx = 0, .InFunction = "Forth"},
+                LineColFunOp{.Line = 5,
+                             .Col = 8,
+                             .InFunction = "Forth",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 6,
+                             .Col = 13,
+                             .InFunction = "Forth",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 7,
+                             .Col = 12,
+                             .InFunction = "Forth",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "Forth"},
+                ArgInFun{.Idx = 0, .InFunction = "Back"},
+                LineColFunOp{.Line = 14,
+                             .Col = 8,
+                             .InFunction = "Back",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 15,
+                             .Col = 13,
+                             .InFunction = "Back",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 16,
+                             .Col = 12,
+                             .InFunction = "Back",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "Back"},
+                LineColFunOp{.Line = 24,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 25,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 27,
+                             .Col = 14,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 29,
+                             .Col = 14,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 31,
+                             .Col = 14,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 33,
+                             .Col = 14,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 35,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+            }},
+           {LineColFunOp{.Line = 27,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 27,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 29,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 29,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 31,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 31,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 33,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("context_10_1_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context11_0) {
+  GTMap GT{{LineColFunOp{.Line = 33,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                ArgInFun{.Idx = 0, .InFunction = "Forth"},
+                LineColFunOp{.Line = 6,
+                             .Col = 8,
+                             .InFunction = "Forth",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 7,
+                             .Col = 13,
+                             .InFunction = "Forth",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 8,
+                             .Col = 12,
+                             .InFunction = "Forth",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "Forth"},
+                ArgInFun{.Idx = 0, .InFunction = "Back"},
+                LineColFunOp{.Line = 15,
+                             .Col = 8,
+                             .InFunction = "Back",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 16,
+                             .Col = 13,
+                             .InFunction = "Back",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 17,
+                             .Col = 12,
+                             .InFunction = "Back",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "Back"},
+                ArgInFun{.Idx = 0, .InFunction = "Stop"},
+                LineColFunOp{.Line = 24,
+                             .Col = 8,
+                             .InFunction = "Stop",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 25,
+                             .Col = 12,
+                             .InFunction = "Stop",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 28,
+                             .Col = 10,
+                             .InFunction = "Stop",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "Stop"},
+                LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 36,
+                             .Col = 12,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 37,
+                             .Col = 12,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 39,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+            }},
+           {LineColFunOp{.Line = 36,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 36,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 37,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 37,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("context_11_0_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context11_1) {
+  GTMap GT{{LineColFunOp{.Line = 33,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                ArgInFun{.Idx = 0, .InFunction = "Forth"},
+                LineColFunOp{.Line = 6,
+                             .Col = 8,
+                             .InFunction = "Forth",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 7,
+                             .Col = 13,
+                             .InFunction = "Forth",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 8,
+                             .Col = 12,
+                             .InFunction = "Forth",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "Forth"},
+                ArgInFun{.Idx = 0, .InFunction = "Back"},
+                LineColFunOp{.Line = 15,
+                             .Col = 8,
+                             .InFunction = "Back",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 16,
+                             .Col = 13,
+                             .InFunction = "Back",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 17,
+                             .Col = 12,
+                             .InFunction = "Back",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "Back"},
+                ArgInFun{.Idx = 0, .InFunction = "Stop"},
+                LineColFunOp{.Line = 24,
+                             .Col = 8,
+                             .InFunction = "Stop",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 25,
+                             .Col = 12,
+                             .InFunction = "Stop",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 28,
+                             .Col = 10,
+                             .InFunction = "Stop",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "Stop"},
+                LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 36,
+                             .Col = 14,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 37,
+                             .Col = 14,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 38,
+                             .Col = 14,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 39,
+                             .Col = 14,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 41,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+            }},
+           {LineColFunOp{.Line = 36,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 36,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 37,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 37,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 38,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 38,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 39,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 39,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("context_11_1_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context12_0) {
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {ArgInFun{.Idx = 0, .InFunction = "argretq"},
+             ArgInFun{.Idx = 1, .InFunction = "argretq"},
+             RetVal{.InFunction = "argretq"},
+             LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 9,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 10,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 13,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 8,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 9,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 10,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 10,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 11,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("context_12_0_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context12_1) {
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {ArgInFun{.Idx = 0, .InFunction = "argretq"},
+             ArgInFun{.Idx = 1, .InFunction = "argretq"},
+             RetVal{.InFunction = "argretq"},
+             LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 9,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 8,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 9,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("context_12_1_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context13_0) {
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {ArgInFun{.Idx = 0, .InFunction = "argretq"},
+             ArgInFun{.Idx = 1, .InFunction = "argretq"},
+             ArgInFun{.Idx = 2, .InFunction = "argretq"},
+             RetVal{.InFunction = "argretq"},
+             LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 9,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 10,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 12,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 13,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 14,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 15,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 17,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 8,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 9,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 10,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 10,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 11,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 12,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 13,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 14,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 15,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("context_13_0_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context13_1) {
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {ArgInFun{.Idx = 0, .InFunction = "argretq"},
+             ArgInFun{.Idx = 1, .InFunction = "argretq"},
+             ArgInFun{.Idx = 2, .InFunction = "argretq"},
+             RetVal{.InFunction = "argretq"},
+             LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 9,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 8,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 9,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("context_13_1_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context14_0) {
+  GTMap GT{{LineColFunOp{.Line = 7,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 7,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_14_0_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context14_1) {
+  GTMap GT{{LineColFunOp{.Line = 9,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("context_14_1_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context14_2) {
+  GTMap GT{{LineColFunOp{.Line = 11,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_14_2_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Indirection01) {
+  GTMap GT{{LineColFunOp{.Line = 8,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+            }},
+           {LineColFunOp{.Line = 11,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("indirection_01_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Indirection02) {
+  GTMap GT{{LineColFunOp{.Line = 8,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 21,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+            }},
+           {LineColFunOp{.Line = 20,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 20,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 21,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 21,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 22,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 22,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 23,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 23,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("indirection_02_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Indirection03) {
+  GTMap GT{{LineColFunOp{.Line = 13,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 21,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 24,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+            }},
+           {LineColFunOp{.Line = 21,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 21,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 22,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 22,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 23,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 23,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 24,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 24,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("indirection_03_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Indirection04) {
+  GTMap GT{{LineColFunOp{.Line = 18,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 18,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 29,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+            }},
+           {LineColFunOp{.Line = 29,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 29,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 30,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 30,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 31,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 31,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 32,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 32,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 33,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 33,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 34,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 34,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("indirection_04_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Indirection05) {
+  GTMap GT{{LineColFunOp{.Line = 23,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 37,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 38,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 41,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+            }},
+           {LineColFunOp{.Line = 37,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 37,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 38,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 38,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 39,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 39,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 40,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 40,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 41,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 41,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 42,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 42,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 43,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 43,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 44,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 44,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("indirection_05_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Indirection06) {
+  GTMap GT{{LineColFunOp{.Line = 28,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 28,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 45,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 46,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 50,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 51,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+            }},
+           {LineColFunOp{.Line = 45,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 45,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 46,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 46,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 47,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 47,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 48,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 48,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 49,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 49,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 50,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 50,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 51,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 51,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 52,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 52,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 53,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 53,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 54,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 54,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("indirection_06_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Indirection07) {
+  GTMap GT{{LineColFunOp{.Line = 33,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 35,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 53,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 54,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 55,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 59,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 60,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 61,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+            }},
+           {LineColFunOp{.Line = 53,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 53,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 54,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 54,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 55,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 55,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 56,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 56,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 57,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 57,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 58,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 58,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 59,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 59,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 60,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 60,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 61,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 61,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 62,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 62,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 63,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 63,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 64,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 64,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("indirection_07_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Indirection08) {
+  GTMap GT{{LineColFunOp{.Line = 13,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {ArgInFun{.Idx = 0, .InFunction = "_ZN3FooC2Ev"},
+             // Bar constructor calls Foo constructor and we are not context
+             // sensitive
+             ArgInFun{.Idx = 0, .InFunction = "_ZN3BarC2Ev"},
+             ArgInFun{.Idx = 0, .InFunction = "_ZN3Bar4FuncEv"},
+             ArgInFun{.Idx = 0, .InFunction = "_ZN3Foo4FuncEv"},
+             LineColFunOp{.Line = 13,
+                          .Col = 7,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 14,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 16,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 16,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("indirection_08_cpp_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Indirection09) {
+  GTMap GT{{LineColFunOp{.Line = 19,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {ArgInFun{.Idx = 0, .InFunction = "_ZN3FooC2Ev"},
+             ArgInFun{.Idx = 0, .InFunction = "_ZN3BarC2Ev"},
+             ArgInFun{.Idx = 0, .InFunction = "_ZN3BazC2Ev"},
+             ArgInFun{.Idx = 0, .InFunction = "_ZN3Foo4FuncEv"},
+             ArgInFun{.Idx = 0, .InFunction = "_ZN3Bar4FuncEv"},
+             ArgInFun{.Idx = 0, .InFunction = "_ZN3Baz4FuncEv"},
+             LineColFunOp{.Line = 19,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 20,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 21,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 23,
+                          .Col = 17,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::PHI}}},
+           {LineColFunOp{.Line = 23,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 23,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("indirection_09_cpp_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Indirection10) {
+  GTMap GT{{LineColFunOp{.Line = 20,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {ArgInFun{.Idx = 0, .InFunction = "_ZN3FooC2Ev"},
+             ArgInFun{.Idx = 0, .InFunction = "_ZN3BarC2Ev"},
+             ArgInFun{.Idx = 0, .InFunction = "_ZN3Foo4FuncEv"},
+             ArgInFun{.Idx = 0, .InFunction = "_ZN3Bar4FuncEv"},
+             LineColFunOp{.Line = 20,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 21,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 23,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 23,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("indirection_10_cpp_dbg.ll", GT, IndAABuilder);
+}
+
+} // namespace
+
+int main(int Argc, char **Argv) {
+  ::testing::InitGoogleTest(&Argc, Argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/unittests/TestUtils/SrcCodeLocationEntry.h b/unittests/TestUtils/SrcCodeLocationEntry.h
index 26a993fc6f..772ee107d2 100644
--- a/unittests/TestUtils/SrcCodeLocationEntry.h
+++ b/unittests/TestUtils/SrcCodeLocationEntry.h
@@ -148,6 +148,7 @@ struct RetVal {
     return std::string("RetVal { InFunction: ") + InFunction.str() + " }";
   }
 };
+
 struct RetStmt {
   llvm::StringRef InFunction;
 
@@ -179,11 +180,26 @@ struct OperandOf {
   }
 };
 
+struct FuncByName {
+  llvm::StringRef NameOfFunction;
+
+  friend bool operator<(FuncByName R1, FuncByName R2) noexcept {
+    return R1.NameOfFunction < R2.NameOfFunction;
+  }
+  friend bool operator==(FuncByName R1, FuncByName R2) noexcept {
+    return R1.NameOfFunction == R2.NameOfFunction;
+  }
+  [[nodiscard]] std::string str() const {
+    return std::string("FuncByName { InFunction: ") + NameOfFunction.str() +
+           " }";
+  }
+};
+
 struct TestingSrcLocation
     : public std::variant<LineCol, LineColFun, LineColFunOp, GlobalVar, ArgNo,
-                          ArgInFun, RetVal, RetStmt, OperandOf> {
+                          ArgInFun, RetVal, RetStmt, OperandOf, FuncByName> {
   using VarT = std::variant<LineCol, LineColFun, LineColFunOp, GlobalVar, ArgNo,
-                            ArgInFun, RetVal, RetStmt, OperandOf>;
+                            ArgInFun, RetVal, RetStmt, OperandOf, FuncByName>;
   using VarT::variant;
 
   template <typename T> [[nodiscard]] constexpr bool isa() const noexcept {
@@ -267,6 +283,12 @@ template <> struct hash<psr::unittest::OperandOf> {
   }
 };
 
+template <> struct hash<psr::unittest::FuncByName> {
+  size_t operator()(psr::unittest::FuncByName FBN) const noexcept {
+    return llvm::hash_value(FBN.NameOfFunction);
+  }
+};
+
 template <> struct hash<psr::unittest::TestingSrcLocation> {
   size_t
   operator()(const psr::unittest::TestingSrcLocation &Loc) const noexcept {
@@ -398,6 +420,13 @@ testingLocInIR(TestingSrcLocation Loc, const LLVMProjectIRDB &IRDB,
 
             return Inst->getOperand(Op.OperandIndex);
           },
+          [&](FuncByName FBN) -> llvm::Value const * {
+            if (const auto *Func = GetFunction(FBN.NameOfFunction)) {
+              return Func;
+            }
+            llvm::report_fatal_error("No function with name " +
+                                     FBN.NameOfFunction);
+          },
       },
       Loc);
   if (!Ret) {
diff --git a/unittests/Utils/CMakeLists.txt b/unittests/Utils/CMakeLists.txt
index d84306e783..aca8f680fc 100644
--- a/unittests/Utils/CMakeLists.txt
+++ b/unittests/Utils/CMakeLists.txt
@@ -7,6 +7,7 @@ set(UtilsSources
   LLVMShorthandsTest.cpp
   PAMMTest.cpp
   StableVectorTest.cpp
+  ValueIdMapTest.cpp
   AnalysisPrinterTest.cpp
   OnTheFlyAnalysisPrinterTest.cpp
   SourceMgrPrinterTest.cpp
diff --git a/unittests/Utils/ValueIdMapTest.cpp b/unittests/Utils/ValueIdMapTest.cpp
new file mode 100644
index 0000000000..b9fb992ba7
--- /dev/null
+++ b/unittests/Utils/ValueIdMapTest.cpp
@@ -0,0 +1,445 @@
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#include "phasar/Utils/ValueIdMap.h"
+
+#include "gtest/gtest.h"
+
+#include <stdexcept>
+#include <string>
+#include <utility>
+
+using namespace psr;
+
+enum class Id : uint32_t {};
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+static constexpr Id id(uint32_t V) noexcept { return Id(V); }
+
+template <typename MapT> static void expectEmpty(const MapT &M) {
+  EXPECT_TRUE(M.empty());
+  EXPECT_EQ(0u, M.size());
+  EXPECT_EQ(M.end(), M.begin());
+}
+
+// ── Basic construction
+// ────────────────────────────────────────────────────────
+
+TEST(ValueIdMap, DefaultCtorEmpty) {
+  ValueIdMap<Id, int> M;
+  expectEmpty(M);
+  EXPECT_FALSE(M.contains(id(0)));
+  EXPECT_EQ(0u, M.count(id(0)));
+}
+
+TEST(ValueIdMap, ReserveCtorEmpty) {
+  ValueIdMap<Id, int> M(64);
+  expectEmpty(M);
+  EXPECT_FALSE(M.contains(id(0)));
+}
+
+// ── try_emplace
+// ───────────────────────────────────────────────────────────────
+
+TEST(ValueIdMap, TryEmplaceInsert) {
+  ValueIdMap<Id, int> M;
+  auto [It, Inserted] = M.try_emplace(id(3), 42);
+  EXPECT_TRUE(Inserted);
+  EXPECT_EQ(id(3), It->first);
+  EXPECT_EQ(42, It->second);
+  EXPECT_EQ(1u, M.size());
+  EXPECT_TRUE(M.contains(id(3)));
+}
+
+TEST(ValueIdMap, TryEmplaceDuplicate) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(3), 42);
+  auto [It, Inserted] = M.try_emplace(id(3), 99);
+  EXPECT_FALSE(Inserted);
+  EXPECT_EQ(42, It->second); // original value unchanged
+  EXPECT_EQ(1u, M.size());
+}
+
+TEST(ValueIdMap, TryEmplaceMultiple) {
+  ValueIdMap<Id, int> M;
+  for (uint32_t I = 0; I < 10; ++I) {
+    auto [It, Inserted] = M.try_emplace(id(I), int(I * 2));
+    EXPECT_TRUE(Inserted);
+    EXPECT_EQ(int(I * 2), It->second);
+  }
+  EXPECT_EQ(10u, M.size());
+  for (uint32_t I = 0; I < 10; ++I) {
+    EXPECT_TRUE(M.contains(id(I)));
+    EXPECT_EQ(int(I * 2), M.at(id(I)));
+  }
+}
+
+// ── operator[] ───────────────────────────────────────────────────────────────
+
+TEST(ValueIdMap, OperatorBracketInserts) {
+  ValueIdMap<Id, int> M;
+  M[id(5)] = 77;
+  EXPECT_EQ(1u, M.size());
+  EXPECT_EQ(77, M.at(id(5)));
+}
+
+TEST(ValueIdMap, OperatorBracketExisting) {
+  ValueIdMap<Id, int> M;
+  M[id(5)] = 77;
+  M[id(5)] = 99;
+  EXPECT_EQ(1u, M.size());
+  EXPECT_EQ(99, M.at(id(5)));
+}
+
+TEST(ValueIdMap, OperatorBracketDefaultConstructs) {
+  ValueIdMap<Id, int> M;
+  int &Ref = M[id(2)];
+  EXPECT_EQ(0,
+            Ref); // int default-initialised to 0 via value-init in try_emplace
+  EXPECT_EQ(1u, M.size());
+}
+
+// ── insert / insert_or_assign
+// ─────────────────────────────────────────────────
+
+TEST(ValueIdMap, InsertNew) {
+  ValueIdMap<Id, int> M;
+  auto [It, Inserted] = M.insert({id(7), 100});
+  EXPECT_TRUE(Inserted);
+  EXPECT_EQ(100, It->second);
+}
+
+TEST(ValueIdMap, InsertExisting) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(7), 100);
+  auto [It, Inserted] = M.insert({id(7), 200});
+  EXPECT_FALSE(Inserted);
+  EXPECT_EQ(100, It->second);
+}
+
+TEST(ValueIdMap, InsertOrAssignNew) {
+  ValueIdMap<Id, int> M;
+  auto [It, Inserted] = M.insert_or_assign(id(4), 55);
+  EXPECT_TRUE(Inserted);
+  EXPECT_EQ(55, It->second);
+}
+
+TEST(ValueIdMap, InsertOrAssignExisting) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(4), 55);
+  auto [It, Inserted] = M.insert_or_assign(id(4), 88);
+  EXPECT_FALSE(Inserted);
+  EXPECT_EQ(88, It->second);
+  EXPECT_EQ(88, M.at(id(4)));
+}
+
+// ── contains / count / find
+// ───────────────────────────────────────────────────
+
+TEST(ValueIdMap, ContainsFindAbsent) {
+  ValueIdMap<Id, int> M;
+  EXPECT_FALSE(M.contains(id(0)));
+  EXPECT_EQ(0u, M.count(id(0)));
+  EXPECT_EQ(M.end(), M.find(id(0)));
+}
+
+TEST(ValueIdMap, ContainsFindPresent) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(0), 1);
+  EXPECT_TRUE(M.contains(id(0)));
+  EXPECT_EQ(1u, M.count(id(0)));
+  auto It = M.find(id(0));
+  ASSERT_NE(M.end(), It);
+  EXPECT_EQ(1, It->second);
+}
+
+// ── at
+// ────────────────────────────────────────────────────────────────────────
+
+TEST(ValueIdMap, AtPresent) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(2), 42);
+  EXPECT_EQ(42, M.at(id(2)));
+  M.at(id(2)) = 99;
+  EXPECT_EQ(99, M.at(id(2)));
+}
+
+TEST(ValueIdMap, AtAbsentThrows) {
+  ValueIdMap<Id, int> M;
+  EXPECT_THROW(std::ignore = M.at(id(0)), std::out_of_range);
+}
+
+TEST(ValueIdMap, AtConstPresent) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(2), 42);
+  const auto &CM = M;
+  EXPECT_EQ(42, CM.at(id(2)));
+}
+
+TEST(ValueIdMap, AtConstAbsentThrows) {
+  const ValueIdMap<Id, int> M;
+  EXPECT_THROW(std::ignore = M.at(id(0)), std::out_of_range);
+}
+
+// ── erase
+// ─────────────────────────────────────────────────────────────────────
+
+TEST(ValueIdMap, EraseKeyPresent) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(1), 10);
+  EXPECT_TRUE(M.erase(id(1)));
+  EXPECT_EQ(0u, M.size());
+  EXPECT_FALSE(M.contains(id(1)));
+}
+
+TEST(ValueIdMap, EraseKeyAbsent) {
+  ValueIdMap<Id, int> M;
+  EXPECT_FALSE(M.erase(id(1)));
+}
+
+TEST(ValueIdMap, EraseIterator) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(1), 10);
+  M.try_emplace(id(3), 30);
+  M.try_emplace(id(5), 50);
+
+  auto It = M.find(id(3));
+  ASSERT_NE(M.end(), It);
+  It = M.erase(It);
+
+  EXPECT_EQ(2u, M.size());
+  EXPECT_FALSE(M.contains(id(3)));
+  // Iterator should now point at id(5) (the next key)
+  ASSERT_NE(M.end(), It);
+  EXPECT_EQ(id(5), It->first);
+}
+
+TEST(ValueIdMap, EraseIteratorLast) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(2), 20);
+  auto It = M.erase(M.begin());
+  EXPECT_EQ(M.end(), It);
+  EXPECT_TRUE(M.empty());
+}
+
+// ── clear
+// ─────────────────────────────────────────────────────────────────────
+
+TEST(ValueIdMap, ClearInt) {
+  ValueIdMap<Id, int> M;
+  for (uint32_t I = 0; I < 8; ++I) {
+    M.try_emplace(id(I), int(I));
+  }
+  M.clear();
+  expectEmpty(M);
+  EXPECT_FALSE(M.contains(id(0)));
+}
+
+TEST(ValueIdMap, ClearString) {
+  ValueIdMap<Id, std::string> M;
+  for (uint32_t I = 0; I < 8; ++I) {
+    M.try_emplace(id(I), std::to_string(I));
+  }
+  M.clear();
+  expectEmpty(M);
+}
+
+TEST(ValueIdMap, ReuseAfterClear) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(0), 1);
+  M.clear();
+  M.try_emplace(id(0), 2);
+  EXPECT_EQ(1u, M.size());
+  EXPECT_EQ(2, M.at(id(0)));
+}
+
+// ── Iteration
+// ─────────────────────────────────────────────────────────────────
+
+TEST(ValueIdMap, IterationOrder) {
+  // Keys must be visited in ascending order (BitSet property)
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(5), 50);
+  M.try_emplace(id(1), 10);
+  M.try_emplace(id(3), 30);
+
+  std::vector<uint32_t> Keys;
+  for (auto [K, V] : M) {
+    Keys.push_back(uint32_t(K));
+  }
+  ASSERT_EQ(3u, Keys.size());
+  EXPECT_EQ(1u, Keys[0]);
+  EXPECT_EQ(3u, Keys[1]);
+  EXPECT_EQ(5u, Keys[2]);
+}
+
+TEST(ValueIdMap, ConstIteration) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(2), 20);
+  M.try_emplace(id(4), 40);
+
+  const auto &CM = M;
+  int Sum = 0;
+  for (auto [K, V] : CM) {
+    Sum += V;
+  }
+  EXPECT_EQ(60, Sum);
+}
+
+TEST(ValueIdMap, IteratorToConstIterator) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(0), 7);
+  ValueIdMap<Id, int>::iterator It = M.begin();
+  ValueIdMap<Id, int>::const_iterator CIt = It; // implicit conversion
+  EXPECT_EQ(It->second, CIt->second);
+}
+
+// ── Copy / Move
+// ───────────────────────────────────────────────────────────────
+
+TEST(ValueIdMap, CopyCtorInt) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(1), 10);
+  M.try_emplace(id(3), 30);
+
+  ValueIdMap<Id, int> Copy(M);
+  EXPECT_EQ(2u, Copy.size());
+  EXPECT_EQ(10, Copy.at(id(1)));
+  EXPECT_EQ(30, Copy.at(id(3)));
+
+  // Independent
+  M.at(id(1)) = 99;
+  EXPECT_EQ(10, Copy.at(id(1)));
+}
+
+TEST(ValueIdMap, CopyCtorString) {
+  ValueIdMap<Id, std::string> M;
+  M.try_emplace(id(0), "hello");
+  M.try_emplace(id(2), "world");
+
+  ValueIdMap<Id, std::string> Copy(M);
+  EXPECT_EQ("hello", Copy.at(id(0)));
+  EXPECT_EQ("world", Copy.at(id(2)));
+}
+
+TEST(ValueIdMap, CopyCtorEmpty) {
+  ValueIdMap<Id, int> M;
+  ValueIdMap<Id, int> Copy(M);
+  expectEmpty(Copy);
+}
+
+TEST(ValueIdMap, MoveCtorInt) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(1), 10);
+  M.try_emplace(id(3), 30);
+
+  ValueIdMap<Id, int> Moved(std::move(M));
+  EXPECT_EQ(2u, Moved.size());
+  EXPECT_EQ(10, Moved.at(id(1)));
+  EXPECT_EQ(30, Moved.at(id(3)));
+}
+
+TEST(ValueIdMap, CopyAssign) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(0), 5);
+  ValueIdMap<Id, int> Other;
+  Other = M;
+  EXPECT_EQ(5, Other.at(id(0)));
+}
+
+TEST(ValueIdMap, MoveAssign) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(0), 5);
+  ValueIdMap<Id, int> Other;
+  Other = std::move(M);
+  EXPECT_EQ(5, Other.at(id(0)));
+}
+
+TEST(ValueIdMap, SelfAssign) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(0), 42);
+  M = M; // NOLINT(clang-diagnostic-self-assign-overloaded)
+  EXPECT_EQ(42, M.at(id(0)));
+}
+
+// ── Reallocation (grow)
+// ───────────────────────────────────────────────────────
+
+TEST(ValueIdMap, GrowTrivial) {
+  // Insert enough keys to force multiple reallocations
+  ValueIdMap<Id, int> M(4);
+  for (uint32_t I = 0; I < 100; ++I) {
+    M.try_emplace(id(I), int(I));
+  }
+  EXPECT_EQ(100u, M.size());
+  for (uint32_t I = 0; I < 100; ++I) {
+    EXPECT_EQ(int(I), M.at(id(I)));
+  }
+}
+
+TEST(ValueIdMap, GrowNonTrivial) {
+  // std::string is not trivially relocatable; exercises the move path in grow()
+  ValueIdMap<Id, std::string> M(4);
+  for (uint32_t I = 0; I < 100; ++I) {
+    M.try_emplace(id(I), std::to_string(I));
+  }
+  EXPECT_EQ(100u, M.size());
+  for (uint32_t I = 0; I < 100; ++I) {
+    EXPECT_EQ(std::to_string(I), M.at(id(I)));
+  }
+}
+
+TEST(ValueIdMap, GrowSparseKeys) {
+  // Sparse insertion: only a few high-valued keys, triggering capacity growth
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(0), 0);
+  M.try_emplace(id(63), 63);
+  M.try_emplace(id(127), 127);
+  EXPECT_EQ(3u, M.size());
+  EXPECT_EQ(0, M.at(id(0)));
+  EXPECT_EQ(63, M.at(id(63)));
+  EXPECT_EQ(127, M.at(id(127)));
+}
+
+// ── Swap
+// ──────────────────────────────────────────────────────────────────────
+
+TEST(ValueIdMap, Swap) {
+  ValueIdMap<Id, int> A;
+  A.try_emplace(id(1), 10);
+  ValueIdMap<Id, int> B;
+  B.try_emplace(id(2), 20);
+  B.try_emplace(id(3), 30);
+
+  swap(A, B);
+  EXPECT_EQ(2u, A.size());
+  EXPECT_EQ(20, A.at(id(2)));
+  EXPECT_EQ(30, A.at(id(3)));
+  EXPECT_EQ(1u, B.size());
+  EXPECT_EQ(10, B.at(id(1)));
+}
+
+// ── reserve
+// ───────────────────────────────────────────────────────────────────
+
+TEST(ValueIdMap, ReserveNoConstruct) {
+  ValueIdMap<Id, int> M;
+  M.reserve(64);
+  expectEmpty(M);
+  EXPECT_FALSE(M.contains(id(0)));
+  // Inserting within reserved capacity should not reallocate
+  M.try_emplace(id(10), 100);
+  EXPECT_EQ(100, M.at(id(10)));
+}
+
+int main(int Argc, char **Argv) {
+  ::testing::InitGoogleTest(&Argc, Argv);
+  return RUN_ALL_TESTS();
+}